385 lines
14 KiB
Python
385 lines
14 KiB
Python
"""
|
||
glm_parser.py - ChatGLM SSE response parser.
|
||
|
||
Observed stream traits:
|
||
- content-type: text/event-stream
|
||
- each SSE block is carried in a data: line with a JSON payload
|
||
- think/tool_calls/text/system_error are all emitted through parts[*].content[*]
|
||
- text payloads are full rendered text snapshots, not pure deltas
|
||
- stream ends when a text part status becomes finish or top-level status becomes finish
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import re
|
||
from typing import Any, Dict, List
|
||
|
||
from app.core.config import logger
|
||
from .base import ResponseParser
|
||
|
||
|
||
class GLMParser(ResponseParser):
|
||
"""Parse ChatGLM SSE streams while ignoring think/tool-call noise."""
|
||
|
||
_TERMINAL_STATUSES = {"finish", "finished", "intervene", "intervened"}
|
||
_PPT_FOLLOWUP_COMMANDS = {"change_mode_to_engine_ppt"}
|
||
_PPT_TEMPLATE_MARKERS = ('"theme"', '"background"', '"palette"')
|
||
_HIDDEN_REPAIR_TEXT_PATTERNS = (
|
||
"xml-style tool call",
|
||
"could not be parsed into a valid declared tool",
|
||
"could not be parsed into valid tool_calls",
|
||
"validation errors",
|
||
"the rejected assistant reply was",
|
||
)
|
||
_THINK_REASONING_PREFIX_RE = re.compile(
|
||
r"^\s*(let me\b|looking at\b|the user has\b|让我|我来|先分析|仔细分析)",
|
||
re.IGNORECASE,
|
||
)
|
||
_EMBEDDED_REPLY_LABEL_RE = re.compile(
|
||
r"(?:the rejected assistant reply was|the rejected response was|被拒绝的响应是|被拒绝的助手回复是)\s*[::]?\s*```",
|
||
re.IGNORECASE,
|
||
)
|
||
_VISIBLE_MARKERS = ("<render", "<segment", "<context_summary", "<q>", "<act>", "<inner>", "<aside>", "<meme")
|
||
|
||
def __init__(self) -> None:
|
||
self._last_raw_length = 0
|
||
self._pending = ""
|
||
self._rendered_text = ""
|
||
self._think_text = ""
|
||
self._has_seen_visible_text = False
|
||
self._saw_hidden_repair_flow = False
|
||
self._saw_only_think_payloads = False
|
||
self._awaiting_ppt_followup = False
|
||
self._deferred_followup_text = ""
|
||
self._ppt_followup_command = ""
|
||
|
||
def reset(self) -> None:
|
||
self._last_raw_length = 0
|
||
self._last_raw_response = ""
|
||
self._pending = ""
|
||
self._rendered_text = ""
|
||
self._think_text = ""
|
||
self._has_seen_visible_text = False
|
||
self._saw_hidden_repair_flow = False
|
||
self._saw_only_think_payloads = False
|
||
self._awaiting_ppt_followup = False
|
||
self._deferred_followup_text = ""
|
||
self._ppt_followup_command = ""
|
||
|
||
def prepare_for_followup_stream(self) -> None:
|
||
awaiting_ppt_followup = self._awaiting_ppt_followup
|
||
ppt_followup_command = self._ppt_followup_command
|
||
self.reset()
|
||
self._awaiting_ppt_followup = awaiting_ppt_followup
|
||
self._ppt_followup_command = ppt_followup_command
|
||
|
||
def parse_chunk(self, raw_response: str) -> Dict[str, Any]:
|
||
result: Dict[str, Any] = {
|
||
"content": "",
|
||
"images": [],
|
||
"done": False,
|
||
"error": None,
|
||
}
|
||
|
||
try:
|
||
if isinstance(raw_response, (bytes, bytearray)):
|
||
raw_response = raw_response.decode("utf-8", errors="ignore")
|
||
elif not isinstance(raw_response, str):
|
||
raw_response = str(raw_response)
|
||
|
||
new_data = self._prepare_incremental_raw_response(raw_response)
|
||
if not new_data:
|
||
return result
|
||
|
||
content, done = self._consume_new_data(new_data)
|
||
if content:
|
||
result["content"] = content
|
||
result["done"] = done
|
||
except Exception as e:
|
||
logger.debug(f"[GLMParser] parse exception: {e}")
|
||
result["error"] = str(e)
|
||
|
||
return result
|
||
|
||
def _consume_new_data(self, new_data: str) -> tuple[str, bool]:
|
||
normalized = (self._pending + new_data).replace("\r\n", "\n")
|
||
if not normalized:
|
||
return "", False
|
||
|
||
blocks = normalized.split("\n\n")
|
||
if normalized.endswith("\n\n"):
|
||
self._pending = ""
|
||
complete_blocks = [block for block in blocks if block.strip()]
|
||
else:
|
||
self._pending = blocks.pop() if blocks else normalized
|
||
complete_blocks = [block for block in blocks if block.strip()]
|
||
|
||
content_parts: List[str] = []
|
||
done = False
|
||
|
||
for block in complete_blocks:
|
||
block_content, block_done = self._parse_event_block(block)
|
||
if block_content:
|
||
content_parts.append(block_content)
|
||
if block_done:
|
||
done = True
|
||
|
||
return "".join(content_parts), done
|
||
|
||
def _parse_event_block(self, block: str) -> tuple[str, bool]:
|
||
data_lines: List[str] = []
|
||
|
||
for raw_line in block.split("\n"):
|
||
line = raw_line.strip()
|
||
if not line:
|
||
continue
|
||
if line.startswith("data:"):
|
||
data_lines.append(line[5:].strip())
|
||
|
||
payload = "\n".join(data_lines).strip()
|
||
if not payload:
|
||
return "", False
|
||
|
||
try:
|
||
data = json.loads(payload)
|
||
except json.JSONDecodeError:
|
||
return "", False
|
||
|
||
if not isinstance(data, dict):
|
||
return "", False
|
||
|
||
return self._extract_payload(data)
|
||
|
||
def _extract_payload(self, data: Dict[str, Any]) -> tuple[str, bool]:
|
||
top_status = str(data.get("status") or "").strip().lower()
|
||
last_error = data.get("last_error")
|
||
intervene_text = self._extract_intervene_text(last_error)
|
||
if intervene_text and self._looks_like_hidden_repair_text(intervene_text):
|
||
intervene_text = ""
|
||
parts = data.get("parts")
|
||
if not isinstance(parts, list) or not parts:
|
||
if self._awaiting_ppt_followup and top_status in self._TERMINAL_STATUSES:
|
||
snapshot = self._resolve_deferred_followup_text()
|
||
if snapshot:
|
||
delta = self._compute_delta(self._rendered_text, snapshot)
|
||
self._rendered_text = snapshot
|
||
self._has_seen_visible_text = True
|
||
return delta, True
|
||
return "", False
|
||
if intervene_text and top_status in self._TERMINAL_STATUSES:
|
||
delta = self._compute_delta(self._rendered_text, intervene_text)
|
||
self._rendered_text = intervene_text
|
||
if intervene_text:
|
||
self._has_seen_visible_text = True
|
||
return delta, True
|
||
return "", bool(self._has_seen_visible_text and top_status in self._TERMINAL_STATUSES)
|
||
|
||
visible_snapshot = self._rendered_text
|
||
saw_visible_text_in_payload = False
|
||
saw_think_in_payload = False
|
||
done = bool(self._has_seen_visible_text and top_status in self._TERMINAL_STATUSES)
|
||
|
||
for part in parts:
|
||
if not isinstance(part, dict):
|
||
continue
|
||
|
||
part_status = str(part.get("status") or "").strip().lower()
|
||
|
||
content_items = part.get("content")
|
||
if not isinstance(content_items, list):
|
||
continue
|
||
|
||
for item in content_items:
|
||
if not isinstance(item, dict):
|
||
continue
|
||
item_type = str(item.get("type") or "").strip().lower()
|
||
if item_type == "system_error":
|
||
self._handle_system_error_item(item, part)
|
||
continue
|
||
if item_type == "think":
|
||
think_text = str(item.get("think") or self._think_text)
|
||
self._think_text = think_text
|
||
saw_think_in_payload = True
|
||
if self._awaiting_ppt_followup and think_text.strip():
|
||
self._awaiting_ppt_followup = False
|
||
self._deferred_followup_text = ""
|
||
embedded_snapshot = self._extract_embedded_visible_snapshot(think_text)
|
||
if embedded_snapshot:
|
||
visible_snapshot = embedded_snapshot
|
||
saw_visible_text_in_payload = True
|
||
self._has_seen_visible_text = True
|
||
if self._looks_like_hidden_repair_text(think_text):
|
||
self._saw_hidden_repair_flow = True
|
||
continue
|
||
if item_type == "tool_calls":
|
||
continue
|
||
if item_type != "text":
|
||
continue
|
||
|
||
snapshot = str(item.get("text") or "")
|
||
if self._awaiting_ppt_followup:
|
||
if snapshot:
|
||
self._deferred_followup_text = snapshot
|
||
if part_status in self._TERMINAL_STATUSES:
|
||
snapshot = self._resolve_deferred_followup_text()
|
||
if snapshot:
|
||
visible_snapshot = snapshot
|
||
saw_visible_text_in_payload = True
|
||
self._has_seen_visible_text = True
|
||
done = True
|
||
continue
|
||
if snapshot:
|
||
visible_snapshot = snapshot
|
||
saw_visible_text_in_payload = True
|
||
self._has_seen_visible_text = True
|
||
if part_status in self._TERMINAL_STATUSES and (snapshot or self._has_seen_visible_text):
|
||
done = True
|
||
|
||
if saw_think_in_payload and not saw_visible_text_in_payload:
|
||
self._saw_only_think_payloads = True
|
||
|
||
if intervene_text and done and not visible_snapshot:
|
||
visible_snapshot = intervene_text
|
||
|
||
delta = self._compute_delta(self._rendered_text, visible_snapshot)
|
||
self._rendered_text = visible_snapshot
|
||
return delta, done
|
||
|
||
def should_fallback_to_dom_when_no_visible_content(self) -> bool:
|
||
return bool(
|
||
not self._has_seen_visible_text
|
||
and (self._saw_hidden_repair_flow or self._saw_only_think_payloads)
|
||
)
|
||
|
||
def should_wait_for_followup_stream(self) -> bool:
|
||
return bool(self._awaiting_ppt_followup)
|
||
|
||
@classmethod
|
||
def _looks_like_hidden_repair_text(cls, text: Any) -> bool:
|
||
normalized = str(text or "").strip()
|
||
if not normalized:
|
||
return False
|
||
|
||
lowered = normalized.lower()
|
||
if any(marker in lowered for marker in cls._HIDDEN_REPAIR_TEXT_PATTERNS):
|
||
return True
|
||
|
||
if cls._THINK_REASONING_PREFIX_RE.search(normalized):
|
||
if "<segment>" in normalized or "<context_summary>" in normalized:
|
||
return True
|
||
if "\\u003csegment\\u003e" in normalized or "\\u003ccontext_summary\\u003e" in normalized:
|
||
return True
|
||
|
||
return False
|
||
|
||
def export_debug_data(self, raw_response: str = "") -> Dict[str, Any]:
|
||
return {
|
||
"has_seen_visible_text": bool(self._has_seen_visible_text),
|
||
"rendered_text_len": len(self._rendered_text or ""),
|
||
"think_text_len": len(self._think_text or ""),
|
||
"saw_hidden_repair_flow": bool(self._saw_hidden_repair_flow),
|
||
"saw_only_think_payloads": bool(self._saw_only_think_payloads),
|
||
"awaiting_ppt_followup": bool(self._awaiting_ppt_followup),
|
||
"ppt_followup_command": self._ppt_followup_command,
|
||
"deferred_followup_text_len": len(self._deferred_followup_text or ""),
|
||
}
|
||
|
||
def _handle_system_error_item(self, item: Dict[str, Any], part: Dict[str, Any]) -> None:
|
||
metadata = part.get("meta_data")
|
||
if not isinstance(metadata, dict):
|
||
metadata = {}
|
||
command = str(
|
||
metadata.get("failedCommand") or item.get("failedCommand") or ""
|
||
).strip()
|
||
if command not in self._PPT_FOLLOWUP_COMMANDS:
|
||
return
|
||
|
||
self._awaiting_ppt_followup = True
|
||
self._deferred_followup_text = ""
|
||
self._ppt_followup_command = command
|
||
|
||
def _resolve_deferred_followup_text(self) -> str:
|
||
snapshot = self._deferred_followup_text
|
||
self._deferred_followup_text = ""
|
||
if not snapshot or self._looks_like_ppt_template(snapshot):
|
||
return ""
|
||
self._awaiting_ppt_followup = False
|
||
return snapshot
|
||
|
||
@classmethod
|
||
def _looks_like_ppt_template(cls, text: Any) -> bool:
|
||
normalized = str(text or "").strip().lower()
|
||
if normalized.startswith("```json"):
|
||
normalized = normalized[7:].lstrip()
|
||
elif normalized.startswith("```"):
|
||
normalized = normalized[3:].lstrip()
|
||
if not normalized.startswith("{"):
|
||
return False
|
||
return sum(marker in normalized for marker in cls._PPT_TEMPLATE_MARKERS) >= 2
|
||
|
||
@classmethod
|
||
def _extract_embedded_visible_snapshot(cls, text: Any) -> str:
|
||
normalized = str(text or "")
|
||
if not normalized:
|
||
return ""
|
||
|
||
match = cls._EMBEDDED_REPLY_LABEL_RE.search(normalized)
|
||
if not match:
|
||
return ""
|
||
|
||
body = normalized[match.end():]
|
||
if not body:
|
||
return ""
|
||
|
||
fence_end = body.find("```")
|
||
candidate = body[:fence_end] if fence_end >= 0 else body
|
||
candidate = candidate.strip()
|
||
if not candidate:
|
||
return ""
|
||
|
||
lowered = candidate.lower()
|
||
if lowered.startswith("<think"):
|
||
return ""
|
||
if any(marker in lowered for marker in cls._HIDDEN_REPAIR_TEXT_PATTERNS):
|
||
return ""
|
||
if not any(marker in lowered for marker in cls._VISIBLE_MARKERS):
|
||
return ""
|
||
return candidate
|
||
|
||
@staticmethod
|
||
def _extract_intervene_text(last_error: Any) -> str:
|
||
if not isinstance(last_error, dict):
|
||
return ""
|
||
text = last_error.get("intervene_text")
|
||
if not isinstance(text, str):
|
||
return ""
|
||
return text.strip()
|
||
|
||
@staticmethod
|
||
def _compute_delta(previous: str, current: str) -> str:
|
||
if current == previous:
|
||
return ""
|
||
if previous and current.startswith(previous):
|
||
return current[len(previous):]
|
||
return current
|
||
|
||
@classmethod
|
||
def get_id(cls) -> str:
|
||
return "glm"
|
||
|
||
@classmethod
|
||
def get_name(cls) -> str:
|
||
return "GLM"
|
||
|
||
@classmethod
|
||
def get_description(cls) -> str:
|
||
return "Parse ChatGLM SSE streams and emit assistant text deltas while ignoring think/tool-call events"
|
||
|
||
@classmethod
|
||
def get_supported_patterns(cls) -> List[str]:
|
||
return ["/chatglm/backend-api/assistant/stream", "assistant/stream"]
|
||
|
||
|
||
__all__ = ["GLMParser"]
|