""" 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"]