Agent Zero AI framework
Keep encrypted Chat reasoning out of readable output
Alessandroc4eeeac54a1f
diff --git a/helpers/litellm_transport.py b/helpers/litellm_transport.pyindex e1a7411a6..a3dd758d5 100644--- a/helpers/litellm_transport.py+++ b/helpers/litellm_transport.py@@ -471,6 +471,29 @@ class LiteLLMTransport:}+class _ChatReasoningFilter:+ marker = "__ENCRYPTED_REASONING__"++ def __init__(self) -> None:+ self.pending = ""+ self.encrypted = False++ def feed(self, text: str, *, final: bool = False) -> str:+ if self.encrypted:+ return ""+ text = self.pending + text+ self.pending = ""+ if self.marker in text:+ self.encrypted = True+ return text.partition(self.marker)[0]+ if not final:+ for length in range(min(len(text), len(self.marker) - 1), 0, -1):+ if text.endswith(self.marker[:length]):+ self.pending = text[-length:]+ return text[:-length]+ return text++class ChatCompletionsTransport:@staticmethoddef prepare_messages(@@ -514,7 +537,9 @@ class ChatCompletionsTransport:return {key: value for key, value in chat_kwargs.items() if value is not None}@staticmethod- def parse(chunk: Any) -> ChatChunk:+ def parse(+ chunk: Any, *, reasoning_filter: _ChatReasoningFilter | None = None+ ) -> ChatChunk:choice = _first_choice(chunk)delta = _get_value(choice, "delta") or {}message = _get_value(choice, "message") or _get_value(@@ -526,6 +551,9 @@ class ChatCompletionsTransport:reasoning_delta = _get_value(delta, "reasoning_content") or _get_value(message, "reasoning_content") or ""+ reasoning_delta = (reasoning_filter or _ChatReasoningFilter()).feed(+ reasoning_delta, final=reasoning_filter is None+ )parsed = {"reasoning_delta": reasoning_delta, "response_delta": response_delta}if not response_delta:tool_calls = _as_list(_get_value(message, "tool_calls"))@@ -591,6 +619,7 @@ class ChatCompletionsTransport:class ChatCompletionsStreamParser:def __init__(self) -> None:+ self.reasoning_filter = _ChatReasoningFilter()self.tool_calls: dict[str, dict[str, Any]] = {}self.order: list[str] = []self.emitted = False@@ -599,7 +628,7 @@ class ChatCompletionsStreamParser:def parse(self, chunk: Any) -> ChatChunk:if usage := _reported_usage(chunk):self.usage.update(usage)- parsed = ChatCompletionsTransport.parse(chunk)+ parsed = ChatCompletionsTransport.parse(chunk, reasoning_filter=self.reasoning_filter)choice = _first_choice(chunk)delta = _get_value(choice, "delta") or {}self._append_tool_calls(_get_value(delta, "tool_calls"))@@ -612,7 +641,10 @@ class ChatCompletionsStreamParser:return parseddef flush(self) -> ChatChunk:- return {"reasoning_delta": "", "response_delta": self._emit()}+ return {+ "reasoning_delta": self.reasoning_filter.feed("", final=True),+ "response_delta": self._emit(),+ }def function_calls_text(self) -> str:return ChatCompletionsTransport.tool_calls_text(self._ordered_tool_calls())diff --git a/helpers/litellm_transport.py.dox.md b/helpers/litellm_transport.py.dox.mdindex 24c454b2b..3d4311a5d 100644--- a/helpers/litellm_transport.py.dox.md+++ b/helpers/litellm_transport.py.dox.md@@ -56,3 +56,9 @@## Child DOX IndexNo child DOX files.++## Chat reasoning boundary++- Chat Completions `reasoning_content` is readable text only up to the provider serialization marker `__ENCRYPTED_REASONING__`. Suppress that marker and its remaining opaque payload before callbacks and result metadata, including markers split across stream chunks. Preserve ordinary reasoning and response content.+- Responses encrypted output items remain opaque native state; this Chat filter neither decodes nor promotes them into text. Existing saved logs are not rewritten.+- Verify with `pytest tests/test_chat_encrypted_reasoning.py -q`.diff --git a/tests/test_chat_encrypted_reasoning.py b/tests/test_chat_encrypted_reasoning.pynew file mode 100644index 000000000..a48db5ec3--- /dev/null+++ b/tests/test_chat_encrypted_reasoning.py@@ -0,0 +1,85 @@+import pytest+import models+from helpers import litellm_transport+from helpers.litellm_transport import (+ ChatCompletionsStreamParser,+ ChatCompletionsTransport,+ ResponsesTransport,+)+from helpers.llm_result import LLMResult+++MARKER = "__ENCRYPTED_REASONING__"+++def test_chat_completion_excludes_sealed_reasoning_from_result_metadata():+ raw = {"choices": [{"message": {+ "content": "Answer",+ "reasoning_content": "Readable summary\n" + MARKER + "id=rs_test\nopaque",+ }}]}+ parsed = ChatCompletionsTransport.parse(raw)+ assert parsed == {"response_delta": "Answer", "reasoning_delta": "Readable summary\n"}+ result = LLMResult.from_chat(response=parsed["response_delta"], reasoning=parsed["reasoning_delta"])+ assert MARKER not in str(result.metadata())+ assert raw["choices"][0]["message"]["reasoning_content"].endswith("opaque")+++def test_chat_stream_filters_every_marker_split_without_losing_content():+ reasoning = "Readable summary\n" + MARKER + "id=rs_test\nopaque"+ for split in range(len(reasoning) + 1):+ parser = ChatCompletionsStreamParser()+ chunks = [parser.parse({"choices": [{"delta": {+ "content": "Answer" if index == 1 else "",+ "reasoning_content": part,+ }}]}) for index, part in enumerate((reasoning[:split], reasoning[split:]))]+ chunks.append(parser.flush())+ assert "".join(c["reasoning_delta"] for c in chunks) == "Readable summary\n"+ assert "".join(c["response_delta"] for c in chunks) == "Answer"+++def test_chat_stream_preserves_ordinary_reasoning_and_flushes_partial_prefix():+ for reasoning in ("Use __ underscores", "__ENCRYPTED_REASONING", "", "Normal reasoning"):+ parser = ChatCompletionsStreamParser()+ output = "".join(parser.parse({"choices": [{"delta": {+ "reasoning_content": char,+ }}]})["reasoning_delta"] for char in reasoning)+ assert output + parser.flush()["reasoning_delta"] == reasoning+++def test_responses_sealed_reasoning_remains_an_opaque_output_item():+ raw = {"output": [{"type": "reasoning", "id": "rs_test",+ "encrypted_content": "opaque", "summary": []}]}+ assert ResponsesTransport.parse_response(raw)["reasoning_delta"] == ""+ result = LLMResult.from_response(raw)+ assert result.output_items[0].data["encrypted_content"] == "opaque"+++async def test_chat_wrapper_never_emits_or_persists_encrypted_reasoning(monkeypatch):+ async def chunks():+ for part in ("Readable\n__ENCRYPTED_", "REASONING__id=rs_test", "opaque"):+ yield {"choices": [{"delta": {"reasoning_content": part}}]}+ yield {"choices": [{"delta": {"content": "Answer"}}]}++ async def completion(**kwargs):+ return chunks()++ async def no_limiter(*args, **kwargs):+ return None++ monkeypatch.setattr(litellm_transport, "acompletion", completion)+ monkeypatch.setattr(models, "apply_rate_limiter", no_limiter)+ emitted = []++ async def reasoning_callback(chunk, full):+ emitted.append(chunk)++ wrapper = models.LiteLLMChatWrapper(+ model="test-model", provider="openai", model_config=None, a0_api_mode="chat",+ )+ result = await wrapper.unified_turn.__wrapped__(+ wrapper, messages=[], reasoning_callback=reasoning_callback,+ )+ assert "".join(emitted) == result.reasoning == "Readable\n"+ assert result.response == "Answer"+ assert MARKER not in str(result.metadata())