Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+384
View File
@@ -0,0 +1,384 @@
"""
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"]