Skip to content

Agent Zero AI framework

Keep encrypted Chat reasoning out of readable output

Alessandroc4eeeac54a1f
diff --git a/helpers/litellm_transport.py b/helpers/litellm_transport.py
index 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:
@staticmethod
def 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 parsed
def 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.md
index 24c454b2b..3d4311a5d 100644
--- a/helpers/litellm_transport.py.dox.md
+++ b/helpers/litellm_transport.py.dox.md
@@ -56,3 +56,9 @@
## Child DOX Index
No 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.py
new file mode 100644
index 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())