feat(llm): retain Anthropic/Gemini state and portable plain-text reasoning

skills/nooa-context-and-state/SKILL.md

@@ -87,6 +87,10 @@ async def solve(self, problem: str) -> str:
 
 Event history is what fills the LLM's conversation window. Key model-visible event types (names have no "Event" suffix): `Task`, `Message`, `Reasoning`, `Error`, `Feedback`, `LLMResponse`, `PythonOutput`, `Summary`, `Notification`. `LLMResponse` is both the canonical assistant turn and the home of its token/cost metadata; renderers expose only its conversational fields. Runtime-only events (never shown to the LLM) include `BeforeAgentCall`/`AfterAgentCall` and `LLMCallStart`/`LLMCallEnd`.
 
+`LLMResponse.reasoning` is provider-exposed text and remains useful across model switches, where UnifiedLLM replays it as ordinary assistant text. `LLMResponse.llm_state` is opaque provider state; it is persisted for resume but is replayed only through a matching provider/API/model gate.
+
+An intentional model/API mismatch logs a warning and falls back to the portable text. A malformed current-version envelope or provider signature raises `ReasoningReplayError`; do not catch it and silently continue, because it signals archive corruption or an unsupported provider contract change.
+
 ```python
 # Query (AND semantics; chronological; limit keeps most recent)
 recent = agent.events.query(limit=20)

src/nooa/strategies/codeact.py

@@ -69,7 +69,7 @@
     run_postconditions,
     run_preconditions,
 )
-from nooa.unifiedllm import LLMResponse, Tool, ToolCall
+from nooa.unifiedllm import LLMResponse, ReasoningReplayError, Tool, ToolCall
 
 if TYPE_CHECKING:
     from nooa.config.strategy_config import CodeActConfig
@@ -874,6 +874,8 @@ async def _run_generation(
         try:
             with _init_hm.timer("time_prefill"):
                 await self._run_prefill(runtime, call, builtins, session)
+        except ReasoningReplayError:
+            raise
         except Exception as e:
             logger.warning(f"[CODEACT] Prefill error (continuing): {e}")
             runtime.event_manager.add(Error(content=f"Prefill error: {e}"))
@@ -919,6 +921,9 @@ async def _run_generation(
                         tool_choice=tool_choice,
                         **self._build_sampling_kwargs(),
                     )
+                except ReasoningReplayError:
+                    turn_state.is_final = True
+                    raise
                 except BlockSyntaxError as e:
                     self._handle_block_syntax_error(e, session, runtime)
                     continue

src/nooa/strategies/pure_python.py

@@ -49,6 +49,7 @@
     ReturnValueValidator,
 )
 from nooa.strategies.template import TemplateStrategy
+from nooa.unifiedllm import ReasoningReplayError
 
 # Import httpx timeout exceptions if available (used by litellm)
 try:
@@ -268,6 +269,8 @@ async def execute(self, runtime: RuntimeServices, call: "CurrentCall") -> Any:
         if self.prefill:
             try:
                 await self._run_prefill(runtime, call, builtins, session)
+            except ReasoningReplayError:
+                raise
             except Exception as e:
                 logger.warning(f"[PURE_PYTHON] Prefill error (continuing): {e}")
                 runtime.event_manager.add(Error(content=f"Prefill error: {e}"))
@@ -305,6 +308,10 @@ async def execute(self, runtime: RuntimeServices, call: "CurrentCall") -> Any:
                 generate_event_id: str | None = None
                 try:
                     code, generate_event_id = await self._generate_code(runtime, session)
+                except ReasoningReplayError as e:
+                    turn_final = True
+                    turn_exception = type(e).__name__
+                    raise
                 except _HTTPX_TIMEOUT_EXCEPTIONS as e:
                     # Catch httpx timeout exceptions and preserve them
                     session.record_error()

src/nooa/tracing/_litellm_journal.py

@@ -71,7 +71,7 @@ def _msg_to_dict(msg: Any) -> dict:
 
 
 def _safe_msg_to_dict(msg: Any) -> dict:
-    """Normalize one provider message and remove issuer-only opaque state."""
+    """Normalize one provider message and remove provider-only opaque state."""
     scrubbed, _ = scrub_value(_msg_to_dict(msg))
     return scrubbed if isinstance(scrubbed, dict) else {}
 

src/nooa/tracing/_secret_scrubber.py

@@ -49,9 +49,18 @@
 )
 
 # Provider-owned replay state is not a user credential, but it has the same
-# telemetry rule: it may go back to its issuer and nowhere else. Provider
-# adapters add their exact wire keys here as support is introduced.
-_OPAQUE_PROVIDER_STATE_KEYS = frozenset({"encrypted_content", "nooa_llm_state"})
+# telemetry rule: it may go back to its matching provider and nowhere else.
+# Provider adapters add their exact wire keys here as support is introduced.
+_OPAQUE_PROVIDER_STATE_KEYS = frozenset(
+    {
+        "encrypted_content",
+        "nooa_llm_state",
+        "thought_signature",
+        "thought_signatures",
+        "thoughtsignature",
+        "thoughtsignatures",
+    }
+)
 
 
 def _is_sensitive_key(key: Any) -> bool:
@@ -79,6 +88,11 @@ def _redact_key(key: Any) -> str | None:
 # ---------------------------------------------------------------------------
 
 _SECRET_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+    # LiteLLM may append Gemini thought signatures to tool-call IDs.
+    (
+        "gemini_inline_thought_signature",
+        re.compile(r"__thought__(?P<secret>[A-Za-z0-9+/=_-]+)"),
+    ),
     # AWS Access Key IDs (AKIA, ASIA, AIDA, AROA + 16 alphanumeric)
     ("aws_access_key", re.compile(r"(?P<secret>(?:AKIA|ASIA|AIDA|AROA)[A-Z0-9]{16})")),
     # AWS Secret Access Keys (40-char base64 after known prefix)
@@ -247,8 +261,15 @@ def scrub_value(value: Any) -> tuple[Any, int]:
     if isinstance(value, dict):
         scrubbed_mapping: dict[Any, Any] = {}
         count = 0
+        is_thinking = value.get("type") == "thinking"
+        is_redacted_thinking = value.get("type") == "redacted_thinking"
         for key, item in value.items():
-            if reason := _redact_key(key):
+            reason = _redact_key(key)
+            if reason is None and is_thinking and key == "signature":
+                reason = "opaque_provider_state"
+            if reason is None and is_redacted_thinking and key == "data":
+                reason = "opaque_provider_state"
+            if reason is not None:
                 scrubbed_mapping[key] = REDACTED
                 stats.record(reason)
                 count += 1

src/nooa/unifiedllm/__init__.py

@@ -11,6 +11,7 @@
     reload_registry,
     resolve_api_key_from_config,
 )
+from nooa.unifiedllm.replay_state import ReasoningReplayError
 from nooa.unifiedllm.retry import (
     EmptyContentError,
     RetryingWrapper,
@@ -48,6 +49,7 @@
     # Response types
     "LLMResponse",
     "LLMUsage",
+    "ReasoningReplayError",
     # HTTP config
     "HttpConfig",
     # Retry utilities

src/nooa/unifiedllm/http_logging.py

@@ -5,24 +5,9 @@
 from datetime import UTC, datetime
 from pathlib import Path
 
-from nooa._llm_state import LLM_STATE_KEY
 from nooa.tracing._secret_scrubber import REDACTED, _is_sensitive_key, scrub_value
 
 
-def _redact_opaque_state(value):
-    """Remove replay envelopes and encrypted reasoning from debug logs."""
-    if isinstance(value, dict):
-        return {
-            key: REDACTED
-            if key in {LLM_STATE_KEY, "encrypted_content"}
-            else _redact_opaque_state(item)
-            for key, item in value.items()
-        }
-    if isinstance(value, list):
-        return [_redact_opaque_state(item) for item in value]
-    return value
-
-
 def enable_http_request_logging(
     output_dir: str | Path = ".",
     url_filter: str | None = None,
@@ -122,7 +107,7 @@ def _redact_body(body):
             # in an OAuth authorization-code exchange.
             if "code" in scrubbed:
                 scrubbed["code"] = REDACTED
-        return _redact_opaque_state(scrubbed)
+        return scrubbed
 
     def _write_jsonl_entry(entry: dict):
         """Append a JSON entry to the JSONL error file."""