""" grok_parser.py - Grok newline-delimited JSON stream parser. Observed stream traits: - content-type: application/json - body is a growing sequence of JSON objects separated by newlines - visible answer tokens arrive as result.token with isThinking=false - final assistant snapshot arrives as result.modelResponse - completed reload/fetch snapshots can arrive as responses[*].message - generated images can be exposed via generatedImageUrls / imageAttachments """ from __future__ import annotations import json from datetime import datetime, timezone from typing import Any, Dict, Iterable, List, Tuple from app.core.config import logger from .base import ResponseParser class GrokParser(ResponseParser): """Parse Grok web NDJSON response streams.""" _IMAGE_URL_KEYS = { "url", "downloadurl", "download_url", "imageurl", "image_url", "imageuri", "image_uri", "uri", } def __init__(self) -> None: self._last_raw_length = 0 self._pending = "" self._rendered_content = "" self._seen_image_refs: set[str] = set() self._media_generation_state: Dict[str, Any] = {} 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") snapshot = self._load_json_snapshot(raw_response) if snapshot is not None: snapshot_payload, snapshot_text = snapshot if snapshot_text == getattr(self, "_last_raw_response", ""): return result self._last_raw_length = len(snapshot_text) self._last_raw_response = snapshot_text delta_content, images, done = self._consume_json_snapshot(snapshot_payload) if delta_content: result["content"] = delta_content if images: result["images"] = images result["done"] = done return result if 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, images, done = self._consume_new_data(new_data) if delta_content: result["content"] = delta_content if images: result["images"] = images result["done"] = done except Exception as e: logger.debug(f"[GrokParser] 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._rendered_content = "" self._seen_image_refs.clear() self._media_generation_state = {} def get_media_generation_state( self, raw_response: str = "", parse_result: Dict[str, Any] | None = None, ) -> Dict[str, Any]: return dict(self._media_generation_state or {}) def _consume_new_data(self, new_data: str) -> Tuple[str, List[Dict[str, Any]], bool]: previous_content = self._rendered_content complete_lines = self._extract_complete_lines(new_data) complete_lines.extend(self._drain_parseable_pending_line()) if not complete_lines: return "", [], False images: List[Dict[str, Any]] = [] done = False for raw_line in complete_lines: line = raw_line.strip() if not line: continue try: payload = json.loads(line) except json.JSONDecodeError: continue line_images, line_done = self._consume_payload(payload) if line_images: images.extend(line_images) if line_done: done = True delta = self._compute_delta(previous_content, self._rendered_content) return delta, images, done def _consume_json_snapshot(self, payload: Any) -> Tuple[str, List[Dict[str, Any]], bool]: previous_content = self._rendered_content images, done = self._consume_payload(payload) delta = self._compute_delta(previous_content, self._rendered_content) return delta, images, done @staticmethod def _load_json_snapshot(raw_response: Any) -> Tuple[Any, str] | None: if isinstance(raw_response, (dict, list)): snapshot_text = json.dumps( raw_response, ensure_ascii=False, sort_keys=True, default=str, ) return raw_response, snapshot_text if not isinstance(raw_response, str): return None text = raw_response.strip() if not text or text[0] not in "[{": return None try: payload = json.loads(text) except json.JSONDecodeError: return None if not isinstance(payload, (dict, list)): return None return payload, text def _extract_complete_lines(self, new_data: str) -> List[str]: normalized = (self._pending + str(new_data or "")).replace("\r\n", "\n").replace("\r", "\n") if not normalized: return [] parts = normalized.split("\n") if normalized.endswith("\n"): self._pending = "" return parts[:-1] self._pending = parts.pop() if parts else normalized return parts def _drain_parseable_pending_line(self) -> List[str]: pending = str(self._pending or "").strip() if not pending: return [] try: json.loads(pending) except json.JSONDecodeError: return [] self._pending = "" return [pending] def _consume_payload(self, payload: Any) -> Tuple[List[Dict[str, Any]], bool]: if isinstance(payload, list): if any(isinstance(item, dict) and "message" in item for item in payload): return self._consume_responses_snapshot(payload) images: List[Dict[str, Any]] = [] done = False for item in payload: item_images, item_done = self._consume_payload(item) if item_images: images.extend(item_images) if item_done: done = True return self._dedupe_images(images), done if not isinstance(payload, dict): return [], False responses = payload.get("responses") if isinstance(responses, list): return self._consume_responses_snapshot(responses) if self._looks_like_response_snapshot(payload): return self._consume_response_snapshot(payload) result = payload.get("result") if not isinstance(result, dict): return [], False event_payload = self._unwrap_result_payload(result) if not isinstance(event_payload, dict): return [], False self._consume_token_event(event_payload) images = self._extract_image_items(event_payload) model_response = event_payload.get("modelResponse") done = False if isinstance(model_response, dict): self._consume_model_response(model_response) images.extend(self._extract_image_items(model_response)) done = not bool(model_response.get("partial", False)) images = self._dedupe_images(images) if images: self._media_generation_state = {} else: self._update_media_generation_state(event_payload) return images, done def _consume_responses_snapshot(self, responses: List[Any]) -> Tuple[List[Dict[str, Any]], bool]: response = self._select_latest_assistant_response(responses) if response is None: return [], False return self._consume_response_snapshot(response) def _consume_response_snapshot(self, response: Dict[str, Any]) -> Tuple[List[Dict[str, Any]], bool]: self._consume_model_response(response) images = self._dedupe_images(self._extract_image_items(response)) done = not bool(response.get("partial", False)) if images: self._media_generation_state = {} else: self._update_media_generation_state(response) return images, done @classmethod def _select_latest_assistant_response(cls, responses: List[Any]) -> Dict[str, Any] | None: for response in reversed(responses): if not isinstance(response, dict): continue if cls._is_assistant_sender(response.get("sender")): return response return None @classmethod def _looks_like_response_snapshot(cls, payload: Dict[str, Any]) -> bool: if "message" not in payload: return False sender = payload.get("sender") return sender in (None, "") or cls._is_assistant_sender(sender) @staticmethod def _is_assistant_sender(sender: Any) -> bool: normalized = str(sender or "").strip().lower() return normalized in {"assistant", "bot"} def _update_media_generation_state(self, event_payload: Dict[str, Any]) -> None: progress = event_payload.get("progressReport") if not isinstance(progress, dict): return category = str(progress.get("category") or "").strip().upper() state = str(progress.get("state") or "").strip().upper() message = str(progress.get("message") or "").strip() if "IMAGE" not in category: return if any(token in state for token in ("COMPLETED", "COMPLETE", "SUCCEEDED", "SUCCESS", "FAILED", "ERROR", "CANCELED", "CANCELLED")): self._media_generation_state = {} return if not any(token in state for token in ("PENDING", "STARTED", "RUNNING", "IN_PROGRESS")): return hint_text = str(self._media_generation_state.get("hint_text") or "") hint_parts = [item for item in hint_text.split("\n\n") if item] if message and message not in hint_parts: hint_parts.append(message) wait_timeout_seconds = self._media_generation_state.get("wait_timeout_seconds") self._media_generation_state = { "pending": True, "media_type": "image", "hint_text": "\n\n".join(hint_parts[:3]), "wait_timeout_seconds": max(float(wait_timeout_seconds or 0), 120.0), } def _consume_token_event(self, result: Dict[str, Any]) -> None: token = result.get("token") if not isinstance(token, str) or not token: return if bool(result.get("isThinking", False)): return message_tag = str(result.get("messageTag") or "").strip().lower() if message_tag and message_tag not in {"final", "answer"}: return self._rendered_content += token def _consume_model_response(self, model_response: Dict[str, Any]) -> None: sender = str(model_response.get("sender") or "").strip().lower() if sender and sender not in {"assistant", "bot"}: return message = model_response.get("message") if isinstance(message, str) and message: self._rendered_content = message def _extract_image_items(self, container: Dict[str, Any]) -> List[Dict[str, Any]]: urls = self._collect_image_urls(container) image_items: List[Dict[str, Any]] = [] for url in urls: if url in self._seen_image_refs: continue self._seen_image_refs.add(url) image_items.append( { "media_type": "image", "kind": "url", "url": url, "data_uri": None, "mime": None, "byte_size": None, "alt": "", "width": None, "height": None, "detected_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"), "source": "grok_stream", } ) return image_items def _collect_image_urls(self, container: Dict[str, Any]) -> List[str]: urls: List[str] = [] generated = container.get("generatedImageUrls") if isinstance(generated, list): for item in generated: if isinstance(item, str) and self._looks_like_image_ref(item): urls.append(item) attachments = container.get("imageAttachments") if isinstance(attachments, list): for item in attachments: urls.extend(self._extract_image_urls_from_value(item)) cards = container.get("cardAttachmentsJson") if isinstance(cards, list): for item in cards: parsed = item if isinstance(item, str): try: parsed = json.loads(item) except json.JSONDecodeError: parsed = item urls.extend(self._extract_image_urls_from_value(parsed)) deduped: List[str] = [] seen = set() for url in urls: if url in seen: continue seen.add(url) deduped.append(url) return deduped @staticmethod def _unwrap_result_payload(result: Dict[str, Any]) -> Dict[str, Any]: response = result.get("response") if isinstance(response, dict): return response return result def _extract_image_urls_from_value(self, value: Any) -> List[str]: urls: List[str] = [] if isinstance(value, str): if self._looks_like_image_ref(value): urls.append(value) return urls if isinstance(value, list): for item in value: urls.extend(self._extract_image_urls_from_value(item)) return urls if not isinstance(value, dict): return urls content_type = str( value.get("contentType") or value.get("mimeType") or value.get("mime") or "" ).strip().lower() for key, item in value.items(): normalized_key = str(key or "").strip().lower() if normalized_key in self._IMAGE_URL_KEYS: if isinstance(item, str) and (self._looks_like_image_ref(item) or content_type.startswith("image/")): urls.append(item) continue if normalized_key in {"images", "attachments", "items", "content", "data"}: urls.extend(self._extract_image_urls_from_value(item)) return urls @staticmethod def _looks_like_image_ref(value: str) -> bool: text = str(value or "").strip() if not text: return False lowered = text.lower() if lowered.startswith("data:image/"): return True if not lowered.startswith(("http://", "https://")): return False return any(marker in lowered for marker in ("/generated/", ".png", ".jpg", ".jpeg", ".webp", ".gif")) @staticmethod def _compute_delta(previous: str, current: str) -> str: if current == previous: return "" if not previous: return current if current.startswith(previous): return current[len(previous) :] if previous.startswith(current): return "" prefix_len = 0 limit = min(len(previous), len(current)) while prefix_len < limit and previous[prefix_len] == current[prefix_len]: prefix_len += 1 if prefix_len >= len(previous) // 2: return current[prefix_len:] return current @staticmethod def _dedupe_images(images: Iterable[Dict[str, Any]]) -> List[Dict[str, Any]]: deduped: List[Dict[str, Any]] = [] seen = set() for item in images: if not isinstance(item, dict): continue key = ( str(item.get("media_type") or ""), str(item.get("kind") or ""), str(item.get("url") or item.get("data_uri") or ""), ) if key in seen: continue seen.add(key) deduped.append(item) return deduped def _iter_payloads(self, raw_response: str): self_pending = self._pending try: self._pending = "" lines = self._extract_complete_lines(raw_response) lines.extend(self._drain_parseable_pending_line()) for raw_line in lines: line = raw_line.strip() if not line: continue try: payload = json.loads(line) except json.JSONDecodeError: continue if isinstance(payload, dict): yield payload finally: self._pending = self_pending @classmethod def get_id(cls) -> str: return "grok" @classmethod def get_name(cls) -> str: return "Grok" @classmethod def get_description(cls) -> str: return "Parse Grok NDJSON chat streams, ignore thinking tokens, and extract generated images" @classmethod def get_supported_patterns(cls) -> List[str]: return ["/rest/app-chat/conversations/", "/responses", "/load-responses"] __all__ = ["GrokParser"]