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

489 lines
17 KiB
Python

"""
deepseek_parser.py - DeepSeek SSE response parser.
Observed stream traits:
- data: {"v": {"response": {"fragments": [...]}}} initializes fragment state
- thinking mode sends THINK fragments first and answer text later in RESPONSE fragments
- path-less data: {"v": "..."} continues the current fragment's content
- response/status or quasi_status=FINISHED ends the stream
"""
from __future__ import annotations
import json
from typing import Any, Dict, List, Tuple
from app.core.config import logger
from .base import ResponseParser
class DeepSeekParser(ResponseParser):
"""Parse DeepSeek web SSE streams and ignore THINK fragments."""
def __init__(self) -> None:
self._last_raw_length = 0
self._pending = ""
self._fragment_types: List[str] = []
self._fragment_contents: List[str] = []
self._current_fragment_type = ""
self._current_fragment_index = -1
self._debug_records: List[Dict[str, Any]] = []
self._emit_buffer = ""
self._has_seen_visible_response_text = False
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
delta_content, done = self._consume_new_data(new_data)
safe_content = self._drain_safe_output(delta_content, force=done)
if safe_content:
result["content"] = safe_content
result["done"] = done
except Exception as e:
logger.debug(f"[DeepSeekParser] parse exception: {e}")
result["error"] = str(e)
return result
def reset(self) -> None:
self._last_raw_length = 0
self._last_raw_response = ""
self._pending = ""
self._fragment_types = []
self._fragment_contents = []
self._current_fragment_type = ""
self._current_fragment_index = -1
self._debug_records = []
self._emit_buffer = ""
self._has_seen_visible_response_text = False
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]:
event_name = ""
data_lines: List[str] = []
for raw_line in block.split("\n"):
line = raw_line.strip()
if not line:
continue
if line.startswith("event:"):
event_name = line[6:].strip()
elif line.startswith("data:"):
data_lines.append(line[5:].strip())
if event_name in {"ready", "update_session", "title"}:
return "", False
if event_name in {"finish", "close"}:
return "", self._can_accept_done_signal()
payload = "\n".join(data_lines).strip()
if not payload or payload == "{}":
return "", False
try:
data = json.loads(payload)
except json.JSONDecodeError:
return "", False
content, done = self._extract_content(data)
self._record_debug_event(event_name, data, content, done)
return content, done
def _extract_content(self, data: Dict[str, Any]) -> Tuple[str, bool]:
path = str(data.get("p", "") or "")
operation = str(data.get("o", "") or "")
value = data.get("v")
if operation == "BATCH" and isinstance(value, list):
return self._extract_batch_content(value)
if isinstance(value, dict):
response = value.get("response")
if isinstance(response, dict):
return self._extract_response_object(response)
if self._is_done_signal(path, value):
return "", self._can_accept_done_signal()
if self._is_fragment_append(path, operation, value):
return self._register_fragments(value), False
if self._is_fragment_content_patch(path, value):
fragment_index = self._resolve_fragment_index(path)
fragment_type = self._resolve_fragment_type(path)
delta_text = self._apply_fragment_content_update(fragment_index, value)
if self._should_emit_fragment_text(fragment_type):
self._mark_visible_response_text(fragment_type, delta_text)
return delta_text, False
return "", False
if not path and not operation and isinstance(value, str):
self._append_to_current_fragment(value)
if self._should_emit_fragment_text(self._current_fragment_type):
self._mark_visible_response_text(self._current_fragment_type, value)
return value, False
return "", False
return "", False
def _extract_batch_content(self, operations: List[Dict[str, Any]]) -> Tuple[str, bool]:
content_parts: List[str] = []
saw_done_signal = False
for op in operations:
if not isinstance(op, dict):
continue
path = str(op.get("p", "") or "")
operation = str(op.get("o", "") or "")
value = op.get("v")
if self._is_done_signal(path, value):
saw_done_signal = True
continue
if self._is_fragment_append(path, operation, value):
fragment_content = self._register_fragments(value)
if fragment_content:
content_parts.append(fragment_content)
continue
if self._is_fragment_content_patch(path, value):
fragment_index = self._resolve_fragment_index(path)
fragment_type = self._resolve_fragment_type(path)
delta_text = self._apply_fragment_content_update(fragment_index, value)
if self._should_emit_fragment_text(fragment_type):
self._mark_visible_response_text(fragment_type, delta_text)
content_parts.append(delta_text)
return "".join(content_parts), bool(saw_done_signal and self._can_accept_done_signal())
def _extract_response_object(self, response: Dict[str, Any]) -> Tuple[str, bool]:
fragments = response.get("fragments")
content = self._register_fragments(fragments) if isinstance(fragments, list) else ""
done = False
if self._can_accept_done_signal():
if self._is_done_signal("response/status", response.get("status")):
done = True
if self._is_done_signal("response/quasi_status", response.get("quasi_status")):
done = True
return content, done
def _register_fragments(self, fragments: List[Dict[str, Any]]) -> str:
content_parts: List[str] = []
for fragment in fragments:
if not isinstance(fragment, dict):
continue
fragment_type = str(fragment.get("type", "") or "").upper()
self._fragment_types.append(fragment_type)
self._fragment_contents.append("")
self._current_fragment_index = len(self._fragment_types) - 1
if fragment_type:
self._current_fragment_type = fragment_type
text = fragment.get("content", "")
if isinstance(text, str):
self._fragment_contents[self._current_fragment_index] = text
if text and self._should_emit_fragment_text(fragment_type):
self._mark_visible_response_text(fragment_type, text)
content_parts.append(text)
return "".join(content_parts)
def _resolve_fragment_index(self, path: str) -> int:
marker = "response/fragments/"
if marker not in path or not self._fragment_types:
return self._current_fragment_index
index_part = path.split(marker, 1)[1].split("/", 1)[0]
if index_part == "-1":
return len(self._fragment_types) - 1
try:
index = int(index_part)
except ValueError:
return self._current_fragment_index
if index < 0:
index += len(self._fragment_types)
if 0 <= index < len(self._fragment_types):
return index
return self._current_fragment_index
def _resolve_fragment_type(self, path: str) -> str:
fragment_index = self._resolve_fragment_index(path)
if 0 <= fragment_index < len(self._fragment_types):
fragment_type = self._fragment_types[fragment_index]
self._current_fragment_index = fragment_index
self._current_fragment_type = fragment_type
return fragment_type
return self._current_fragment_type
def _append_to_current_fragment(self, delta_text: str) -> None:
if not isinstance(delta_text, str) or not delta_text:
return
if 0 <= self._current_fragment_index < len(self._fragment_contents):
self._fragment_contents[self._current_fragment_index] += delta_text
def _apply_fragment_content_update(self, fragment_index: int, incoming_text: str) -> str:
if not isinstance(incoming_text, str) or not incoming_text:
return ""
if not (0 <= fragment_index < len(self._fragment_contents)):
return incoming_text
previous_text = self._fragment_contents[fragment_index]
new_text, delta_text = self._merge_fragment_text(previous_text, incoming_text)
self._fragment_contents[fragment_index] = new_text
self._current_fragment_index = fragment_index
return delta_text
@staticmethod
def _merge_fragment_text(previous_text: str, incoming_text: str) -> Tuple[str, str]:
previous = previous_text if isinstance(previous_text, str) else ""
incoming = incoming_text if isinstance(incoming_text, str) else ""
if not previous:
return incoming, incoming
if not incoming:
return previous, ""
if incoming.startswith(previous):
return incoming, incoming[len(previous) :]
if previous.endswith(incoming):
return previous, ""
common_prefix_len = 0
max_prefix_len = min(len(previous), len(incoming))
while common_prefix_len < max_prefix_len and previous[common_prefix_len] == incoming[common_prefix_len]:
common_prefix_len += 1
if common_prefix_len > 0:
return incoming, incoming[common_prefix_len:]
return previous + incoming, incoming
@staticmethod
def _is_fragment_append(path: str, operation: str, value: Any) -> bool:
if not isinstance(value, list):
return False
return operation == "APPEND" and path in {"response/fragments", "fragments"}
@staticmethod
def _is_fragment_content_patch(path: str, value: Any) -> bool:
return isinstance(value, str) and "fragments/" in path and path.endswith("/content")
@staticmethod
def _is_done_signal(path: str, value: Any) -> bool:
if not isinstance(value, str):
return False
if value.upper() != "FINISHED":
return False
return path.endswith("status") or path.endswith("quasi_status")
def _should_emit_fragment_text(self, fragment_type: str) -> bool:
if not self._fragment_types:
return True
return fragment_type == "RESPONSE"
def _mark_visible_response_text(self, fragment_type: str, text: str) -> None:
if not isinstance(text, str) or not text:
return
if self._should_emit_fragment_text(fragment_type):
self._has_seen_visible_response_text = True
def _can_accept_done_signal(self) -> bool:
return bool(self._has_seen_visible_response_text)
def _drain_safe_output(self, delta_text: str, force: bool = False) -> str:
if delta_text:
self._emit_buffer += delta_text
if not self._emit_buffer:
return ""
if force:
flushed = self._emit_buffer
self._emit_buffer = ""
return flushed
safe_index = self._find_last_safe_emit_index(self._emit_buffer)
if safe_index <= 0:
return ""
flushed = self._emit_buffer[:safe_index]
self._emit_buffer = self._emit_buffer[safe_index:]
return flushed
@staticmethod
def _find_last_safe_emit_index(text: str) -> int:
if not text:
return 0
inside_tag = False
quote_char = ""
last_safe_index = 0
for index, char in enumerate(text):
if inside_tag:
if quote_char:
if char == quote_char:
quote_char = ""
continue
if char in {'"', "'"}:
quote_char = char
continue
if char == ">":
inside_tag = False
last_safe_index = index + 1
continue
if char == "<":
inside_tag = True
continue
last_safe_index = index + 1
if inside_tag:
last_open = text.rfind("<")
if last_open != -1:
return last_open
return last_safe_index
def export_debug_data(self, raw_response: str = "") -> Dict[str, Any]:
return {
"parser": self.get_id(),
"fragment_types": list(self._fragment_types),
"fragment_lengths": [len(item) for item in self._fragment_contents],
"current_fragment_type": self._current_fragment_type,
"current_fragment_index": self._current_fragment_index,
"has_seen_visible_response_text": bool(self._has_seen_visible_response_text),
"debug_records": self._debug_records[-120:],
"raw_response_preview": str(raw_response or "")[:12000],
}
def export_debug_snapshot(self, raw_response: str = "") -> str:
import time
from pathlib import Path
payload = {
**self.export_debug_data(raw_response),
"exported_at": int(time.time()),
}
path = Path("logs") / "deepseek_parser_debug.json"
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(
json.dumps(payload, ensure_ascii=False, indent=2) + "\n",
encoding="utf-8",
newline="\n",
)
return str(path)
def _record_debug_event(self, event_name: str, data: Dict[str, Any], content: str, done: bool) -> None:
value = data.get("v")
path = str(data.get("p", "") or "")
operation = str(data.get("o", "") or "")
record: Dict[str, Any] = {
"event": str(event_name or ""),
"path": path,
"op": operation,
"done": bool(done),
"content_len": len(content or ""),
"content_preview": str(content or "")[:240],
"value_type": type(value).__name__,
"fragment_count": len(self._fragment_types),
"current_fragment_type": self._current_fragment_type,
"current_fragment_index": self._current_fragment_index,
}
if isinstance(value, str):
record["value_len"] = len(value)
record["value_preview"] = value[:240]
elif isinstance(value, list):
record["value_len"] = len(value)
elif isinstance(value, dict):
response = value.get("response") if isinstance(value.get("response"), dict) else {}
fragments = response.get("fragments") if isinstance(response.get("fragments"), list) else []
record["response_keys"] = list(response.keys())[:12]
record["response_fragment_count"] = len(fragments)
if fragments:
record["response_fragment_types"] = [
str(fragment.get("type", "") or "").upper()
for fragment in fragments[:8]
if isinstance(fragment, dict)
]
self._debug_records.append(record)
if len(self._debug_records) > 200:
self._debug_records = self._debug_records[-200:]
@classmethod
def get_id(cls) -> str:
return "deepseek"
@classmethod
def get_name(cls) -> str:
return "DeepSeek API"
@classmethod
def get_description(cls) -> str:
return "Parse DeepSeek SSE streams and ignore THINK fragments"
@classmethod
def get_supported_patterns(cls) -> List[str]:
return ["**/api/v0/chat/completion**"]
__all__ = ["DeepSeekParser"]