ripperdoc 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

ripperdoc/utils/context_length_errors.py

@@ -0,0 +1,252 @@
+"""Detection helpers for context-window overflow errors across providers.
+
+Observed provider responses when the request is too large:
+- OpenAI/OpenRouter style (400 BadRequestError): error.code/context_length_exceeded with
+  a message like "This model's maximum context length is 128000 tokens. However, you
+  requested 130000 tokens (... in the messages, ... in the completion)."
+- Anthropic (400 BadRequestError): invalid_request_error with a message such as
+  "prompt is too long for model claude-3-5-sonnet. max tokens: 200000 prompt tokens: 240000".
+- Gemini / google-genai (FAILED_PRECONDITION or INVALID_ARGUMENT): APIError message like
+  "The input to the model was too long. The requested input has X tokens, which exceeds
+  the maximum of Y tokens for models/gemini-...".
+
+These helpers allow callers to detect the condition and trigger auto-compaction.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Set
+
+ContextLengthErrorCode = Optional[str]
+
+
+@dataclass
+class ContextLengthErrorInfo:
+    """Normalized metadata about a context-length error."""
+
+    provider: Optional[str]
+    message: str
+    error_code: ContextLengthErrorCode = None
+    status_code: Optional[int] = None
+
+
+_CONTEXT_PATTERNS = [
+    "context_length_exceeded",
+    "maximum context length",
+    "max context length",
+    "maximum context window",
+    "max context window",
+    "context length is",
+    "context length was exceeded",
+    "context window of",
+    "token limit exceeded",
+    "token length exceeded",
+    "prompt is too long",
+    "input is too long",
+    "request is too large",
+    "exceeds the maximum context",
+    "exceeds the model's context",
+    "requested input has",
+    "too many tokens",
+    "reduce the length of the messages",
+]
+
+
+def detect_context_length_error(error: Any) -> Optional[ContextLengthErrorInfo]:
+    """Return normalized context-length error info if the exception matches."""
+    if error is None:
+        return None
+
+    provider = _guess_provider(error)
+    status_code = _extract_status_code(error)
+    codes = _extract_codes(error)
+    messages = _collect_strings(error)
+
+    # Check explicit error codes first.
+    for code in codes:
+        normalized = code.lower()
+        if any(
+            keyword in normalized
+            for keyword in (
+                "context_length",
+                "max_tokens",
+                "token_length",
+                "prompt_too_long",
+                "input_too_large",
+                "token_limit",
+            )
+        ):
+            message = messages[0] if messages else code
+            return ContextLengthErrorInfo(
+                provider=provider,
+                message=message,
+                error_code=code,
+                status_code=status_code,
+            )
+
+    # Fall back to message-based detection.
+    for text in messages:
+        if _looks_like_context_length_message(text):
+            return ContextLengthErrorInfo(
+                provider=provider,
+                message=text,
+                error_code=codes[0] if codes else None,
+                status_code=status_code,
+            )
+
+    return None
+
+
+def _looks_like_context_length_message(text: str) -> bool:
+    lower = text.lower()
+    if any(pattern in lower for pattern in _CONTEXT_PATTERNS):
+        return True
+    if "too long" in lower and (
+        "prompt" in lower or "input" in lower or "context" in lower or "token" in lower
+    ):
+        return True
+    if "exceed" in lower and ("token" in lower or "context" in lower):
+        return True
+    if "max" in lower and "token" in lower and ("context" in lower or "limit" in lower):
+        return True
+    return False
+
+
+def _guess_provider(error: Any) -> Optional[str]:
+    module = getattr(getattr(error, "__class__", None), "__module__", "") or ""
+    name = getattr(getattr(error, "__class__", None), "__name__", "").lower()
+    if "openai" in module or "openai" in name:
+        return "openai"
+    if "anthropic" in module or "claude" in module:
+        return "anthropic"
+    if "google.genai" in module or "vertexai" in module:
+        return "gemini"
+    return None
+
+
+def _extract_status_code(error: Any) -> Optional[int]:
+    for attr in ("status_code", "http_status", "code"):
+        value = getattr(error, attr, None)
+        if isinstance(value, int):
+            return value
+        if isinstance(value, str) and value.isdigit():
+            return int(value)
+
+    for payload in (
+        _safe_getattr(error, "body"),
+        _safe_getattr(error, "details"),
+        _safe_getattr(error, "error"),
+    ):
+        if isinstance(payload, dict):
+            for key in ("status_code", "code"):
+                value = payload.get(key)
+                if isinstance(value, int):
+                    return value
+                if isinstance(value, str) and value.isdigit():
+                    return int(value)
+
+    return None
+
+
+def _extract_codes(error: Any) -> List[str]:
+    codes: List[str] = []
+    seen: Set[str] = set()
+
+    def _add(value: Any) -> None:
+        if value is None:
+            return
+        if isinstance(value, int):
+            value = str(value)
+        if not isinstance(value, str):
+            return
+        normalized = value.strip()
+        if not normalized or normalized in seen:
+            return
+        seen.add(normalized)
+        codes.append(normalized)
+
+    for attr in ("code", "error_code", "type", "status"):
+        _add(_safe_getattr(error, attr))
+
+    for payload in (
+        _safe_getattr(error, "body"),
+        _safe_getattr(error, "details"),
+        _safe_getattr(error, "error"),
+    ):
+        if isinstance(payload, dict):
+            for key in ("code", "type", "status"):
+                _add(payload.get(key))
+            nested = payload.get("error")
+            if isinstance(nested, dict):
+                for key in ("code", "type", "status"):
+                    _add(nested.get(key))
+
+    if isinstance(error, dict):
+        for key in ("code", "type", "status"):
+            _add(error.get(key))
+
+    return codes
+
+
+def _collect_strings(error: Any) -> List[str]:
+    """Collect human-readable strings from an exception/payload."""
+    texts: List[str] = []
+    seen_texts: Set[str] = set()
+    seen_objs: Set[int] = set()
+
+    def _add_text(value: Any) -> None:
+        if not isinstance(value, str):
+            return
+        normalized = value.strip()
+        if not normalized or normalized in seen_texts:
+            return
+        seen_texts.add(normalized)
+        texts.append(normalized)
+
+    def _walk(obj: Any) -> None:
+        if obj is None:
+            return
+        obj_id = id(obj)
+        if obj_id in seen_objs:
+            return
+        seen_objs.add(obj_id)
+
+        if isinstance(obj, str):
+            _add_text(obj)
+            return
+
+        if isinstance(obj, BaseException):
+            _add_text(_safe_getattr(obj, "message"))
+            for arg in getattr(obj, "args", ()):
+                _walk(arg)
+            for attr in ("body", "error", "details"):
+                _walk(_safe_getattr(obj, attr))
+            return
+
+        if isinstance(obj, dict):
+            for val in obj.values():
+                _walk(val)
+            return
+
+        if isinstance(obj, (list, tuple, set)):
+            for item in obj:
+                _walk(item)
+            return
+
+        _add_text(_safe_getattr(obj, "message"))
+
+    _walk(error)
+    try:
+        _add_text(str(error))
+    except (TypeError, ValueError):
+        pass
+
+    return texts
+
+
+def _safe_getattr(obj: Any, attr: str) -> Any:
+    try:
+        return getattr(obj, attr, None)
+    except (TypeError, AttributeError):
+        return None

ripperdoc/utils/file_watch.py

@@ -102,10 +102,11 @@ def detect_changed_files(
 
         try:
             new_content = _read_portion(file_path, snapshot.offset, snapshot.limit)
-        except Exception as exc:  # pragma: no cover - best-effort telemetry
-            logger.exception(
-                "[file_watch] Failed reading changed file",
-                extra={"file_path": file_path, "error": str(exc)},
+        except (OSError, IOError, UnicodeDecodeError, ValueError) as exc:  # pragma: no cover - best-effort telemetry
+            logger.warning(
+                "[file_watch] Failed reading changed file: %s: %s",
+                type(exc).__name__, exc,
+                extra={"file_path": file_path},
             )
             notices.append(
                 ChangedFileNotice(

ripperdoc/utils/json_utils.py

@@ -17,11 +17,11 @@ def safe_parse_json(json_text: Optional[str], log_error: bool = True) -> Optiona
         return None
     try:
         return json.loads(json_text)
-    except Exception as exc:
+    except (json.JSONDecodeError, TypeError, ValueError) as exc:
         if log_error:
             logger.debug(
-                "[json_utils] Failed to parse JSON",
-                extra={"error": str(exc), "length": len(json_text)},
-                exc_info=True,
+                "[json_utils] Failed to parse JSON: %s: %s",
+                type(exc).__name__, exc,
+                extra={"length": len(json_text)},
             )
         return None

ripperdoc/utils/log.py

@@ -55,7 +55,7 @@ class StructuredFormatter(logging.Formatter):
         if extras:
             try:
                 serialized = json.dumps(extras, sort_keys=True, ensure_ascii=True, default=str)
-            except Exception:
+            except (TypeError, ValueError):
                 serialized = str(extras)
             return f"{message} | {serialized}"
         return message
@@ -97,9 +97,9 @@ class RipperdocLogger:
         if self._file_handler:
             try:
                 self.logger.removeHandler(self._file_handler)
-            except Exception:
+            except (ValueError, RuntimeError):
                 # Swallow errors while rotating handlers; console logging should continue.
-                self.logger.exception("[logging] Failed to remove existing file handler")
+                pass
 
         # Use UTF-8 to avoid Windows code page encoding errors when logs contain non-ASCII text.
         file_handler = logging.FileHandler(log_file, encoding="utf-8")

ripperdoc/utils/mcp.py

@@ -25,11 +25,11 @@ try:
     from mcp.client.streamable_http import streamablehttp_client  # type: ignore[import-not-found]
 
     MCP_AVAILABLE = True
-except Exception:  # pragma: no cover - handled gracefully at runtime
+except (ImportError, ModuleNotFoundError):  # pragma: no cover - handled gracefully at runtime
     MCP_AVAILABLE = False
     ClientSession = object  # type: ignore
     mcp_types = None  # type: ignore
-    logger.exception("[mcp] MCP SDK not available at import time")
+    logger.debug("[mcp] MCP SDK not available at import time")
 
 
 @dataclass
@@ -89,18 +89,17 @@ def _ensure_str_dict(raw: object) -> Dict[str, str]:
     for key, value in raw.items():
         try:
             result[str(key)] = str(value)
-        except Exception:
-            logger.exception(
-                "[mcp] Failed to coerce env/header value to string",
-                extra={"key": key, "value": value},
+        except (TypeError, ValueError) as exc:
+            logger.warning(
+                "[mcp] Failed to coerce env/header value to string: %s: %s",
+                type(exc).__name__, exc,
+                extra={"key": key},
             )
             continue
     return result
 
 
-def _normalize_command(
-    raw_command: Any, raw_args: Any
-) -> tuple[Optional[str], List[str]]:
+def _normalize_command(raw_command: Any, raw_args: Any) -> tuple[Optional[str], List[str]]:
     """Normalize MCP server command/args.
 
     Supports:
@@ -366,10 +365,11 @@ class McpRuntime:
                     "capabilities": list(info.capabilities.keys()),
                 },
             )
-        except Exception as exc:  # pragma: no cover - network/process errors
-            logger.exception(
-                "Failed to connect to MCP server",
-                extra={"server": config.name, "error": str(exc)},
+        except (OSError, RuntimeError, ConnectionError, ValueError, TimeoutError) as exc:  # pragma: no cover - network/process errors
+            logger.warning(
+                "Failed to connect to MCP server: %s: %s",
+                type(exc).__name__, exc,
+                extra={"server": config.name},
             )
             info.status = "failed"
             info.error = str(exc)
@@ -386,6 +386,12 @@ class McpRuntime:
         )
         try:
             await self._exit_stack.aclose()
+        except BaseException as exc:  # pragma: no cover - defensive shutdown
+            # Swallow noisy ExceptionGroups from stdio_client cancel scopes during exit.
+            logger.debug(
+                "[mcp] Suppressed MCP shutdown error",
+                extra={"error": str(exc), "project_path": str(self.project_path)},
+            )
         finally:
             self.sessions.clear()
             self.servers.clear()
@@ -394,10 +400,16 @@ class McpRuntime:
 _runtime_var: contextvars.ContextVar[Optional[McpRuntime]] = contextvars.ContextVar(
     "ripperdoc_mcp_runtime", default=None
 )
+# Fallback for synchronous contexts (e.g., run_until_complete) where contextvars
+# don't propagate values back to the caller.
+_global_runtime: Optional[McpRuntime] = None
 
 
 def _get_runtime() -> Optional[McpRuntime]:
-    return _runtime_var.get()
+    runtime = _runtime_var.get()
+    if runtime:
+        return runtime
+    return _global_runtime
 
 
 def get_existing_mcp_runtime() -> Optional[McpRuntime]:
@@ -409,6 +421,7 @@ async def ensure_mcp_runtime(project_path: Optional[Path] = None) -> McpRuntime:
     runtime = _get_runtime()
     project_path = project_path or Path.cwd()
     if runtime and not runtime._closed and runtime.project_path == project_path:
+        _runtime_var.set(runtime)
         logger.debug(
             "[mcp] Reusing existing MCP runtime",
             extra={
@@ -429,6 +442,9 @@ async def ensure_mcp_runtime(project_path: Optional[Path] = None) -> McpRuntime:
     configs = _load_server_configs(project_path)
     await runtime.connect(configs)
     _runtime_var.set(runtime)
+    # Keep a module-level reference so sync callers that hop event loops can reuse it.
+    global _global_runtime
+    _global_runtime = runtime
     return runtime
 
 
@@ -436,8 +452,13 @@ async def shutdown_mcp_runtime() -> None:
     runtime = _get_runtime()
     if not runtime:
         return
-    await runtime.aclose()
+    try:
+        await runtime.aclose()
+    except BaseException as exc:  # pragma: no cover - defensive for ExceptionGroup
+        logger.debug("[mcp] Suppressed MCP runtime shutdown error", extra={"error": str(exc)})
     _runtime_var.set(None)
+    global _global_runtime
+    _global_runtime = None
 
 
 async def load_mcp_servers_async(project_path: Optional[Path] = None) -> List[McpServerInfo]:

ripperdoc/utils/memory.py

@@ -45,9 +45,10 @@ def _is_path_under_directory(path: Path, directory: Path) -> bool:
     try:
         path.resolve().relative_to(directory.resolve())
         return True
-    except Exception:
-        logger.exception(
-            "[memory] Failed to compare path containment",
+    except (ValueError, OSError) as exc:
+        logger.warning(
+            "[memory] Failed to compare path containment: %s: %s",
+            type(exc).__name__, exc,
             extra={"path": str(path), "directory": str(directory)},
         )
         return False
@@ -122,9 +123,11 @@ def _collect_files(
     resolved_path = file_path.expanduser()
     try:
         resolved_path = resolved_path.resolve()
-    except Exception:
-        logger.exception(
-            "[memory] Failed to resolve memory file path", extra={"path": str(resolved_path)}
+    except (OSError, ValueError) as exc:
+        logger.warning(
+            "[memory] Failed to resolve memory file path: %s: %s",
+            type(exc).__name__, exc,
+            extra={"path": str(resolved_path)},
         )
 
     resolved_key = str(resolved_path)

ripperdoc/utils/message_compaction.py

@@ -169,9 +169,10 @@ def _stringify_content(content: Union[str, List[MessageContent], None]) -> str:
             if block_type == "tool_use" and part.get("input") is not None:
                 try:
                     parts.append(json.dumps(part.get("input"), ensure_ascii=False))
-                except Exception:
-                    logger.exception(
-                        "[message_compaction] Failed to serialize tool_use input for token estimate"
+                except (TypeError, ValueError) as exc:
+                    logger.warning(
+                        "[message_compaction] Failed to serialize tool_use input for token estimate: %s: %s",
+                        type(exc).__name__, exc,
                     )
                     parts.append(str(part.get("input")))
 
@@ -225,10 +226,11 @@ def _estimate_tool_schema_tokens(tools: Sequence[Any]) -> int:
             schema = tool.input_schema.model_json_schema()
             schema_text = json.dumps(schema, sort_keys=True)
             total += estimate_tokens_from_text(schema_text)
-        except Exception as exc:
-            logger.exception(
-                "Failed to estimate tokens for tool schema",
-                extra={"tool": getattr(tool, "name", None), "error": str(exc)},
+        except (AttributeError, TypeError, KeyError, ValueError) as exc:
+            logger.warning(
+                "Failed to estimate tokens for tool schema: %s: %s",
+                type(exc).__name__, exc,
+                extra={"tool": getattr(tool, "name", None)},
             )
             continue
     return total
@@ -399,8 +401,8 @@ def find_latest_assistant_usage_tokens(
                     tokens += int(value)
             if tokens > 0:
                 return tokens
-        except Exception:
-            logger.debug("[message_compaction] Failed to parse usage tokens", exc_info=True)
+        except (TypeError, ValueError, AttributeError):
+            logger.debug("[message_compaction] Failed to parse usage tokens")
             continue
     return 0
 
@@ -436,8 +438,11 @@ def _run_cleanup_callbacks() -> None:
     for callback in callbacks:
         try:
             callback()
-        except Exception as exc:
-            logger.debug(f"[message_compaction] Cleanup callback failed: {exc}", exc_info=True)
+        except (RuntimeError, TypeError, ValueError, AttributeError) as exc:
+            logger.debug(
+                "[message_compaction] Cleanup callback failed: %s: %s",
+                type(exc).__name__, exc,
+            )
 
 
 def _normalize_tool_use_id(block: Any) -> str:

ripperdoc/utils/messages.py

@@ -6,7 +6,7 @@ for communication with AI models.
 
 import json
 from typing import Any, Dict, List, Optional, Union
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 from uuid import uuid4
 from enum import Enum
 from ripperdoc.utils.log import get_logger
@@ -27,6 +27,9 @@ class MessageContent(BaseModel):
 
     type: str
     text: Optional[str] = None
+    thinking: Optional[str] = None
+    signature: Optional[str] = None
+    data: Optional[str] = None
     # Some providers return tool_use IDs as "id", others as "tool_use_id"
     id: Optional[str] = None
     tool_use_id: Optional[str] = None
@@ -38,6 +41,18 @@ class MessageContent(BaseModel):
 def _content_block_to_api(block: MessageContent) -> Dict[str, Any]:
     """Convert a MessageContent block to API-ready dict for tool protocols."""
     block_type = getattr(block, "type", None)
+    if block_type == "thinking":
+        return {
+            "type": "thinking",
+            "thinking": getattr(block, "thinking", None) or getattr(block, "text", None) or "",
+            "signature": getattr(block, "signature", None),
+        }
+    if block_type == "redacted_thinking":
+        return {
+            "type": "redacted_thinking",
+            "data": getattr(block, "data", None) or getattr(block, "text", None) or "",
+            "signature": getattr(block, "signature", None),
+        }
     if block_type == "tool_use":
         return {
             "type": "tool_use",
@@ -75,8 +90,11 @@ def _content_block_to_openai(block: MessageContent) -> Dict[str, Any]:
         args = getattr(block, "input", None) or {}
         try:
             args_str = json.dumps(args)
-        except Exception:
-            logger.exception("[_content_block_to_openai] Failed to serialize tool arguments")
+        except (TypeError, ValueError) as exc:
+            logger.warning(
+                "[_content_block_to_openai] Failed to serialize tool arguments: %s: %s",
+                type(exc).__name__, exc,
+            )
             args_str = "{}"
         tool_call_id = (
             getattr(block, "id", None) or getattr(block, "tool_use_id", "") or str(uuid4())
@@ -118,6 +136,8 @@ class Message(BaseModel):
 
     role: MessageRole
     content: Union[str, List[MessageContent]]
+    reasoning: Optional[Any] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
     uuid: str = ""
 
     def __init__(self, **data: object) -> None:
@@ -187,9 +207,12 @@ def create_user_message(
         try:
             if hasattr(tool_use_result, "model_dump"):
                 tool_use_result = tool_use_result.model_dump()
-        except Exception:
+        except (AttributeError, TypeError, ValueError) as exc:
             # Fallback: keep as-is if conversion fails
-            logger.exception("[create_user_message] Failed to normalize tool_use_result")
+            logger.warning(
+                "[create_user_message] Failed to normalize tool_use_result: %s: %s",
+                type(exc).__name__, exc,
+            )
 
     message = Message(role=MessageRole.USER, content=message_content)
 
@@ -208,7 +231,11 @@ def create_user_message(
 
 
 def create_assistant_message(
-    content: Union[str, List[Dict[str, Any]]], cost_usd: float = 0.0, duration_ms: float = 0.0
+    content: Union[str, List[Dict[str, Any]]],
+    cost_usd: float = 0.0,
+    duration_ms: float = 0.0,
+    reasoning: Optional[Any] = None,
+    metadata: Optional[Dict[str, Any]] = None,
 ) -> AssistantMessage:
     """Create an assistant message."""
     if isinstance(content, str):
@@ -216,7 +243,12 @@ def create_assistant_message(
     else:
         message_content = [MessageContent(**item) for item in content]
 
-    message = Message(role=MessageRole.ASSISTANT, content=message_content)
+    message = Message(
+        role=MessageRole.ASSISTANT,
+        content=message_content,
+        reasoning=reasoning,
+        metadata=metadata or {},
+    )
 
     return AssistantMessage(message=message, cost_usd=cost_usd, duration_ms=duration_ms)
 
@@ -264,6 +296,28 @@ def normalize_messages_for_api(
                 return msg.get("content")
         return None
 
+    def _msg_metadata(msg: Any) -> Dict[str, Any]:
+        message_obj = getattr(msg, "message", None)
+        if message_obj is not None and hasattr(message_obj, "metadata"):
+            try:
+                meta = getattr(message_obj, "metadata", {}) or {}
+                meta_dict = dict(meta) if isinstance(meta, dict) else {}
+            except (TypeError, ValueError):
+                meta_dict = {}
+            reasoning_val = getattr(message_obj, "reasoning", None)
+            if reasoning_val is not None and "reasoning" not in meta_dict:
+                meta_dict["reasoning"] = reasoning_val
+            return meta_dict
+        if isinstance(msg, dict):
+            message_payload = msg.get("message")
+            if isinstance(message_payload, dict):
+                meta = message_payload.get("metadata") or {}
+                meta_dict = dict(meta) if isinstance(meta, dict) else {}
+                if "reasoning" not in meta_dict and "reasoning" in message_payload:
+                    meta_dict["reasoning"] = message_payload.get("reasoning")
+                return meta_dict
+        return {}
+
     def _block_type(block: Any) -> Optional[str]:
         if hasattr(block, "type"):
             return getattr(block, "type", None)
@@ -299,7 +353,7 @@ def normalize_messages_for_api(
                 if input_data not in (None, {}):
                     try:
                         input_preview = json.dumps(input_data)
-                    except Exception:
+                    except (TypeError, ValueError):
                         input_preview = str(input_data)
                 tool_id = _block_attr(blk, "tool_use_id") or _block_attr(blk, "id")
                 desc = "Tool call"
@@ -352,6 +406,7 @@ def normalize_messages_for_api(
 
         if msg_type == "user":
             user_content = _msg_content(msg)
+            meta = _msg_metadata(msg)
             if isinstance(user_content, list):
                 if protocol == "openai":
                     # Map each block to an OpenAI-style message
@@ -362,6 +417,11 @@ def normalize_messages_for_api(
                         mapped = _content_block_to_openai(block)
                         if mapped:
                             openai_msgs.append(mapped)
+                    if meta and openai_msgs:
+                        for candidate in openai_msgs:
+                            for key in ("reasoning_content", "reasoning_details", "reasoning"):
+                                if key in meta and meta[key] is not None:
+                                    candidate[key] = meta[key]
                     normalized.extend(openai_msgs)
                     continue
                 api_blocks = []
@@ -374,6 +434,7 @@ def normalize_messages_for_api(
                 normalized.append({"role": "user", "content": user_content})  # type: ignore
         elif msg_type == "assistant":
             asst_content = _msg_content(msg)
+            meta = _msg_metadata(msg)
             if isinstance(asst_content, list):
                 if protocol == "openai":
                     assistant_openai_msgs: List[Dict[str, Any]] = []
@@ -417,6 +478,10 @@ def normalize_messages_for_api(
                                 "tool_calls": tool_calls,
                             }
                         )
+                    if meta and assistant_openai_msgs:
+                        for key in ("reasoning_content", "reasoning_details", "reasoning"):
+                            if key in meta and meta[key] is not None:
+                                assistant_openai_msgs[-1][key] = meta[key]
                     normalized.extend(assistant_openai_msgs)
                     continue
                 api_blocks = []