evidor 1.11.0.dev1__tar.gz → 1.11.1.dev1__tar.gz

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 <!-- version list -->
 
+## v1.11.1-dev.1 (2026-11-04)
+
+### Bug Fixes
+
+- **anthropic**: Fixing reasoning mode issues
+  ([`405c681`](https://github.com/vedangiitb/evidor-core/commit/405c68150ea149f0bb693a1fb23bcd5151267211))
+
+- **gemini**: Removing redundant fields in parsing
+  ([`555be1d`](https://github.com/vedangiitb/evidor-core/commit/555be1dfd2e0f79cc5c27c3c9c6cf342f5ca1029))
+
+
+## v1.11.0 (2026-11-03)
+
+
 ## v1.11.0-dev.1 (2026-11-03)
 
 ### Features

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.11.0-dev.1
+Version: 1.11.1-dev.1
 Summary: A small, provider-agnostic harness for LLM input and output.
 Project-URL: Homepage, https://github.com/evidor/evidor-core
 Project-URL: Repository, https://github.com/evidor/evidor-core
@@ -554,10 +554,17 @@ p_openai_cfg = OpenAIProvider(
     thinking=ThinkingConfig(effort="high", summary="auto"),
 )
 
-# 2. Anthropic: Configure extended budget tokens (budget_tokens >= 1024; auto-bumps max_tokens if needed)
-p_anthropic_cfg = AnthropicProvider(
+# 2. Anthropic: Configure adaptive thinking with reasoning summary, or manual budget tokens
+# Adaptive thinking with reasoning summary:
+p_anthropic_adaptive = AnthropicProvider(
     model="claude-3-7-sonnet-20250219",
-    thinking=ThinkingConfig(budget_tokens=4096),
+    thinking=ThinkingConfig(effort="high", summary="auto"),
+)
+
+# Extended manual budget tokens (budget_tokens >= 1024; auto-bumps max_tokens if needed):
+p_anthropic_budget = AnthropicProvider(
+    model="claude-3-7-sonnet-20250219",
+    thinking=ThinkingConfig(budget_tokens=4096, summary="omitted"),
 )
 
 # 3. Gemini: Configure thinking level and summaries (or thinking budget for earlier models)
@@ -577,9 +584,9 @@ p_gemini_budget = GeminiProvider(
 
 | Field | Type | Description & Provider Mapping |
 | :--- | :--- | :--- |
-| `effort` | `str \| None` | Reasoning intensity. Passed through directly without client-side mapping or gating to ensure forward compatibility with new provider levels (e.g., `"none"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`). Supported by OpenAI (`reasoning.effort`), Gemini (`thinking_level`), and Anthropic (`effort`). If an unexpected effort level is passed, the provider API handles it directly. |
+| `effort` | `str \| None` | Reasoning intensity. Passed through directly without client-side mapping or gating to ensure forward compatibility with new provider levels (e.g., `"none"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`). Supported by OpenAI (`reasoning.effort`), Gemini (`thinking_level`), and Anthropic (`output_config.effort` with adaptive thinking). If an unexpected effort level is passed, the provider API handles it directly. |
 | `budget_tokens` | `int \| None` | Maximum reasoning token budget where supported. Supported by Anthropic (`thinking={"type": "enabled", "budget_tokens": ...}`) and Gemini (`thinking_budget`). |
-| `summary` | `str \| None` | Whether and how to expose reasoning summaries. Supported by OpenAI (`reasoning.summary`) and Gemini (`thinking_summaries`).<br>**Note on Gemini**: Gemini natively supports `"auto"` and `"none"`. When targeting Gemini, you should specify `"auto"` or `"none"`. As a fallback, Evidor automatically maps other non-`none` strings (e.g. `"concise"`, `"detailed"`) to `"auto"`. |
+| `summary` | `str \| None` | Whether and how to expose reasoning summaries. Supported across all three providers:<br>• **Anthropic**: Controls reasoning exposure via Claude's `thinking.display` parameter (`"summarized"` vs `"omitted"`). Values such as `"auto"`, `"summarized"`, `"concise"`, or `"detailed"` set `display: "summarized"`, populating `response.thinking` with a human-readable summary. Values like `"none"` or `"omitted"` set `display: "omitted"`, omitting thinking text to minimize time-to-first-token while preserving cryptographic signatures in `thought_blocks` for multi-turn replay.<br>• **OpenAI**: Configures `reasoning.summary`.<br>• **Gemini**: Configures `thinking_summaries` (`"auto"` or `"none"`). As a fallback, Evidor automatically maps other non-`none` strings (e.g. `"concise"`, `"detailed"`) to `"auto"`. |
 
 > [!NOTE]
 > **No Boolean or Standalone Integer Shorthands**: Shorthands like `thinking=False` or `thinking=4096` are intentionally not supported to avoid ambiguity. To run without thinking, simply omit the parameter or pass `thinking=None`. To configure a token budget, use `ThinkingConfig(budget_tokens=4096)`.
@@ -606,7 +613,7 @@ if response.usage and response.usage.reasoning_tokens:
 
 #### Multi-Turn Tool Calling & Cryptographic Signatures
 
-Reasoning models from Anthropic and Gemini output thought blocks alongside cryptographic signatures (such as Anthropic's `signature` field or Gemini's thought parts). In multi-turn tool loops, these signatures must be preserved and replayed in subsequent conversation turns to avoid API verification errors. Evidor automatically captures and replays them in `agent.messages` and `thought_blocks` without requiring any manual handling.
+Reasoning models from Anthropic and Gemini output thought blocks alongside cryptographic signatures (such as Anthropic's `signature` field or Gemini's thought parts). In multi-turn tool loops, these signatures must be preserved and replayed in subsequent conversation turns to avoid API verification errors. Evidor automatically captures and replays them in `agent.messages` and `thought_blocks` without requiring any manual handling. Furthermore, Evidor normalizes and sanitizes thought blocks across providers (e.g. converting between Gemini's and Anthropic's signature representations and stripping non-standard fields) so history can be transferred or replayed seamlessly without schema violations.
 
 ## Tools & Function Calling
 

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/README.md

@@ -467,10 +467,17 @@ p_openai_cfg = OpenAIProvider(
     thinking=ThinkingConfig(effort="high", summary="auto"),
 )
 
-# 2. Anthropic: Configure extended budget tokens (budget_tokens >= 1024; auto-bumps max_tokens if needed)
-p_anthropic_cfg = AnthropicProvider(
+# 2. Anthropic: Configure adaptive thinking with reasoning summary, or manual budget tokens
+# Adaptive thinking with reasoning summary:
+p_anthropic_adaptive = AnthropicProvider(
     model="claude-3-7-sonnet-20250219",
-    thinking=ThinkingConfig(budget_tokens=4096),
+    thinking=ThinkingConfig(effort="high", summary="auto"),
+)
+
+# Extended manual budget tokens (budget_tokens >= 1024; auto-bumps max_tokens if needed):
+p_anthropic_budget = AnthropicProvider(
+    model="claude-3-7-sonnet-20250219",
+    thinking=ThinkingConfig(budget_tokens=4096, summary="omitted"),
 )
 
 # 3. Gemini: Configure thinking level and summaries (or thinking budget for earlier models)
@@ -490,9 +497,9 @@ p_gemini_budget = GeminiProvider(
 
 | Field | Type | Description & Provider Mapping |
 | :--- | :--- | :--- |
-| `effort` | `str \| None` | Reasoning intensity. Passed through directly without client-side mapping or gating to ensure forward compatibility with new provider levels (e.g., `"none"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`). Supported by OpenAI (`reasoning.effort`), Gemini (`thinking_level`), and Anthropic (`effort`). If an unexpected effort level is passed, the provider API handles it directly. |
+| `effort` | `str \| None` | Reasoning intensity. Passed through directly without client-side mapping or gating to ensure forward compatibility with new provider levels (e.g., `"none"`, `"minimal"`, `"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`). Supported by OpenAI (`reasoning.effort`), Gemini (`thinking_level`), and Anthropic (`output_config.effort` with adaptive thinking). If an unexpected effort level is passed, the provider API handles it directly. |
 | `budget_tokens` | `int \| None` | Maximum reasoning token budget where supported. Supported by Anthropic (`thinking={"type": "enabled", "budget_tokens": ...}`) and Gemini (`thinking_budget`). |
-| `summary` | `str \| None` | Whether and how to expose reasoning summaries. Supported by OpenAI (`reasoning.summary`) and Gemini (`thinking_summaries`).<br>**Note on Gemini**: Gemini natively supports `"auto"` and `"none"`. When targeting Gemini, you should specify `"auto"` or `"none"`. As a fallback, Evidor automatically maps other non-`none` strings (e.g. `"concise"`, `"detailed"`) to `"auto"`. |
+| `summary` | `str \| None` | Whether and how to expose reasoning summaries. Supported across all three providers:<br>• **Anthropic**: Controls reasoning exposure via Claude's `thinking.display` parameter (`"summarized"` vs `"omitted"`). Values such as `"auto"`, `"summarized"`, `"concise"`, or `"detailed"` set `display: "summarized"`, populating `response.thinking` with a human-readable summary. Values like `"none"` or `"omitted"` set `display: "omitted"`, omitting thinking text to minimize time-to-first-token while preserving cryptographic signatures in `thought_blocks` for multi-turn replay.<br>• **OpenAI**: Configures `reasoning.summary`.<br>• **Gemini**: Configures `thinking_summaries` (`"auto"` or `"none"`). As a fallback, Evidor automatically maps other non-`none` strings (e.g. `"concise"`, `"detailed"`) to `"auto"`. |
 
 > [!NOTE]
 > **No Boolean or Standalone Integer Shorthands**: Shorthands like `thinking=False` or `thinking=4096` are intentionally not supported to avoid ambiguity. To run without thinking, simply omit the parameter or pass `thinking=None`. To configure a token budget, use `ThinkingConfig(budget_tokens=4096)`.
@@ -519,7 +526,7 @@ if response.usage and response.usage.reasoning_tokens:
 
 #### Multi-Turn Tool Calling & Cryptographic Signatures
 
-Reasoning models from Anthropic and Gemini output thought blocks alongside cryptographic signatures (such as Anthropic's `signature` field or Gemini's thought parts). In multi-turn tool loops, these signatures must be preserved and replayed in subsequent conversation turns to avoid API verification errors. Evidor automatically captures and replays them in `agent.messages` and `thought_blocks` without requiring any manual handling.
+Reasoning models from Anthropic and Gemini output thought blocks alongside cryptographic signatures (such as Anthropic's `signature` field or Gemini's thought parts). In multi-turn tool loops, these signatures must be preserved and replayed in subsequent conversation turns to avoid API verification errors. Evidor automatically captures and replays them in `agent.messages` and `thought_blocks` without requiring any manual handling. Furthermore, Evidor normalizes and sanitizes thought blocks across providers (e.g. converting between Gemini's and Anthropic's signature representations and stripping non-standard fields) so history can be transferred or replayed seamlessly without schema violations.
 
 ## Tools & Function Calling
 

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "evidor"
-version = "1.11.0-dev.1"
+version = "1.11.1-dev.1"
 description = "A small, provider-agnostic harness for LLM input and output."
 readme = "README.md"
 requires-python = ">=3.10"

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/src/evidor/agent/providers/anthropic/builder.py

@@ -4,8 +4,8 @@ from collections.abc import Sequence
 import json
 from typing import Any
 
-from evidor.models import GenerationRequest, Message
-from ..base import extract_system_prompt, sort_tools
+from evidor.models import GenerationRequest, Message, ThinkingConfig
+from ..base import extract_system_prompt, safe_parse_tool_arguments, sort_tools
 
 
 class AnthropicPayloadBuilder:
@@ -54,26 +54,61 @@ class AnthropicPayloadBuilder:
             payload["output_config"] = {"effort": active_thinking}
         elif active_thinking and not isinstance(active_thinking, (bool, int)):
             budget = (
-                active_thinking.get("budget_tokens")
+                active_thinking.get("budget_tokens") or active_thinking.get("thinking_budget")
                 if isinstance(active_thinking, dict)
-                else getattr(active_thinking, "budget_tokens", None)
+                else getattr(active_thinking, "budget_tokens", None) or getattr(active_thinking, "thinking_budget", None)
             )
             effort = (
-                active_thinking.get("effort")
+                active_thinking.get("effort") or active_thinking.get("thinking_level")
                 if isinstance(active_thinking, dict)
-                else getattr(active_thinking, "effort", None)
+                else getattr(active_thinking, "effort", None) or getattr(active_thinking, "thinking_level", None)
             )
-            if budget is not None and not isinstance(budget, bool) and budget > 0:
-                actual_budget = max(budget, 1024)
-                payload["thinking"] = {
+            raw_summary = (
+                active_thinking.get("summary") or active_thinking.get("display") or active_thinking.get("thinking_summaries")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "summary", None) or getattr(active_thinking, "display", None) or getattr(active_thinking, "thinking_summaries", None)
+            )
+            explicit_type = (
+                active_thinking.get("type")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "type", None)
+            )
+
+            display_val: str | None = None
+            if isinstance(raw_summary, bool):
+                display_val = "summarized" if raw_summary else "omitted"
+            elif isinstance(raw_summary, str) and raw_summary.strip():
+                cleaned_summary = raw_summary.strip().lower()
+                if cleaned_summary in ("none", "omitted", "off", "hidden", "false"):
+                    display_val = "omitted"
+                elif cleaned_summary in ("summarized", "summary", "auto", "concise", "detailed", "on", "visible", "true"):
+                    display_val = "summarized"
+                else:
+                    display_val = raw_summary.strip()
+
+            if (budget is not None and not isinstance(budget, bool) and budget > 0) or explicit_type == "enabled":
+                actual_budget = max(budget or 1024, 1024)
+                thinking_dict: dict[str, Any] = {
                     "type": "enabled",
                     "budget_tokens": actual_budget,
                 }
+                if display_val:
+                    thinking_dict["display"] = display_val
+                payload["thinking"] = thinking_dict
                 if payload["max_tokens"] <= actual_budget:
                     payload["max_tokens"] = actual_budget + 1024
-            elif isinstance(effort, str):
-                payload["thinking"] = {"type": "adaptive"}
-                payload["output_config"] = {"effort": effort}
+            elif (
+                isinstance(effort, str)
+                or display_val is not None
+                or explicit_type == "adaptive"
+                or isinstance(active_thinking, ThinkingConfig)
+            ):
+                thinking_dict = {"type": "adaptive"}
+                if display_val:
+                    thinking_dict["display"] = display_val
+                payload["thinking"] = thinking_dict
+                if isinstance(effort, str) and effort.strip():
+                    payload["output_config"] = {"effort": effort.strip()}
 
         if self.enable_prompt_caching:
             payload["cache_control"] = {"type": "ephemeral"}
@@ -109,25 +144,65 @@ class AnthropicPayloadBuilder:
     @staticmethod
     def _normalize_thought_block(tb: Any) -> dict[str, Any] | None:
         """Convert a thought block (dict, Pydantic model, SDK object) to an Anthropic block dict."""
+        if tb is None:
+            return None
+
+        block_dict: dict[str, Any] | None = None
         if isinstance(tb, dict):
-            return dict(tb)
-        if hasattr(tb, "model_dump") and callable(tb.model_dump):
+            block_dict = tb
+        elif hasattr(tb, "model_dump") and callable(tb.model_dump):
             dumped = tb.model_dump()
             if isinstance(dumped, dict):
-                return dumped
-        if hasattr(tb, "to_dict") and callable(tb.to_dict):
+                block_dict = dumped
+        elif hasattr(tb, "to_dict") and callable(tb.to_dict):
             dumped = tb.to_dict()
             if isinstance(dumped, dict):
-                return dumped
-        if hasattr(tb, "type"):
-            block: dict[str, Any] = {"type": getattr(tb, "type")}
-            if hasattr(tb, "thinking") and getattr(tb, "thinking") is not None:
-                block["thinking"] = getattr(tb, "thinking")
-            if hasattr(tb, "signature") and getattr(tb, "signature") is not None:
-                block["signature"] = getattr(tb, "signature")
-            if hasattr(tb, "data") and getattr(tb, "data") is not None:
-                block["data"] = getattr(tb, "data")
-            return block
+                block_dict = dumped
+
+        def _get(key: str, default: Any = None) -> Any:
+            if block_dict is not None:
+                return block_dict.get(key, default)
+            return getattr(tb, key, default)
+
+        raw_type = _get("type")
+        block_type = str(raw_type).strip().lower() if raw_type is not None else None
+
+        if block_type == "redacted_thinking":
+            data_val = _get("data", "")
+            return {
+                "type": "redacted_thinking",
+                "data": str(data_val or ""),
+            }
+
+        is_thought = (
+            block_type in ("thinking", "thought", "reasoning")
+            or _get("thinking") is not None
+            or _get("thought") is not None
+            or _get("thought_signature") is not None
+            or _get("thoughtSignature") is not None
+            or _get("signature") is not None
+        )
+
+        if is_thought:
+            thinking_text = (
+                _get("thinking")
+                or _get("summary")
+                or _get("text")
+                or ""
+            )
+            sig = (
+                _get("signature")
+                or _get("thought_signature")
+                or _get("thoughtSignature")
+            )
+            normalized: dict[str, Any] = {
+                "type": "thinking",
+                "thinking": str(thinking_text) if thinking_text is not None else "",
+            }
+            if sig is not None and str(sig).strip():
+                normalized["signature"] = str(sig).strip()
+            return normalized
+
         return None
 
     def format_messages(self, messages: Sequence[Message]) -> list[dict[str, Any]]:
@@ -184,15 +259,27 @@ class AnthropicPayloadBuilder:
                         content_blocks.append({"type": "text", "text": message.content})
                     if message.tool_calls:
                         for tc in message.tool_calls:
+                            tc_args = (
+                                tc.arguments
+                                if isinstance(tc.arguments, dict)
+                                else (safe_parse_tool_arguments(tc.arguments) if tc.arguments else {})
+                            )
                             content_blocks.append({
                                 "type": "tool_use",
                                 "id": tc.id,
                                 "name": tc.name,
-                                "input": tc.arguments,
+                                "input": tc_args,
                             })
+                    if not content_blocks:
+                        fallback_text = message.content if (isinstance(message.content, str) and message.content.strip()) else "Done."
+                        content_blocks.append({"type": "text", "text": fallback_text})
                     formatted.append({"role": "assistant", "content": content_blocks})
                 else:
-                    formatted.append({"role": "assistant", "content": message.content})
+                    if isinstance(message.content, list):
+                        formatted.append({"role": "assistant", "content": message.content})
+                    else:
+                        content_val = message.content if (isinstance(message.content, str) and message.content.strip()) else "Done."
+                        formatted.append({"role": "assistant", "content": content_val})
 
             else:
                 # User or other role

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/src/evidor/agent/providers/anthropic/parser.py

@@ -39,9 +39,18 @@ class AnthropicResponseParser:
 
         thinking_text = "".join(thought_parts) if thought_parts else None
         if thinking_text is None:
-            raw_thinking = _get_field(response_msg, "thinking") or _get_field(response_msg, "reasoning")
+            raw_thinking = (
+                _get_field(response_msg, "thinking")
+                or _get_field(response_msg, "reasoning")
+                or _get_field(response_msg, "thinking_summary")
+                or _get_field(response_msg, "summary")
+            )
             if isinstance(raw_thinking, str) and raw_thinking.strip():
                 thinking_text = raw_thinking.strip()
+            elif isinstance(raw_thinking, dict):
+                th = raw_thinking.get("thinking") or raw_thinking.get("summary") or raw_thinking.get("text")
+                if isinstance(th, str) and th.strip():
+                    thinking_text = th.strip()
 
         usage = self.parse_usage(_get_field(response_msg, "usage"))
 
@@ -93,10 +102,20 @@ class AnthropicResponseParser:
                 )
                 if c:
                     compaction_summary = str(c)
-            elif block_type == "thinking":
-                th_text = _get_field(block, "thinking") or _get_field(block, "text") or ""
-                thought_parts.append(str(th_text))
-                sig = _get_field(block, "signature")
+            elif block_type in ("thinking", "thought"):
+                th_text = (
+                    _get_field(block, "thinking")
+                    or _get_field(block, "summary")
+                    or _get_field(block, "text")
+                    or ""
+                )
+                if str(th_text).strip():
+                    thought_parts.append(str(th_text))
+                sig = (
+                    _get_field(block, "signature")
+                    or _get_field(block, "thought_signature")
+                    or _get_field(block, "thoughtSignature")
+                )
                 tb: dict[str, Any] = {"type": "thinking", "thinking": str(th_text)}
                 if isinstance(sig, str) and sig.strip():
                     tb["signature"] = sig.strip()

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/src/evidor/agent/providers/anthropic/stream.py

@@ -53,8 +53,8 @@ class AnthropicStreamHandler:
                 name = _get_field(cb, "name") or "unknown_tool"
                 self.block_id_map[idx] = str(call_id)
                 self.tool_acc.start_call(str(call_id), str(name))
-            elif cb_type == "thinking":
-                th_text = _get_field(cb, "thinking") or ""
+            elif cb_type in ("thinking", "thought"):
+                th_text = _get_field(cb, "thinking") or _get_field(cb, "summary") or ""
                 self.block_thinking_map[idx] = {
                     "type": "thinking",
                     "parts": [str(th_text)] if th_text else [],
@@ -85,8 +85,17 @@ class AnthropicStreamHandler:
                     if txt:
                         self.accumulated_text.append(str(txt))
                         yield StreamChunk(text=str(txt), raw_event=event)
-                elif delta_type == "thinking_delta" or hasattr(delta, "thinking"):
-                    th = _get_field(delta, "thinking", "") or ""
+                elif (
+                    delta_type in (
+                        "thinking_delta",
+                        "thinking_summary_delta",
+                        "reasoning_delta",
+                        "reasoning_summary_delta",
+                    )
+                    or hasattr(delta, "thinking")
+                    or hasattr(delta, "summary")
+                ):
+                    th = _get_field(delta, "thinking", "") or _get_field(delta, "summary", "") or ""
                     if th:
                         self.text_thinking_parts.append(str(th))
                         if idx in self.block_thinking_map and "parts" in self.block_thinking_map[idx]:
@@ -101,7 +110,9 @@ class AnthropicStreamHandler:
                 elif delta_type == "signature_delta" or hasattr(delta, "signature"):
                     sig = _get_field(delta, "signature", "") or ""
                     if sig and idx in self.block_thinking_map:
-                        self.block_thinking_map[idx]["signature"] = str(sig)
+                        self.block_thinking_map[idx]["signature"] = (
+                            self.block_thinking_map[idx].get("signature", "") + str(sig)
+                        )
                 elif delta_type == "input_json_delta" or hasattr(delta, "partial_json"):
                     call_id = self.block_id_map.get(idx, f"call_{idx}")
                     pj = _get_field(delta, "partial_json", "") or ""

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/src/evidor/agent/providers/gemini/parser.py

@@ -152,11 +152,11 @@ class GeminiResponseParser:
                     return val
             return default
 
-        pt = _get_field("total_input_tokens", "input_tokens", "prompt_tokens")
-        ct = _get_field("total_output_tokens", "output_tokens", "completion_tokens")
+        pt = _get_field("total_input_tokens")
+        ct = _get_field("total_output_tokens")
         tt = _get_field("total_tokens")
-        cached = _get_field("total_cached_tokens", "cached_tokens", default=0) or 0
-        reasoning = _get_field("total_thought_tokens", "thought_tokens", "reasoning_tokens", default=0) or 0
+        cached = _get_field("total_cached_tokens", default=0) or 0
+        reasoning = _get_field("total_thought_tokens", default=0) or 0
 
         if not (isinstance(pt, int) or isinstance(ct, int) or isinstance(tt, int)):
             return None

{evidor-1.11.0.dev1 → evidor-1.11.1.dev1}/tests/test_thinking.py

@@ -224,6 +224,199 @@ def test_anthropic_provider_multiturn_thought_signature_replay(monkeypatch: pyte
     assert content_blocks[1]["id"] == "call_99"
 
 
+def test_anthropic_builder_adaptive_effort_and_summary() -> None:
+    from evidor.agent.providers.anthropic.builder import AnthropicPayloadBuilder
+
+    # 1. Adaptive with effort and summary="auto" -> display: "summarized"
+    cfg1 = ThinkingConfig(effort="high", summary="auto")
+    b1 = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=2048, thinking=cfg1)
+    p1 = b1.build(GenerationRequest(prompt="Explain quantum mechanics"))
+    assert p1["thinking"] == {"type": "adaptive", "display": "summarized"}
+    assert p1["output_config"] == {"effort": "high"}
+
+    # 2. Adaptive with effort and summary="none" -> display: "omitted"
+    cfg2 = ThinkingConfig(effort="low", summary="none")
+    b2 = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=2048, thinking=cfg2)
+    p2 = b2.build(GenerationRequest(prompt="Simple math"))
+    assert p2["thinking"] == {"type": "adaptive", "display": "omitted"}
+    assert p2["output_config"] == {"effort": "low"}
+
+    # 3. Summary only ("detailed") -> adaptive thinking with display: "summarized"
+    cfg3 = ThinkingConfig(summary="detailed")
+    b3 = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=2048, thinking=cfg3)
+    p3 = b3.build(GenerationRequest(prompt="Summarize"))
+    assert p3["thinking"] == {"type": "adaptive", "display": "summarized"}
+    assert "output_config" not in p3
+
+    # 4. Summary only ("omitted") -> adaptive thinking with display: "omitted"
+    cfg4 = ThinkingConfig(summary="omitted")
+    b4 = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=2048, thinking=cfg4)
+    p4 = b4.build(GenerationRequest(prompt="Code quickly"))
+    assert p4["thinking"] == {"type": "adaptive", "display": "omitted"}
+
+    # 5. Budget tokens with summary="concise" -> display: "summarized"
+    cfg5 = ThinkingConfig(budget_tokens=2048, summary="concise")
+    b5 = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=2048, thinking=cfg5)
+    p5 = b5.build(GenerationRequest(prompt="Analyze code"))
+    assert p5["thinking"] == {"type": "enabled", "budget_tokens": 2048, "display": "summarized"}
+    assert p5["max_tokens"] > 2048
+
+    # 6. Budget tokens with summary="none" -> display: "omitted"
+    cfg6 = ThinkingConfig(budget_tokens=2048, summary="none")
+    b6 = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=4096, thinking=cfg6)
+    p6 = b6.build(GenerationRequest(prompt="Deep benchmark"))
+    assert p6["thinking"] == {"type": "enabled", "budget_tokens": 2048, "display": "omitted"}
+
+
+def test_anthropic_builder_thought_block_normalization_cross_provider() -> None:
+    from evidor.agent.providers.anthropic.builder import AnthropicPayloadBuilder
+
+    builder = AnthropicPayloadBuilder(model="claude-3-7-sonnet", max_tokens=2048)
+
+    # Gemini-style thought block with thought_signature and boolean thought flag
+    gem_block = {
+        "type": "thought",
+        "text": "Gemini chain-of-thought",
+        "thought": True,
+        "thought_signature": "gem_sig_789",
+        "extra_gemini_field": "ignore_me",
+    }
+    norm_gem = builder._normalize_thought_block(gem_block)
+    assert norm_gem == {
+        "type": "thinking",
+        "thinking": "Gemini chain-of-thought",
+        "signature": "gem_sig_789",
+    }
+    assert "extra_gemini_field" not in norm_gem
+    assert "thought" not in norm_gem
+
+    # OpenAI-style reasoning block with summary
+    oai_block = {
+        "type": "reasoning",
+        "summary": "OpenAI reasoning summary",
+        "signature": "oai_sig_321",
+    }
+    norm_oai = builder._normalize_thought_block(oai_block)
+    assert norm_oai == {
+        "type": "thinking",
+        "thinking": "OpenAI reasoning summary",
+        "signature": "oai_sig_321",
+    }
+
+    # Anthropic omitted block (empty thinking)
+    omitted_block = {
+        "type": "thinking",
+        "thinking": "",
+        "signature": "omitted_sig_999",
+    }
+    norm_omit = builder._normalize_thought_block(omitted_block)
+    assert norm_omit == {
+        "type": "thinking",
+        "thinking": "",
+        "signature": "omitted_sig_999",
+    }
+
+    # Redacted thinking block
+    redacted_block = {
+        "type": "redacted_thinking",
+        "data": "encrypted_thought_data",
+    }
+    norm_redacted = builder._normalize_thought_block(redacted_block)
+    assert norm_redacted == {
+        "type": "redacted_thinking",
+        "data": "encrypted_thought_data",
+    }
+
+    # Replay assistant message with normalized blocks and fallback for empty content
+    req = GenerationRequest(
+        messages=[
+            Message(role="user", content="Test"),
+            Message(role="assistant", content="", thought_blocks=(gem_block,)),
+        ]
+    )
+    payload = builder.build(req)
+    asst_content = payload["messages"][1]["content"]
+    assert len(asst_content) == 1
+    assert asst_content[0]["type"] == "thinking"
+    assert asst_content[0]["signature"] == "gem_sig_789"
+
+
+def test_anthropic_parser_reasoning_summary_and_omitted() -> None:
+    from evidor.agent.providers.anthropic.parser import AnthropicResponseParser
+
+    parser = AnthropicResponseParser(model="claude-3-7-sonnet")
+
+    # 1. Summarized thinking block: thinking has text
+    resp_sum = {
+        "id": "msg_sum_01",
+        "content": [
+            {"type": "thinking", "summary": "Core algorithm design steps", "signature": "sig_sum_1"},
+            {"type": "text", "text": "Here is the implementation"},
+        ],
+    }
+    res_sum = parser.parse(resp_sum)
+    assert res_sum.thinking == "Core algorithm design steps"
+    assert len(res_sum.thought_blocks) == 1
+    assert res_sum.thought_blocks[0] == {
+        "type": "thinking",
+        "thinking": "Core algorithm design steps",
+        "signature": "sig_sum_1",
+    }
+
+    # 2. Omitted thinking block: thinking is empty string ""
+    resp_omit = {
+        "id": "msg_omit_02",
+        "content": [
+            {"type": "thinking", "thinking": "", "signature": "sig_omit_2"},
+            {"type": "text", "text": "Fast response"},
+        ],
+    }
+    res_omit = parser.parse(resp_omit)
+    assert res_omit.thinking is None  # Omitted thinking text should not expose empty string
+    assert len(res_omit.thought_blocks) == 1
+    assert res_omit.thought_blocks[0] == {
+        "type": "thinking",
+        "thinking": "",
+        "signature": "sig_omit_2",
+    }
+
+
+def test_anthropic_stream_reasoning_summary_and_signature_accumulation() -> None:
+    from evidor.agent.providers.anthropic.stream import AnthropicStreamHandler
+
+    handler = AnthropicStreamHandler(model="claude-3-7-sonnet")
+
+    events = [
+        {"type": "message_start", "message": {"id": "msg_str_01", "model": "claude-3-7-sonnet"}},
+        {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}},
+        {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "First reasoning step. "}},
+        {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_summary_delta", "summary": "Second reasoning step."}},
+        {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "sig_part1_"}},
+        {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "sig_part2"}},
+        {"type": "content_block_stop", "index": 0},
+        {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}},
+        {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "Final answer."}},
+        {"type": "content_block_stop", "index": 1},
+        {"type": "message_stop"},
+    ]
+
+    chunks = []
+    for ev in events:
+        chunks.extend(list(handler.process_event(ev)))
+
+    finished_chunk = next(c for c in chunks if c.is_finished)
+    final_resp = finished_chunk.response
+    assert final_resp is not None
+    assert final_resp.text == "Final answer."
+    assert final_resp.thinking == "First reasoning step. Second reasoning step."
+    assert len(final_resp.thought_blocks) == 1
+    assert final_resp.thought_blocks[0] == {
+        "type": "thinking",
+        "thinking": "First reasoning step. Second reasoning step.",
+        "signature": "sig_part1_sig_part2",
+    }
+
+
 # ==============================================================================
 # GeminiProvider Thinking Tests
 # ==============================================================================