Files
2026-11-02 22:54:14 +08:00

385 lines
14 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
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"]