fix parser

Author: luukunn

fastdeploy/entrypoints/openai/tool_parsers/ernie_x1_tool_parser.py

@@ -58,7 +58,7 @@ def __init__(self, tokenizer):
         self.tool_call_start_token_id = self.vocab.get(self.tool_call_start_token)
         self.tool_call_end_token_id = self.vocab.get(self.tool_call_end_token)
         if self.tool_call_start_token_id is None or self.tool_call_end_token_id is None:
-            raise RuntimeError("Ernie x1 Tool parser could not locate tool call start/end " "tokens in the tokenizer!")
+            raise RuntimeError("Ernie x1 Tool parser could not locate tool call start/end tokens in the tokenizer!")
 
         if not self.model_tokenizer:
             raise ValueError(

fastdeploy/reasoning/ernie_vl_reasoning_parsers.py

@@ -53,7 +53,7 @@ def __init__(self, tokenizer):
 
         if missing_tokens:
             raise RuntimeError(
-                f"Could not find the following token ids in tokenizer vocabulary: {', '.join(missing_tokens)}"
+                f"ernie vl reasoning parser could not find the following token ids in tokenizer vocabulary: {', '.join(missing_tokens)}"
             )
         self.token_status_mapping = {
             self.think_start_token_id: "think_start",

fastdeploy/reasoning/ernie_x1_reasoning_parsers.py

@@ -54,11 +54,11 @@ def __init__(self, tokenizer):
             token_id = self.vocab.get(token_value)
             setattr(self, f"{name}_id", token_id)
             if token_id is None:
-                missing_tokens.append(f"{name.replace('_', ' ')} token")
+                missing_tokens.append(token_value)
 
         if missing_tokens:
             raise RuntimeError(
-                f"Could not find the following token ids in tokenizer vocabulary: {', '.join(missing_tokens)}"
+                f"ernie x1 reasoning parser could not find the following token ids in tokenizer vocabulary: {', '.join(missing_tokens)}"
             )
 
         self.token_status_mapping = {
@@ -106,22 +106,33 @@ def extract_reasoning_content_streaming(
             return None
 
         if model_status == "think_start":
-            if self.think_end_token_id not in current_token_ids:
-                return DeltaMessage(reasoning_content=delta_text)
-            else:
+            if self.think_end_token_id in delta_token_ids:
+                reasoning_content = ""
+                response_content = ""
+                end_index = delta_text.find(self.think_end_token)
+                reasoning_content = delta_text[:end_index]
+                response_start_pos = delta_text.find(self.response_start_token)
+                if response_start_pos != -1:
+                    response_content = self._extract_response_content(
+                        delta_text[response_start_pos + len(self.response_start_token) :]
+                    )
+                return DeltaMessage(reasoning_content=reasoning_content, content=response_content)
+            elif self.think_end_token_id in previous_token_ids:
                 if (
-                    self.response_start_token_id in current_token_ids
-                    and self.response_end_token_id not in current_token_ids
+                    self.response_start_token_id in previous_token_ids
+                    and self.response_end_token_id not in previous_token_ids
                 ):
                     return DeltaMessage(content=delta_text)
+            else:
+                return DeltaMessage(reasoning_content=delta_text)
         elif model_status == "think_end":
             if (
-                self.response_start_token_id in current_token_ids
+                self.response_start_token_id in previous_token_ids
                 and self.response_end_token_id not in current_token_ids
             ):
                 return DeltaMessage(content=delta_text)
         elif model_status == "response_start":
-            if self.response_end_token_id not in current_token_ids:
+            if self.response_end_token_id not in previous_token_ids:
                 return DeltaMessage(content=delta_text)
 
         return None
@@ -130,33 +141,29 @@ def extract_reasoning_content(
         self, model_output: str, request: ChatCompletionRequest, model_status: str
     ) -> Tuple[str, str]:
         """
-        Optimized batch version of the enhanced parser.
-        Preserves newlines in both reasoning and response content,
-        only removing the single newline before closing tags.
+        优化版解析器。保留推理和响应内容中的换行符，
+        仅删除闭合标签前的单个换行符。
         """
         reasoning_content = ""
         response_content = ""
 
-        if model_status == "think_start":
-            think_end_pos = model_output.find(self.think_end_token)
-            if think_end_pos != -1:
-                reasoning_content = model_output[:think_end_pos]
-                remaining = model_output[think_end_pos + len(self.think_end_token) :].lstrip("\n")
-
-                # Determine if remaining content is a response or tool call
-                if remaining.startswith(self.response_start_token):
-                    response_start_len = len(self.response_start_token)
-                    response_content = self._extract_response_content(remaining[response_start_len:])
-                elif remaining.startswith(self.tool_call_start_token):
-                    pass  # No response content
+        if model_status in ["think_start", "think_end"]:
+            if model_status == "think_start":
+                think_end_pos = model_output.find(self.think_end_token)
+                if think_end_pos != -1:
+                    reasoning_content = model_output[:think_end_pos]
+                    remaining = model_output[think_end_pos + len(self.think_end_token) :].lstrip("\n")
+                else:
+                    reasoning_content = model_output
+                    remaining = ""
             else:
-                reasoning_content = model_output
+                remaining = model_output.lstrip("\n")
 
-        elif model_status == "think_end":
-            remaining = model_output.lstrip("\n")
-            if remaining.startswith(self.response_start_token):
-                response_start_len = len(self.response_start_token)
-                response_content = self._extract_response_content(remaining[response_start_len:])
+            response_start_pos = remaining.find(self.response_start_token)
+            if response_start_pos != -1:
+                response_content = self._extract_response_content(
+                    remaining[response_start_pos + len(self.response_start_token) :]
+                )
 
         elif model_status == "response_start":
             response_content = self._extract_response_content(model_output)

fastdeploy/reasoning/qwen3_reasoning_parsers.py

@@ -35,24 +35,49 @@ class Qwen3ReasoningParser(ReasoningParser):
 
     def __init__(self, tokenizer):
         super().__init__(tokenizer)
-        self.think_start_token = "<think>"
-        self.think_end_token = "</think>"
+
+        # 定义所有需要检查的token
+        token_definitions = {
+            "think_start_token": "<think>",
+            "think_end_token": "</think>",
+        }
 
         if not self.model_tokenizer:
-            raise ValueError(
-                "The model tokenizer must be passed to the ReasoningParser " "constructor during construction."
+            raise ValueError("The model tokenizer must be passed to the ReasoningParser constructor.")
+
+        missing_tokens = []
+        for name, token_value in token_definitions.items():
+            setattr(self, name, token_value)
+            token_id = self.vocab.get(token_value)
+            setattr(self, f"{name}_id", token_id)
+            if token_id is None:
+                missing_tokens.append(token_value)
+
+        if missing_tokens:
+            raise RuntimeError(
+                f"Qwen3 reasoning parser could not find the following token ids in tokenizer vocabulary: {', '.join(missing_tokens)}"
             )
-
-        self.think_start_token_id = self.vocab.get(self.think_start_token)
-        self.think_end_token_id = self.vocab.get(self.think_end_token)
-        if self.think_end_token_id is None:
-            raise RuntimeError("Qwen3  reasoning parser could not locate think end " "tokens in the tokenizer!")
+        self.token_status_mapping = {
+            self.think_start_token_id: "think_start",
+            self.think_end_token_id: "think_end",
+        }
 
     def is_reasoning_end(self, input_ids: list[int]) -> bool:
         return self.think_end_token_id in input_ids
 
+    def find_last_special_token(self, prompt_token_ids: list[int]) -> int:
+        for i in range(len(prompt_token_ids) - 1, -1, -1):
+            if prompt_token_ids[i] in self.token_status_mapping:
+                return prompt_token_ids[i]
+        return -1
+
     def get_model_status(self, prompt_token_ids: list[int]):
-        return "think_start"
+        special_token_id = self.find_last_special_token(prompt_token_ids)
+
+        if special_token_id == -1:
+            return "think_start"
+
+        return self.token_status_mapping[special_token_id]
 
     def extract_reasoning_content_streaming(
         self,
@@ -75,36 +100,39 @@ def extract_reasoning_content_streaming(
         if len(delta_token_ids) == 1 and (delta_token_ids[0] in [self.think_start_token_id, self.think_end_token_id]):
             return None
 
-        # </think> in delta
-        if self.think_end_token_id in delta_token_ids:
-            # <think> in delta, </think> in delta, extract reasoning content
-            if self.think_start_token_id in delta_token_ids:
+        if model_status == "think_start":
+            # </think> in delta
+            if self.think_end_token_id in delta_token_ids:
+                # <think> in delta, </think> in delta, extract reasoning content
+                if self.think_start_token_id in delta_token_ids:
+                    start_index = delta_text.find(self.think_start_token)
+                    end_index = delta_token_ids.find(self.think_end_token)
+                    reasoning_content = delta_text[start_index + len(self.think_start_token) : end_index]
+                    content = delta_text[end_index + len(self.think_end_token) :]
+                    return DeltaMessage(reasoning_content=reasoning_content, content=content)
+                # <think> in previous, </think> in delta,
+                else:
+                    end_index = delta_text.find(self.think_end_token)
+                    reasoning_content = delta_text[:end_index]
+                    content = delta_text[end_index + len(self.think_end_token) :]
+                    content = content if content else None
+                    return DeltaMessage(reasoning_content=reasoning_content, content=content)
+            # </think> in previous reasoning content continues
+            elif self.think_end_token_id in previous_token_ids:
+                return DeltaMessage(content=delta_text)
+            # <think> in previous
+            elif self.think_start_token_id in previous_token_ids:
+                return DeltaMessage(reasoning_content=delta_text)
+            # <think> in delta
+            elif self.think_start_token_id in delta_token_ids:
                 start_index = delta_text.find(self.think_start_token)
-                end_index = delta_token_ids.find(self.think_end_token)
-                reasoning_content = delta_text[start_index + len(self.think_start_token) : end_index]
-                content = delta_text[end_index + len(self.think_end_token) :]
+                reasoning_content = delta_text[start_index + len(self.think_start_token) :]
+                content = ""
                 return DeltaMessage(reasoning_content=reasoning_content, content=content)
-            # <think> in previous, </think> in delta,
             else:
-                end_index = delta_text.find(self.think_end_token)
-                reasoning_content = delta_text[:end_index]
-                content = delta_text[end_index + len(self.think_end_token) :]
-                content = content if content else None
-                return DeltaMessage(reasoning_content=reasoning_content, content=content)
-        # </think> in previous reasoning content continues
-        elif self.think_end_token_id in previous_token_ids:
-            return DeltaMessage(content=delta_text)
-        # <think> in previous
-        elif self.think_start_token_id in previous_token_ids:
-            return DeltaMessage(reasoning_content=delta_text)
-        # <think> in delta
-        elif self.think_start_token_id in delta_token_ids:
-            start_index = delta_text.find(self.think_start_token)
-            reasoning_content = delta_text[start_index + len(self.think_start_token) :]
-            content = ""
-            return DeltaMessage(reasoning_content=reasoning_content, content=content)
+                return DeltaMessage(reasoning_content=delta_text)
         else:
-            return DeltaMessage(reasoning_content=delta_text)
+            return DeltaMessage(content=delta_text)
 
     def extract_reasoning_content(
         self, model_output: str, request: ChatCompletionRequest, model_status: str
@@ -120,36 +148,39 @@ def extract_reasoning_content(
             tuple[Optional[str], Optional[str]]: reasoning content and content
         """
 
-        # 检查是否包含结束标签
-        if self.think_end_token not in model_output:
-            return None, model_output
-
-        # 检查是否有起始标签
-        if self.think_start_token in model_output:
-            # 标准格式：<think>content</think>answer
-            if self.think_start_token not in model_output or self.think_end_token not in model_output:
-                return None, model_output
-            # Check if the <think> is present in the model output, remove it
-            # if it is present.
-            model_output_parts = model_output.partition(self.think_start_token)
-            model_output = model_output_parts[2] if model_output_parts[1] else model_output_parts[0]
-            # Check if the model output contains the </think> tokens.
-            # If the end token is not found, return the model output as is.
+        if model_status == "think_start":
+            # 检查是否包含结束标签
             if self.think_end_token not in model_output:
                 return None, model_output
 
-            # Extract reasoning content from the model output.
-            reasoning_content, _, content = model_output.partition(self.think_end_token)
-
-            final_content = content or None
-            return reasoning_content, final_content
-        else:
-            # 缺少起始标签的格式：content</think>answer
-            parts = model_output.split(self.think_end_token, 1)
-
-            if len(parts) == 2:
-                reasoning_content = parts[0].strip()
-                final_content = parts[1].strip() if parts[1].strip() else None
+            # 检查是否有起始标签
+            if self.think_start_token in model_output:
+                # 标准格式：<think>content</think>answer
+                if self.think_start_token not in model_output or self.think_end_token not in model_output:
+                    return None, model_output
+                # Check if the <think> is present in the model output, remove it
+                # if it is present.
+                model_output_parts = model_output.partition(self.think_start_token)
+                model_output = model_output_parts[2] if model_output_parts[1] else model_output_parts[0]
+                # Check if the model output contains the </think> tokens.
+                # If the end token is not found, return the model output as is.
+                if self.think_end_token not in model_output:
+                    return None, model_output
+
+                # Extract reasoning content from the model output.
+                reasoning_content, _, content = model_output.partition(self.think_end_token)
+
+                final_content = content or None
                 return reasoning_content, final_content
+            else:
+                # 缺少起始标签的格式：content</think>answer
+                parts = model_output.split(self.think_end_token, 1)
 
-        return None, model_output
+                if len(parts) == 2:
+                    reasoning_content = parts[0].strip()
+                    final_content = parts[1].strip() if parts[1].strip() else None
+                    return reasoning_content, final_content
+
+            return None, model_output
+        else:
+            return None, model_output