@agenthippo-ai/agenthippo 1.110.11 → 1.110.20

package/out/scripts/agentide_litellm_hooks_v1.py

@@ -1,27 +1,5 @@
-#---------------------------------------------------------------------------------------------
-# Copyright (c) AgentHippo.ai. All rights reserved.
-# Licensed under the MIT License. See LICENSE.txt in the project root for license information.
-#---------------------------------------------------------------------------------------------
-"""
-AgentIDE LiteLLM proxy hooks - Clean structured assistant output with separate input/output
-Mimics langfuse_otel style: gen_ai.input.messages (history) + gen_ai.output.messages (new reply only)
-
-Usage in litellm config.yaml:
-  callbacks: ["agentide_litellm_hooks_v1.clean_separated_otel_output"]
-
-PRIVACY DEFAULT (PLAN/compliance-req.md §6 "data minimization"):
-  Prompt and completion CONTENT is NOT captured unless an operator opts in with
-
-      AGENTHIPPO_EVIDENCE_CONTENT_CAPTURE=1
-
-  Without the opt-in every span carries metadata only — model, tokens, latency, status — plus a
-  sha256 + byte length of the content so a later disclosure can still be *matched* against a
-  span without the span holding the text. This is enforced here at span-write time, in addition
-  to `turn_off_message_logging: true` in the config, so a config that re-enables message logging
-  without the env opt-in still produces redacted spans (defence in depth: the config is edited by
-  hand far more often than this file).
-"""
-
+# Copyright (c) 2026 AgentHippo.ai. All rights reserved.
+# Proprietary and confidential. See LICENSE.
 from __future__ import annotations
 from typing import Any
 import ast
@@ -30,88 +8,33 @@ import json
 import os
 import re
 import sys
-
 from litellm.integrations.custom_logger import CustomLogger
 from litellm.integrations.opentelemetry import OpenTelemetry
 from opentelemetry.trace import Status, StatusCode
-
-_OTEL_TEXT_MAX_LEN = 4000           # per text block
-_OTEL_PREVIEW_LEN = 180             # short preview in event
-
-# -----------------------------------------------------------------------------
-# Content capture opt-in (fix: full capture used to be the default)
-# -----------------------------------------------------------------------------
-
-CONTENT_CAPTURE_ENV = "AGENTHIPPO_EVIDENCE_CONTENT_CAPTURE"
-
-_TRUTHY = frozenset({"1", "true", "yes", "on"})
-
-# Span attributes that can carry prompt/completion text. Mirrors CONTENT_ATTRS in
-# @agenthippo-ai/evidence-ship so the two redaction points cannot drift silently.
-_CONTENT_ATTR_RE = re.compile(
-    r"^(gen_ai\.(input|output)\.messages"
-    r"|gen_ai\.(prompt|completion)"
-    r"|gen_ai\.system_instructions"
-    r"|llm\.(prompts|responses)"
-    r"|llm\.request\.functions\."
-    r"|error\.(message|stack_trace)"
-    r"|hidden_params"
-    r"|metadata\.requester_custom_headers)"
-)
-
+_OTEL_TEXT_MAX_LEN = 4000
+_OTEL_PREVIEW_LEN = 180
+CONTENT_CAPTURE_ENV = 'AGENTHIPPO_EVIDENCE_CONTENT_CAPTURE'
+_TRUTHY = frozenset({'1', 'true', 'yes', 'on'})
+_CONTENT_ATTR_RE = re.compile('^(gen_ai\\.(input|output)\\.messages|gen_ai\\.(prompt|completion)|gen_ai\\.system_instructions|llm\\.(prompts|responses)|llm\\.request\\.functions\\.|error\\.(message|stack_trace)|hidden_params|metadata\\.requester_custom_headers)')
 _capture_banner_printed = False
 
-
 def _content_capture_enabled() -> bool:
-    """True only when an operator explicitly opted in to prompt/completion capture."""
-    return (os.environ.get(CONTENT_CAPTURE_ENV, "") or "").strip().lower() in _TRUTHY
-
+    return (os.environ.get(CONTENT_CAPTURE_ENV, '') or '').strip().lower() in _TRUTHY
 
 def _announce_content_capture() -> None:
-    """Log loudly, once, whichever mode is in force — silence is how this got shipped on."""
     global _capture_banner_printed
     if _capture_banner_printed:
         return
     _capture_banner_printed = True
     if _content_capture_enabled():
-        print(
-            "\n"
-            "!! AGENTHIPPO EVIDENCE: FULL PROMPT/COMPLETION CAPTURE IS ON !!\n"
-            f"!! {CONTENT_CAPTURE_ENV} is set. Every span will carry prompt and completion text.\n"
-            "!! Unset it to return to metadata-only (sha256 + length) spans.\n",
-            file=sys.stderr,
-            flush=True,
-        )
+        print(f'\n!! AGENTHIPPO EVIDENCE: FULL PROMPT/COMPLETION CAPTURE IS ON !!\n!! {CONTENT_CAPTURE_ENV} is set. Every span will carry prompt and completion text.\n!! Unset it to return to metadata-only (sha256 + length) spans.\n', file=sys.stderr, flush=True)
     else:
-        print(
-            f"[agentide-otel] content capture OFF (metadata + sha256 only). "
-            f"Set {CONTENT_CAPTURE_ENV}=1 to record prompts/completions.",
-            file=sys.stderr,
-            flush=True,
-        )
-
+        print(f'[agentide-otel] content capture OFF (metadata + sha256 only). Set {CONTENT_CAPTURE_ENV}=1 to record prompts/completions.', file=sys.stderr, flush=True)
 
 def _sha256(text: str) -> str:
-    return hashlib.sha256(text.encode("utf-8", "replace")).hexdigest()
-
-
-# Correlation IDs Spotlight reads from the requester header blob (see FLEET_DATA_CONTRACT.md).
-# These are minted by AgentHippo clients and carry no user content, so with capture off the
-# blob is reduced to exactly these keys rather than dropped — unknown x-* headers from clients
-# we do not control (e.g. x-api-key) still never reach the span in plaintext.
-_METADATA_HEADERS_KEY = "metadata.requester_custom_headers"
-
-_METADATA_HEADER_ALLOWLIST = frozenset({
-    "x-litellm-metadata-session-id",
-    "x-litellm-metadata-request-id",
-    "x-litellm-metadata-user-id",
-    "x-litellm-metadata-project-id",
-    "x-litellm-metadata-agent-id",
-    "x-litellm-metadata-agent-version",
-    "x-litellm-metadata-source",
-    "x-litellm-metadata-engine",
-})
-
+    return hashlib.sha256(text.encode('utf-8', 'replace')).hexdigest()
+_METADATA_HEADERS_KEY = 'metadata.requester_custom_headers'
+_METADATA_HEADER_ALLOWLIST = frozenset({'x-litellm-metadata-session-id', 'x-litellm-metadata-request-id', 'x-litellm-metadata-user-id', 'x-litellm-metadata-project-id', 'x-litellm-metadata-agent-id', 'x-litellm-metadata-agent-version', 'x-litellm-metadata-source', 'x-litellm-metadata-engine'})
 
 def _parse_attr_dict(value: Any) -> Any:
     if not isinstance(value, str):
@@ -124,58 +47,31 @@ def _parse_attr_dict(value: Any) -> Any:
         except ValueError:
             return None
 
-
 def _allowlisted_headers(headers: dict) -> dict:
-    return {
-        k.lower(): v for k, v in headers.items()
-        if isinstance(k, str) and k.lower() in _METADATA_HEADER_ALLOWLIST
-    }
-
+    return {k.lower(): v for k, v in headers.items() if isinstance(k, str) and k.lower() in _METADATA_HEADER_ALLOWLIST}
 
 def _filtered_metadata_headers(value: Any) -> str | None:
-    """Reduce the header blob to allowlisted keys, keeping the str(dict) repr format that
-    the DuckDB extraction regexes parse. None when nothing allowlisted survives."""
     headers = _parse_attr_dict(value)
     if not isinstance(headers, dict):
         return None
     kept = _allowlisted_headers(headers)
     return str(kept) if kept else None
-
-
-# LiteLLM also embeds the raw request headers as metadata.requester_metadata['headers'] on some
-# routes (observed on /v1/chat/completions; absent on /v1/messages). The attribute's scalar keys
-# (session_id, request_id, …) are a fallback landing spot the extraction chain parses, so the
-# attribute itself must survive — only its embedded header dict gets the allowlist treatment.
-_REQUESTER_METADATA_KEY = "metadata.requester_metadata"
-
+_REQUESTER_METADATA_KEY = 'metadata.requester_metadata'
 
 def _scrub_requester_metadata(value: Any) -> Any:
-    """Scrubbed value, or None (caller drops the attribute) when an embedded header dict
-    cannot be safely isolated — reprs with non-literal values defeat ast.literal_eval, and
-    passing those through unparsed would leak the very headers this exists to remove."""
     md = _parse_attr_dict(value)
-    if isinstance(md, dict) and isinstance(md.get("headers"), dict):
-        return str({**md, "headers": _allowlisted_headers(md["headers"])})
+    if isinstance(md, dict) and isinstance(md.get('headers'), dict):
+        return str({**md, 'headers': _allowlisted_headers(md['headers'])})
     if isinstance(md, dict):
         return value
-    return None if "headers" in str(value) else value
-
+    return None if 'headers' in str(value) else value
 
 class _RedactingSpan:
-    """
-    Span proxy that drops content-bearing attributes and replaces them with a sha256 + length.
-
-    LiteLLM's own `set_attributes()` writes `gen_ai.input.messages` (the full history) and
-    friends. We cannot remove an attribute after the SDK has recorded it, so the only place to
-    stop it is between LiteLLM and the SDK — here. Everything that is not content passes through
-    untouched, so the span keeps model, tokens, latency, status, and the requester metadata the
-    evidence index reads.
-    """
 
     def __init__(self, span: Any) -> None:
         self._span = span
 
-    def __getattr__(self, name: str) -> Any:  # everything we do not override
+    def __getattr__(self, name: str) -> Any:
         return getattr(self._span, name)
 
     def set_attribute(self, key: Any, value: Any) -> Any:
@@ -186,9 +82,9 @@ class _RedactingSpan:
             return self._span.set_attribute(key, scrubbed)
         if isinstance(key, str) and _CONTENT_ATTR_RE.match(key):
             text = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str)
-            self._span.set_attribute(f"{key}.sha256", _sha256(text))
-            self._span.set_attribute(f"{key}.length", len(text))
-            self._span.set_attribute(f"{key}.redacted", True)
+            self._span.set_attribute(f'{key}.sha256', _sha256(text))
+            self._span.set_attribute(f'{key}.length', len(text))
+            self._span.set_attribute(f'{key}.redacted', True)
             if key == _METADATA_HEADERS_KEY:
                 kept = _filtered_metadata_headers(value)
                 if kept is not None:
@@ -203,7 +99,7 @@ class _RedactingSpan:
             return None
         return self._span.set_attributes(attributes)
 
-    def add_event(self, name: Any, attributes: Any = None, **kwargs: Any) -> Any:
+    def add_event(self, name: Any, attributes: Any=None, **kwargs: Any) -> Any:
         if isinstance(attributes, dict):
             filtered = {}
             for key, value in attributes.items():
@@ -213,8 +109,8 @@ class _RedactingSpan:
                         filtered[key] = scrubbed
                 elif isinstance(key, str) and _CONTENT_ATTR_RE.match(key):
                     text = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str)
-                    filtered[f"{key}.sha256"] = _sha256(text)
-                    filtered[f"{key}.length"] = len(text)
+                    filtered[f'{key}.sha256'] = _sha256(text)
+                    filtered[f'{key}.length'] = len(text)
                     if key == _METADATA_HEADERS_KEY:
                         kept = _filtered_metadata_headers(value)
                         if kept is not None:
@@ -224,18 +120,16 @@ class _RedactingSpan:
             attributes = filtered
         return self._span.add_event(name, attributes, **kwargs)
 
-
-def _read_field(obj: Any, key: str, default: Any = None) -> Any:
+def _read_field(obj: Any, key: str, default: Any=None) -> Any:
     if isinstance(obj, dict):
         return obj.get(key, default)
     return getattr(obj, key, default)
 
-
 def _content_blocks_to_text(content: Any) -> str:
     if isinstance(content, str):
         return content
     if not isinstance(content, (list, tuple)):
-        return ""
+        return ''
     parts: list[str] = []
     for block in content:
         if isinstance(block, str):
@@ -244,90 +138,65 @@ def _content_blocks_to_text(content: Any) -> str:
             continue
         if not isinstance(block, dict):
             continue
-        text = block.get("text") or block.get("output_text") or block.get("content")
+        text = block.get('text') or block.get('output_text') or block.get('content')
         if isinstance(text, str) and text.strip():
             parts.append(text)
-    return "\n".join(parts)
-
+    return '\n'.join(parts)
 
 def _extract_assistant_text(response_obj: Any) -> str:
     if response_obj is None:
-        return ""
-    # OpenAI-style
-    choices = _read_field(response_obj, "choices")
+        return ''
+    choices = _read_field(response_obj, 'choices')
     if isinstance(choices, list) and choices:
-        msg = _read_field(choices[0], "message")
-        content = _read_field(msg, "content")
+        msg = _read_field(choices[0], 'message')
+        content = _read_field(msg, 'content')
         text = _content_blocks_to_text(content)
         if text.strip():
             return text
-    # Direct output fields
-    for key in ("output_text", "content", "output", "text"):
+    for key in ('output_text', 'content', 'output', 'text'):
         val = _read_field(response_obj, key)
         if val:
             text = _content_blocks_to_text(val)
             if text.strip():
                 return text
-    return ""
-
+    return ''
 
 def _extract_text_from_success_kwargs(kwargs: dict) -> str:
-    text = _extract_assistant_text(kwargs.get("response_obj"))
+    text = _extract_assistant_text(kwargs.get('response_obj'))
     if text:
         return text
-    for k in ("complete_response", "model_response", "response", "original_response"):
+    for k in ('complete_response', 'model_response', 'response', 'original_response'):
         candidate = kwargs.get(k)
         if candidate:
             text = _extract_assistant_text(candidate)
             if text:
                 return text
-    return ""
-
+    return ''
 
 def _make_output_messages_structured(text: str) -> list:
     if not text.strip():
         return []
     trimmed = text[:_OTEL_TEXT_MAX_LEN]
-    # Align with LiteLLM's GEN_AI_OUTPUT_MESSAGES shape: parts + inner content (not content + text).
-    return [{"role": "assistant", "parts": [{"type": "text", "content": trimmed}]}]
-
+    return [{'role': 'assistant', 'parts': [{'type': 'text', 'content': trimmed}]}]
 
 def _model_name(model: Any) -> str:
-    return model.lower() if isinstance(model, str) else ""
-
+    return model.lower() if isinstance(model, str) else ''
 
 def _is_reasoning_unsupported_model(model: Any) -> bool:
-    """True when model is known to reject reasoning parameters."""
-    return "gpt-4.1-nano" in _model_name(model)
-
+    return 'gpt-4.1-nano' in _model_name(model)
 
 def _is_anthropic_route(model: Any) -> bool:
-    """True when the request will be forwarded to Anthropic."""
     name = _model_name(model)
-    return "claude" in name or "anthropic" in name
-
-
-# Every model known to reject the Codex built-in web-search tools. Additive by policy: a
-# deployment that still routes to an older model keeps its sanitizer when a newer one is added,
-# because a dropped entry fails as upstream 400s on live traffic, not as a test failure.
-_WEB_SEARCH_UNSUPPORTED_MODELS = ("gpt-5.6-luna", "gpt-4.1-nano")
-
+    return 'claude' in name or 'anthropic' in name
+_WEB_SEARCH_UNSUPPORTED_MODELS = ('gpt-5.6-luna', 'gpt-4.1-nano')
 
 def _is_web_search_unsupported_model(model: Any) -> bool:
-    """True when the upstream model rejects Codex web-search tools."""
     name = _model_name(model)
-    return any(m in name for m in _WEB_SEARCH_UNSUPPORTED_MODELS)
-
+    return any((m in name for m in _WEB_SEARCH_UNSUPPORTED_MODELS))
+_OPENAI_RESPONSES_ONLY_KEYS = ('client_metadata',)
+_UNSUPPORTED_TOOL_IDENTIFIERS = frozenset({'web_search_preview', 'web_search'})
 
-# OpenAI Responses API fields that Anthropic (and some gateways) reject if forwarded verbatim.
-_OPENAI_RESPONSES_ONLY_KEYS = ("client_metadata",)
-
-# Codex built-in tools not supported on all OpenAI models.
-_UNSUPPORTED_TOOL_IDENTIFIERS = frozenset({"web_search_preview", "web_search"})
-
-
-def _strip_key_recursive(data: Any, key: str, _visited: set[int] | None = None) -> None:
-    """Remove a key in nested dict/list payloads (bounded; avoids cyclic graphs)."""
+def _strip_key_recursive(data: Any, key: str, _visited: set[int] | None=None) -> None:
     if _visited is None:
         _visited = set()
     if isinstance(data, dict):
@@ -347,58 +216,49 @@ def _strip_key_recursive(data: Any, key: str, _visited: set[int] | None = None)
         for item in data:
             _strip_key_recursive(item, key, _visited)
 
-
 def _resolve_route_model(payload: dict, model: Any) -> str:
     name = _model_name(model)
     if name:
         return name
-    for candidate in (
-        payload.get("model"),
-        payload.get("model_group"),
-        payload.get("model_name"),
-        payload.get("deployment"),
-    ):
+    for candidate in (payload.get('model'), payload.get('model_group'), payload.get('model_name'), payload.get('deployment')):
         name = _model_name(candidate)
         if name:
             return name
-    metadata = payload.get("metadata")
+    metadata = payload.get('metadata')
     if isinstance(metadata, dict):
-        for candidate in (metadata.get("model_group"), metadata.get("model")):
+        for candidate in (metadata.get('model_group'), metadata.get('model')):
             name = _model_name(candidate)
             if name:
                 return name
-    return ""
-
+    return ''
 
 def _tool_is_unsupported(tool: Any) -> bool:
     if not isinstance(tool, dict):
         return False
-    tool_type = tool.get("type")
+    tool_type = tool.get('type')
     if isinstance(tool_type, str) and tool_type in _UNSUPPORTED_TOOL_IDENTIFIERS:
         return True
-    name = tool.get("name")
+    name = tool.get('name')
     if isinstance(name, str) and name in _UNSUPPORTED_TOOL_IDENTIFIERS:
         return True
-    fn = tool.get("function")
+    fn = tool.get('function')
     if isinstance(fn, dict):
-        fn_name = fn.get("name")
+        fn_name = fn.get('name')
         if isinstance(fn_name, str) and fn_name in _UNSUPPORTED_TOOL_IDENTIFIERS:
             return True
     return False
 
-
 def _strip_unsupported_tools(data: dict) -> None:
-    tools = data.get("tools")
+    tools = data.get('tools')
     if not isinstance(tools, list):
         return
     filtered = [tool for tool in tools if not _tool_is_unsupported(tool)]
     if len(filtered) == len(tools):
         return
     if filtered:
-        data["tools"] = filtered
+        data['tools'] = filtered
     else:
-        data.pop("tools", None)
-
+        data.pop('tools', None)
 
 def _apply_codex_proxy_sanitizers(data: dict, model: Any) -> None:
     route_model = _resolve_route_model(data, model)
@@ -408,14 +268,7 @@ def _apply_codex_proxy_sanitizers(data: dict, model: Any) -> None:
     if _is_web_search_unsupported_model(route_model):
         _strip_unsupported_tools(data)
 
-
-def _strip_unsupported_reasoning_params(data: Any, _visited: set[int] | None = None) -> None:
-    """
-    Mutates `data` in-place by removing unsupported reasoning controls.
-
-    OpenAI's API error reports `reasoning.effort`, but the payload is sent as:
-      { "reasoning": { "effort": ... } }
-    """
+def _strip_unsupported_reasoning_params(data: Any, _visited: set[int] | None=None) -> None:
     if _visited is None:
         _visited = set()
     if isinstance(data, dict):
@@ -423,8 +276,8 @@ def _strip_unsupported_reasoning_params(data: Any, _visited: set[int] | None = N
         if obj_id in _visited:
             return
         _visited.add(obj_id)
-        data.pop("reasoning", None)
-        data.pop("reasoning_effort", None)
+        data.pop('reasoning', None)
+        data.pop('reasoning_effort', None)
         for v in list(data.values()):
             _strip_unsupported_reasoning_params(v, _visited)
         return
@@ -436,412 +289,227 @@ def _strip_unsupported_reasoning_params(data: Any, _visited: set[int] | None = N
         for item in data:
             _strip_unsupported_reasoning_params(item, _visited)
 
-
 def _extract_text_content(message: dict[str, Any]) -> str:
-    """Extract text content from OpenAI-style message content."""
-    content = message.get("content")
+    content = message.get('content')
     if isinstance(content, str):
         return content
     if not isinstance(content, list):
-        return ""
+        return ''
     parts: list[str] = []
     for block in content:
-        if isinstance(block, dict) and block.get("type") == "text":
-            text = block.get("text")
+        if isinstance(block, dict) and block.get('type') == 'text':
+            text = block.get('text')
             if isinstance(text, str) and text.strip():
                 parts.append(text)
-    return "\n".join(parts)
-
+    return '\n'.join(parts)
 
 def _set_text_content(message: dict[str, Any], text: str) -> None:
-    """Set text content while preserving existing content shape when possible."""
-    content = message.get("content")
+    content = message.get('content')
     if isinstance(content, list):
-        # Keep non-text blocks and append merged text as final text block.
-        preserved = [b for b in content if not (isinstance(b, dict) and b.get("type") == "text")]
+        preserved = [b for b in content if not (isinstance(b, dict) and b.get('type') == 'text')]
         if text.strip():
-            preserved.append({"type": "text", "text": text})
-        message["content"] = preserved
+            preserved.append({'type': 'text', 'text': text})
+        message['content'] = preserved
         return
-    message["content"] = text
-
+    message['content'] = text
 
 def _is_text_only_assistant(message: Any) -> bool:
-    """True when assistant message has text and no tool calls."""
-    if not isinstance(message, dict) or message.get("role") != "assistant":
+    if not isinstance(message, dict) or message.get('role') != 'assistant':
         return False
-    tool_calls = message.get("tool_calls")
+    tool_calls = message.get('tool_calls')
     if isinstance(tool_calls, list) and len(tool_calls) > 0:
         return False
     return bool(_extract_text_content(message).strip())
 
-
 def _tool_result_ids_from_message(message: Any) -> set[str]:
-    """Collect tool result ids from OpenAI or Anthropic-style tool result messages."""
     if not isinstance(message, dict):
         return set()
-
-    role = message.get("role")
-    if role == "tool":
-        tool_call_id = message.get("tool_call_id")
+    role = message.get('role')
+    if role == 'tool':
+        tool_call_id = message.get('tool_call_id')
         return {tool_call_id} if isinstance(tool_call_id, str) and tool_call_id else set()
-
-    content = message.get("content")
+    content = message.get('content')
     if not isinstance(content, list):
         return set()
     ids: set[str] = set()
     for block in content:
-        if isinstance(block, dict) and block.get("type") == "tool_result":
-            tool_use_id = block.get("tool_use_id")
+        if isinstance(block, dict) and block.get('type') == 'tool_result':
+            tool_use_id = block.get('tool_use_id')
             if isinstance(tool_use_id, str) and tool_use_id:
                 ids.add(tool_use_id)
     return ids
 
-
 def sanitize_messages(messages: Any) -> Any:
-    """
-    Lightweight tool-order sanitizer for Codex/OpenAI-style tool calls.
-
-    Ensures assistant tool calls are followed immediately by tool results.
-    If text-only assistant messages appear between tool call and tool result,
-    merge text into the tool-call assistant message.
-    If no immediate tool result exists, inject placeholder tool results.
-    """
     if not isinstance(messages, list) or not messages:
         return messages
-
     result: list[Any] = []
     i = 0
     changed = False
-
     while i < len(messages):
         msg = messages[i]
         if not isinstance(msg, dict):
             result.append(msg)
             i += 1
             continue
-
-        role = msg.get("role")
-        tool_calls = msg.get("tool_calls")
-        if role != "assistant" or not isinstance(tool_calls, list) or len(tool_calls) == 0:
+        role = msg.get('role')
+        tool_calls = msg.get('tool_calls')
+        if role != 'assistant' or not isinstance(tool_calls, list) or len(tool_calls) == 0:
             result.append(msg)
             i += 1
             continue
-
-        # Assistant tool-call message.
         tool_ids: list[str] = []
         for tc in tool_calls:
             if isinstance(tc, dict):
-                tid = tc.get("id")
+                tid = tc.get('id')
                 if isinstance(tid, str) and tid:
                     tool_ids.append(tid)
-
         merged = dict(msg)
         merged_text = _extract_text_content(merged)
         j = i + 1
-
-        # Merge consecutive text-only assistant messages.
         while j < len(messages) and _is_text_only_assistant(messages[j]):
             extra = _extract_text_content(messages[j])
             if extra.strip():
-                merged_text = f"{merged_text}\n{extra}" if merged_text.strip() else extra
+                merged_text = f'{merged_text}\n{extra}' if merged_text.strip() else extra
             j += 1
             changed = True
-
         if merged_text != _extract_text_content(merged):
             _set_text_content(merged, merged_text)
-
         result.append(merged)
-
-        # Immediate next message must carry tool results for all tool ids.
         next_ids = _tool_result_ids_from_message(messages[j]) if j < len(messages) else set()
         missing_ids = [tid for tid in tool_ids if tid not in next_ids]
         if missing_ids:
             changed = True
             for tid in missing_ids:
-                result.append({
-                    "role": "tool",
-                    "tool_call_id": tid,
-                    "content": "[Placeholder: tool result was not provided]",
-                })
-
+                result.append({'role': 'tool', 'tool_call_id': tid, 'content': '[Placeholder: tool result was not provided]'})
         i = j
-
     return result if changed else messages
 
-
 class ReasoningParamsSanitizer(CustomLogger):
-    """LiteLLM proxy hook: strip reasoning controls for gpt-5.6-luna."""
-
-    async def async_pre_call_hook(
-        self,
-        user_api_key_dict: Any,
-        cache: Any,
-        data: dict,
-        call_type: Any,
-    ) -> dict:
+
+    async def async_pre_call_hook(self, user_api_key_dict: Any, cache: Any, data: dict, call_type: Any) -> dict:
         if not isinstance(data, dict):
             return data
-        model = data.get("model")
+        model = data.get('model')
         if not _is_reasoning_unsupported_model(model):
             return data
         _strip_unsupported_reasoning_params(data)
         return data
 
-    async def async_pre_call_deployment_hook(
-        self,
-        request_kwargs: dict,
-        call_type: Any,
-    ) -> dict:
-        """Extra safety: strip during deployment-layer payload building."""
+    async def async_pre_call_deployment_hook(self, request_kwargs: dict, call_type: Any) -> dict:
         if not isinstance(request_kwargs, dict):
             return request_kwargs
-        model = request_kwargs.get("model")
+        model = request_kwargs.get('model')
         if not _is_reasoning_unsupported_model(model):
             return request_kwargs
         _strip_unsupported_reasoning_params(request_kwargs)
         return request_kwargs
 
-    async def async_pre_request_hook(
-        self,
-        model: str,
-        messages: list[Any],
-        request_kwargs: dict,
-    ) -> dict:
-        """Extra safety: strip right before provider call."""
+    async def async_pre_request_hook(self, model: str, messages: list[Any], request_kwargs: dict) -> dict:
         if not _is_reasoning_unsupported_model(model):
             return request_kwargs
         if isinstance(request_kwargs, dict):
             _strip_unsupported_reasoning_params(request_kwargs)
         return request_kwargs
 
-
 class CodexProxySanitizer(CustomLogger):
-    """
-    LiteLLM proxy hook: strip Codex/OpenAI Responses fields/tools that break proxy routes.
-
-    - Anthropic: drop client_metadata (OpenAI-only Responses telemetry).
-    - gpt-5.6-luna: drop web_search_preview and related built-in search tools.
-    """
 
     def _sanitize(self, payload: dict, model: Any) -> dict:
         if isinstance(payload, dict):
             _apply_codex_proxy_sanitizers(payload, model)
         return payload
 
-    async def async_pre_call_hook(
-        self,
-        user_api_key_dict: Any,
-        cache: Any,
-        data: dict,
-        call_type: Any,
-    ) -> dict:
+    async def async_pre_call_hook(self, user_api_key_dict: Any, cache: Any, data: dict, call_type: Any) -> dict:
         if not isinstance(data, dict):
             return data
-        return self._sanitize(data, data.get("model"))
+        return self._sanitize(data, data.get('model'))
 
-    async def async_pre_call_deployment_hook(
-        self,
-        request_kwargs: dict,
-        call_type: Any,
-    ) -> dict:
+    async def async_pre_call_deployment_hook(self, request_kwargs: dict, call_type: Any) -> dict:
         if not isinstance(request_kwargs, dict):
             return request_kwargs
-        return self._sanitize(request_kwargs, request_kwargs.get("model"))
-
-    async def async_pre_request_hook(
-        self,
-        model: str,
-        messages: list[Any],
-        request_kwargs: dict,
-    ) -> dict:
+        return self._sanitize(request_kwargs, request_kwargs.get('model'))
+
+    async def async_pre_request_hook(self, model: str, messages: list[Any], request_kwargs: dict) -> dict:
         if isinstance(request_kwargs, dict):
             self._sanitize(request_kwargs, model)
         return request_kwargs
 
-
 class ToolOrderSanitizer(CustomLogger):
-    """LiteLLM proxy hook: sanitize tool call/result ordering for Claude routes."""
-
-    async def async_pre_call_hook(
-        self,
-        user_api_key_dict: Any,
-        cache: Any,
-        data: dict,
-        call_type: Any,
-    ) -> dict:
+
+    async def async_pre_call_hook(self, user_api_key_dict: Any, cache: Any, data: dict, call_type: Any) -> dict:
         if not isinstance(data, dict):
             return data
-        messages = data.get("messages")
+        messages = data.get('messages')
         if isinstance(messages, list) and messages:
-            data["messages"] = sanitize_messages(messages)
+            data['messages'] = sanitize_messages(messages)
         return data
 
-
 def strip_empty_thinking_blocks(messages: list[Any]) -> list[Any]:
-    """
-    Strip empty thinking/reasoning blocks from OpenAI-format messages.
-
-    Anthropic's API rejects empty `thinking` content blocks and empty
-    `reasoning_content` strings. LiteLLM proxies these fields unchanged,
-    so we sanitize outbound messages here at the proxy layer.
-
-    Handles three shapes:
-      1. Top-level `reasoning_content: ""` on assistant messages
-      2. `{ type: "thinking", thinking: "" }` inside content arrays
-      3. Removes assistant messages that become entirely empty after stripping
-    """
     result: list[Any] = []
-
     for msg in messages:
         if not isinstance(msg, dict):
             result.append(msg)
             continue
-
         cleaned = msg
-
-        # 1. Strip empty top-level reasoning_content on assistant messages
-        if cleaned.get("role") == "assistant" and "reasoning_content" in cleaned:
-            rc = cleaned["reasoning_content"]
-            if not rc or (isinstance(rc, str) and not rc.strip()):
-                cleaned = {k: v for k, v in cleaned.items() if k != "reasoning_content"}
-
-        # 2. Filter empty thinking blocks from content arrays
-        content = cleaned.get("content")
+        if cleaned.get('role') == 'assistant' and 'reasoning_content' in cleaned:
+            rc = cleaned['reasoning_content']
+            if not rc or (isinstance(rc, str) and (not rc.strip())):
+                cleaned = {k: v for k, v in cleaned.items() if k != 'reasoning_content'}
+        content = cleaned.get('content')
         if isinstance(content, list):
             original_len = len(content)
-            filtered = [
-                block for block in content
-                if not (
-                    isinstance(block, dict)
-                    and block.get("type") == "thinking"
-                    and (not block.get("thinking") or (isinstance(block.get("thinking"), str) and not block["thinking"].strip()))
-                )
-            ]
+            filtered = [block for block in content if not (isinstance(block, dict) and block.get('type') == 'thinking' and (not block.get('thinking') or (isinstance(block.get('thinking'), str) and (not block['thinking'].strip()))))]
             if len(filtered) != original_len:
-                # Preserve turn structure: if assistant becomes empty, keep a placeholder
-                if not filtered and cleaned.get("role") == "assistant":
-                    filtered = [{"type": "text", "text": ""}]
-                cleaned = {**cleaned, "content": filtered}
-
-        # 3. Skip entirely empty assistant messages (no content, no tool_calls)
-        if cleaned.get("role") == "assistant" and not cleaned.get("tool_calls"):
-            c = cleaned.get("content")
-            if (isinstance(c, str) and not c.strip()) or (isinstance(c, list) and len(c) == 0):
+                if not filtered and cleaned.get('role') == 'assistant':
+                    filtered = [{'type': 'text', 'text': ''}]
+                cleaned = {**cleaned, 'content': filtered}
+        if cleaned.get('role') == 'assistant' and (not cleaned.get('tool_calls')):
+            c = cleaned.get('content')
+            if isinstance(c, str) and (not c.strip()) or (isinstance(c, list) and len(c) == 0):
                 continue
-
         result.append(cleaned)
-
     return result
 
-
 class EmptyThinkingBlockSanitizer(CustomLogger):
-    """LiteLLM proxy hook: strip empty thinking/reasoning blocks before Anthropic dispatch."""
-
-    async def async_pre_call_hook(
-        self,
-        user_api_key_dict: Any,
-        cache: Any,
-        data: dict,
-        call_type: Any,
-    ) -> dict:
+
+    async def async_pre_call_hook(self, user_api_key_dict: Any, cache: Any, data: dict, call_type: Any) -> dict:
         if not isinstance(data, dict):
             return data
-        messages = data.get("messages")
+        messages = data.get('messages')
         if isinstance(messages, list) and messages:
-            data["messages"] = strip_empty_thinking_blocks(messages)
+            data['messages'] = strip_empty_thinking_blocks(messages)
         return data
 
-
 class CleanSeparatedOtelOutput(OpenTelemetry):
-    """
-    LiteLLM OTEL with clean separation:
-    - gen_ai.input.messages  → full history (as set by LiteLLM)
-    - gen_ai.output.messages → only the new assistant reply (stringified structured array)
-    - Short preview event for quick visibility
-
-    Content (both directions) is recorded ONLY when AGENTHIPPO_EVIDENCE_CONTENT_CAPTURE is set.
-    Otherwise every content attribute becomes `<key>.sha256` + `<key>.length` — enough to prove
-    which bytes a turn saw, without shipping the bytes.
-    """
 
     def set_attributes(self, span: Any, *args: Any, **kwargs: Any) -> Any:
-        """
-        Redaction chokepoint. Overriding here rather than at the call site covers every path in
-        the base class that sets attributes, including ones this subclass does not override.
-        """
         _announce_content_capture()
         if not _content_capture_enabled():
             span = _RedactingSpan(span)
         return super().set_attributes(span, *args, **kwargs)
 
     def _get_span_name(self, kwargs: dict) -> str:
-        # Evidence pipeline indexes spans named litellm_request; main-stable semconv uses "chat …".
-        #
-        # The constant is a PRIVATE litellm symbol and this runs on the span-creation path, so an
-        # upstream rename would raise for every span — total evidence loss at layer 1, not a
-        # degraded span name. The literal is the same value; falling back to it keeps the pipeline
-        # indexing while the import is fixed.
         try:
             from litellm.integrations.opentelemetry import LITELLM_REQUEST_SPAN_NAME
-
             return LITELLM_REQUEST_SPAN_NAME
-        except Exception:  # pragma: no cover - depends on the pinned litellm build
-            return "litellm_request"
-
-    def _start_primary_span(
-        self,
-        kwargs: dict,
-        response_obj: Any,
-        start_time: Any,
-        end_time: Any,
-        context: Any,
-    ):
-        otel_tracer = self.get_tracer_to_use_for_request(kwargs)
+        except Exception:
+            return 'litellm_request'
 
-        span = otel_tracer.start_span(
-            name=self._get_span_name(kwargs),
-            start_time=self._to_ns(start_time),
-            context=context,
-        )
+    def _start_primary_span(self, kwargs: dict, response_obj: Any, start_time: Any, end_time: Any, context: Any):
+        otel_tracer = self.get_tracer_to_use_for_request(kwargs)
+        span = otel_tracer.start_span(name=self._get_span_name(kwargs), start_time=self._to_ns(start_time), context=context)
         span.set_status(Status(StatusCode.OK))
         self.set_attributes(span, kwargs, response_obj)
-
-        # -- Extract only the new assistant output -------------------------------
-        text = _extract_text_from_success_kwargs(kwargs) or \
-               _extract_assistant_text(response_obj)
-
+        text = _extract_text_from_success_kwargs(kwargs) or _extract_assistant_text(response_obj)
         if text.strip():
             capture = _content_capture_enabled()
-            event_attrs: dict[str, Any] = {
-                # Always present: proves a reply of exactly these bytes was produced, and lets a
-                # disclosed transcript be matched back to the span without storing the text.
-                "gen_ai.output.sha256": _sha256(text),
-                "gen_ai.output.length": len(text),
-                "gen_ai.output.truncated": len(text) > _OTEL_TEXT_MAX_LEN,
-                "gen_ai.output.captured": capture,
-                "gen_ai.response.model": _read_field(kwargs, "model", "unknown"),
-            }
-
+            event_attrs: dict[str, Any] = {'gen_ai.output.sha256': _sha256(text), 'gen_ai.output.length': len(text), 'gen_ai.output.truncated': len(text) > _OTEL_TEXT_MAX_LEN, 'gen_ai.output.captured': capture, 'gen_ai.response.model': _read_field(kwargs, 'model', 'unknown')}
             if capture:
-                # Structured output (separate from input history) — opt-in only.
                 structured_msgs = _make_output_messages_structured(text)
-                span.set_attribute(
-                    "gen_ai.output.messages",
-                    json.dumps(structured_msgs, ensure_ascii=False)
-                )
-                # Short preview event - easy to spot, low noise
-                event_attrs["gen_ai.output.preview"] = (
-                    text[:_OTEL_PREVIEW_LEN] + ("..." if len(text) > _OTEL_PREVIEW_LEN else "")
-                )
-
-            span.add_event(name="gen_ai.output.generated", attributes=event_attrs)
-
+                span.set_attribute('gen_ai.output.messages', json.dumps(structured_msgs, ensure_ascii=False))
+                event_attrs['gen_ai.output.preview'] = text[:_OTEL_PREVIEW_LEN] + ('...' if len(text) > _OTEL_PREVIEW_LEN else '')
+            span.add_event(name='gen_ai.output.generated', attributes=event_attrs)
         span.end(end_time=self._to_ns(end_time))
         return span
-
-
-# Register
 structured_genai_otel = CleanSeparatedOtelOutput()
 reasoning_params_sanitizer = ReasoningParamsSanitizer()
 codex_proxy_sanitizer = CodexProxySanitizer()