evidor 1.10.7.dev1__tar.gz → 1.11.0.dev1__tar.gz

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

@@ -2,6 +2,17 @@
 
 <!-- version list -->
 
+## v1.11.0-dev.1 (2026-11-03)
+
+### Features
+
+- **agent**: Centralized thinking configs
+  ([`4a05c49`](https://github.com/vedangiitb/evidor-core/commit/4a05c49bbae3852a10d9597c6c27c1d9cdd335af))
+
+
+## v1.10.7 (2026-11-02)
+
+
 ## v1.10.7-dev.1 (2026-11-02)
 
 ### Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.10.7-dev.1
+Version: 1.11.0-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
@@ -443,7 +443,7 @@ For reasoning models (**OpenAI** `gpt-6-astra`, **Anthropic** `claude-3-7-sonnet
 ```python
 from evidor import Agent, AnthropicProvider
 
-agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=2048))
+agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high"))
 stream = agent.send("Solve: Which is greater, 9.11 or 9.9?", stream=True)
 
 for chunk in stream:
@@ -517,59 +517,79 @@ Evidor delegates retry handling directly to the underlying model provider SDKs (
 
 ### Configurable Thinking & Reasoning Mode
 
-Evidor provides first-class support for reasoning models across **OpenAI** (`gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-luna`), **Anthropic** (`claude-3-7-sonnet-20250219`), and **Gemini** (`gemini-3.8-flash`, `gemini-3.8-live-extended-thinking`, `gemini-3.1-pro-preview`). Thinking can be configured either using provider-specific typed configuration classes or natural shorthands.
+Evidor provides a centralized, provider-neutral `ThinkingConfig` for reasoning models across **OpenAI** (`gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-luna`), **Anthropic** (`claude-3-7-sonnet-20250219`), and **Gemini** (`gemini-3.8-flash`, `gemini-3.8-live-extended-thinking`, `gemini-3.1-pro-preview`).
+
+Instead of navigating provider-specific configuration differences, you configure thinking through **two simple, unified modes**:
+
+- **Mode 1: Shorthand Effort String** (e.g. `thinking="high"`, `thinking="medium"`, `thinking="low"`): Works universally across all providers. The effort level string is passed directly through to the underlying provider without client-side mapping or restrictions.
+- **Mode 2: Centralized `ThinkingConfig` Object**: When you need granular control over reasoning effort, token budget, or summaries.
 
 ```python
 from evidor import (
     Agent,
     AnthropicProvider,
-    AnthropicThinkingConfig,
     GeminiProvider,
-    GeminiThinkingConfig,
     OpenAIProvider,
-    OpenAIThinkingConfig,
+    ThinkingConfig,
 )
 
-# 1. OpenAI: Configure reasoning effort ('low', 'medium', 'high', 'xhigh', 'max')
-# Via shorthand:
-provider = OpenAIProvider(model="gpt-6-astra", thinking="high")
-# Or via typed config:
-provider = OpenAIProvider(model="gpt-6-astra", thinking=OpenAIThinkingConfig(effort="high"))
-
-# 2. Anthropic: Configure token budget or adaptive effort
-# Shorthand int (sets budget_tokens >= 1024; auto-bumps max_tokens if needed):
-provider = AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=4096)
-# Shorthand string (adaptive thinking):
-provider = AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high")
-# Or via typed config:
-provider = AnthropicProvider(
-    model="claude-3-7-sonnet-20250219",
-    thinking=AnthropicThinkingConfig(budget_tokens=4096),
+# ----------------------------------------------------------------------
+# Mode 1: Direct Effort String (universal across providers)
+# ----------------------------------------------------------------------
+# OpenAI (sets reasoning.effort):
+p_openai = OpenAIProvider(model="gpt-6-astra", thinking="high")
+
+# Anthropic (sets adaptive thinking with effort):
+p_anthropic = AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high")
+
+# Gemini (sets generation_config.thinking_level):
+p_gemini = GeminiProvider(model="gemini-3.8-flash", thinking="high")
+
+# ----------------------------------------------------------------------
+# Mode 2: Centralized ThinkingConfig Object
+# ----------------------------------------------------------------------
+# 1. OpenAI: Configure effort and reasoning summary
+p_openai_cfg = OpenAIProvider(
+    model="gpt-6-astra",
+    thinking=ThinkingConfig(effort="high", summary="auto"),
 )
 
-# 3. Gemini: 2 modes for thinking configuration
-# Mode 1: Thinking level string ('minimal', 'low', 'medium', 'high'):
-provider = GeminiProvider(model="gemini-3.8-flash", thinking="high")
+# 2. Anthropic: Configure extended budget tokens (budget_tokens >= 1024; auto-bumps max_tokens if needed)
+p_anthropic_cfg = AnthropicProvider(
+    model="claude-3-7-sonnet-20250219",
+    thinking=ThinkingConfig(budget_tokens=4096),
+)
 
-# Mode 2: Object supporting thinking_level, thinking_summaries ('auto', 'none'), or thinking_budget:
-provider = GeminiProvider(
+# 3. Gemini: Configure thinking level and summaries (or thinking budget for earlier models)
+p_gemini_cfg = GeminiProvider(
     model="gemini-3.8-flash",
-    thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto"),
+    thinking=ThinkingConfig(effort="medium", summary="auto"),
 )
 
-# Earlier models supporting numeric thinking_budget can also be configured via GeminiThinkingConfig:
-provider = GeminiProvider(
+# Earlier models supporting numeric thinking budget:
+p_gemini_budget = GeminiProvider(
     model="gemini-2.5-flash",
-    thinking=GeminiThinkingConfig(thinking_budget=2048),
+    thinking=ThinkingConfig(budget_tokens=2048),
 )
 ```
 
+#### Centralized `ThinkingConfig` Reference
+
+| 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. |
+| `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"`. |
+
+> [!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)`.
+
 #### Inspecting Thinking Steps & Reasoning Tokens
 
 When thinking is enabled and the provider outputs thought tokens, the response provides both the visible text and the internal reasoning scratchpad:
 
 ```python
-agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=2048))
+agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high"))
 response = agent.send("Solve this logic riddle step-by-step...")
 
 # Final visible response
@@ -1186,7 +1206,7 @@ phoenix_sink = PhoenixSink(capture_content=True, capture_thinking=True)
 langfuse_sink = LangfuseSink(capture_content=True, capture_thinking=True)
 
 agent = Agent(
-    AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=2048),
+    AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high"),
     telemetry=[console_sink, phoenix_sink],
 )
 response = agent.send("Analyze system security risks...")

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

@@ -356,7 +356,7 @@ For reasoning models (**OpenAI** `gpt-6-astra`, **Anthropic** `claude-3-7-sonnet
 ```python
 from evidor import Agent, AnthropicProvider
 
-agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=2048))
+agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high"))
 stream = agent.send("Solve: Which is greater, 9.11 or 9.9?", stream=True)
 
 for chunk in stream:
@@ -430,59 +430,79 @@ Evidor delegates retry handling directly to the underlying model provider SDKs (
 
 ### Configurable Thinking & Reasoning Mode
 
-Evidor provides first-class support for reasoning models across **OpenAI** (`gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-luna`), **Anthropic** (`claude-3-7-sonnet-20250219`), and **Gemini** (`gemini-3.8-flash`, `gemini-3.8-live-extended-thinking`, `gemini-3.1-pro-preview`). Thinking can be configured either using provider-specific typed configuration classes or natural shorthands.
+Evidor provides a centralized, provider-neutral `ThinkingConfig` for reasoning models across **OpenAI** (`gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-luna`), **Anthropic** (`claude-3-7-sonnet-20250219`), and **Gemini** (`gemini-3.8-flash`, `gemini-3.8-live-extended-thinking`, `gemini-3.1-pro-preview`).
+
+Instead of navigating provider-specific configuration differences, you configure thinking through **two simple, unified modes**:
+
+- **Mode 1: Shorthand Effort String** (e.g. `thinking="high"`, `thinking="medium"`, `thinking="low"`): Works universally across all providers. The effort level string is passed directly through to the underlying provider without client-side mapping or restrictions.
+- **Mode 2: Centralized `ThinkingConfig` Object**: When you need granular control over reasoning effort, token budget, or summaries.
 
 ```python
 from evidor import (
     Agent,
     AnthropicProvider,
-    AnthropicThinkingConfig,
     GeminiProvider,
-    GeminiThinkingConfig,
     OpenAIProvider,
-    OpenAIThinkingConfig,
+    ThinkingConfig,
 )
 
-# 1. OpenAI: Configure reasoning effort ('low', 'medium', 'high', 'xhigh', 'max')
-# Via shorthand:
-provider = OpenAIProvider(model="gpt-6-astra", thinking="high")
-# Or via typed config:
-provider = OpenAIProvider(model="gpt-6-astra", thinking=OpenAIThinkingConfig(effort="high"))
-
-# 2. Anthropic: Configure token budget or adaptive effort
-# Shorthand int (sets budget_tokens >= 1024; auto-bumps max_tokens if needed):
-provider = AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=4096)
-# Shorthand string (adaptive thinking):
-provider = AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high")
-# Or via typed config:
-provider = AnthropicProvider(
-    model="claude-3-7-sonnet-20250219",
-    thinking=AnthropicThinkingConfig(budget_tokens=4096),
+# ----------------------------------------------------------------------
+# Mode 1: Direct Effort String (universal across providers)
+# ----------------------------------------------------------------------
+# OpenAI (sets reasoning.effort):
+p_openai = OpenAIProvider(model="gpt-6-astra", thinking="high")
+
+# Anthropic (sets adaptive thinking with effort):
+p_anthropic = AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high")
+
+# Gemini (sets generation_config.thinking_level):
+p_gemini = GeminiProvider(model="gemini-3.8-flash", thinking="high")
+
+# ----------------------------------------------------------------------
+# Mode 2: Centralized ThinkingConfig Object
+# ----------------------------------------------------------------------
+# 1. OpenAI: Configure effort and reasoning summary
+p_openai_cfg = OpenAIProvider(
+    model="gpt-6-astra",
+    thinking=ThinkingConfig(effort="high", summary="auto"),
 )
 
-# 3. Gemini: 2 modes for thinking configuration
-# Mode 1: Thinking level string ('minimal', 'low', 'medium', 'high'):
-provider = GeminiProvider(model="gemini-3.8-flash", thinking="high")
+# 2. Anthropic: Configure extended budget tokens (budget_tokens >= 1024; auto-bumps max_tokens if needed)
+p_anthropic_cfg = AnthropicProvider(
+    model="claude-3-7-sonnet-20250219",
+    thinking=ThinkingConfig(budget_tokens=4096),
+)
 
-# Mode 2: Object supporting thinking_level, thinking_summaries ('auto', 'none'), or thinking_budget:
-provider = GeminiProvider(
+# 3. Gemini: Configure thinking level and summaries (or thinking budget for earlier models)
+p_gemini_cfg = GeminiProvider(
     model="gemini-3.8-flash",
-    thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto"),
+    thinking=ThinkingConfig(effort="medium", summary="auto"),
 )
 
-# Earlier models supporting numeric thinking_budget can also be configured via GeminiThinkingConfig:
-provider = GeminiProvider(
+# Earlier models supporting numeric thinking budget:
+p_gemini_budget = GeminiProvider(
     model="gemini-2.5-flash",
-    thinking=GeminiThinkingConfig(thinking_budget=2048),
+    thinking=ThinkingConfig(budget_tokens=2048),
 )
 ```
 
+#### Centralized `ThinkingConfig` Reference
+
+| 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. |
+| `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"`. |
+
+> [!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)`.
+
 #### Inspecting Thinking Steps & Reasoning Tokens
 
 When thinking is enabled and the provider outputs thought tokens, the response provides both the visible text and the internal reasoning scratchpad:
 
 ```python
-agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=2048))
+agent = Agent(AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high"))
 response = agent.send("Solve this logic riddle step-by-step...")
 
 # Final visible response
@@ -1099,7 +1119,7 @@ phoenix_sink = PhoenixSink(capture_content=True, capture_thinking=True)
 langfuse_sink = LangfuseSink(capture_content=True, capture_thinking=True)
 
 agent = Agent(
-    AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking=2048),
+    AnthropicProvider(model="claude-3-7-sonnet-20250219", thinking="high"),
     telemetry=[console_sink, phoenix_sink],
 )
 response = agent.send("Analyze system security risks...")

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

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

{evidor-1.10.7.dev1 → evidor-1.11.0.dev1}/src/evidor/__init__.py

@@ -13,18 +13,16 @@ from .mcp import (
 )
 from .models import (
     AnyThinkingConfig,
-    AnthropicThinkingConfig,
     AsyncStreamResponse,
-    GeminiThinkingConfig,
     GenerationRequest,
     GenerationResponse,
     Message,
-    OpenAIThinkingConfig,
     SearchResult,
     StreamChunk,
     StreamResponse,
     ThinkingConfig,
     ThinkingEffort,
+    ThinkingSummary,
     ToolCall,
 )
 
@@ -77,7 +75,6 @@ from .tools import (
 __all__ = [
     "Agent",
     "AnthropicProvider",
-    "AnthropicThinkingConfig",
     "AnyThinkingConfig",
     "AsyncStreamResponse",
     "BraveSearchProvider",
@@ -91,7 +88,6 @@ __all__ = [
     "ExaSearchProvider",
     "fetch_webpage_content",
     "GeminiProvider",
-    "GeminiThinkingConfig",
     "GenerationRequest",
     "GenerationResponse",
     "get_current_time",
@@ -105,7 +101,6 @@ __all__ = [
     "Message",
     "ModelProvider",
     "OpenAIProvider",
-    "OpenAIThinkingConfig",
     "OpenTelemetrySink",
     "PhoenixSink",
     "PrometheusSink",
@@ -121,6 +116,7 @@ __all__ = [
     "TelemetrySink",
     "ThinkingConfig",
     "ThinkingEffort",
+    "ThinkingSummary",
     "Tool",
     "ToolCall",
     "TraceContext",

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

@@ -27,7 +27,7 @@ class AnthropicPayloadBuilder:
         self.compact_threshold = compact_threshold
         self.compact_instructions = compact_instructions
 
-    def build(self, request: GenerationRequest) -> dict[str, Any]:
+    def build(self, request: GenerationRequest, thinking: Any = None) -> dict[str, Any]:
         """Construct the full request dictionary for Anthropic Messages API."""
         system_prompt = extract_system_prompt(request)
         formatted_messages = self.format_messages(request.messages)
@@ -48,22 +48,32 @@ class AnthropicPayloadBuilder:
             payload["betas"] = ["compact-2026-01-12"]
             payload["context_management"] = {"edits": [edit]}
 
-        if self.thinking and self.thinking.enabled:
-            if getattr(self.thinking, "type", "enabled") == "adaptive":
-                payload["thinking"] = {"type": "adaptive"}
-                if getattr(self.thinking, "effort", None):
-                    payload["output_config"] = {"effort": self.thinking.effort}
-            else:
-                budget = getattr(self.thinking, "budget_tokens", None)
-                if budget is None or budget < 1024:
-                    budget = 1024
+        active_thinking = thinking if thinking is not None else self.thinking
+        if active_thinking and isinstance(active_thinking, str):
+            payload["thinking"] = {"type": "adaptive"}
+            payload["output_config"] = {"effort": active_thinking}
+        elif active_thinking and not isinstance(active_thinking, (bool, int)):
+            budget = (
+                active_thinking.get("budget_tokens")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "budget_tokens", None)
+            )
+            effort = (
+                active_thinking.get("effort")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "effort", None)
+            )
+            if budget is not None and not isinstance(budget, bool) and budget > 0:
+                actual_budget = max(budget, 1024)
                 payload["thinking"] = {
                     "type": "enabled",
-                    "budget_tokens": budget,
+                    "budget_tokens": actual_budget,
                 }
-                # Anthropic Messages API requires max_tokens > budget_tokens
-                if payload["max_tokens"] <= budget:
-                    payload["max_tokens"] = budget + 1024
+                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}
 
         if self.enable_prompt_caching:
             payload["cache_control"] = {"type": "ephemeral"}

{evidor-1.10.7.dev1 → evidor-1.11.0.dev1}/src/evidor/agent/providers/anthropic/provider.py

@@ -47,19 +47,7 @@ class AnthropicProvider(BaseProvider):
         compact_instructions: str | None = None,
         base_url: str | None = None,
     ) -> None:
-        if thinking is not None:
-            from evidor.models import AnthropicThinkingConfig
-
-            thinking_cfg: AnthropicThinkingConfig | None = (
-                thinking
-                if isinstance(thinking, AnthropicThinkingConfig)
-                else AnthropicThinkingConfig.from_value(thinking)
-            )
-            thinking_cfg.validate()
-        else:
-            thinking_cfg = None
-
-        super().__init__(model=model, api_key=api_key, thinking=thinking_cfg)
+        super().__init__(model=model, api_key=api_key, thinking=thinking)
         self._enable_prompt_caching = enable_prompt_caching
         self._compact_threshold = compact_threshold
         self._compact_instructions = compact_instructions
@@ -69,8 +57,13 @@ class AnthropicProvider(BaseProvider):
         self._async_clients: dict[asyncio.AbstractEventLoop, Any] = {}
 
         if max_tokens is None:
-            if self._thinking and self._thinking.enabled and self._thinking.budget_tokens:
-                max_tokens = self._thinking.budget_tokens + 2048
+            budget = (
+                self._thinking.get("budget_tokens")
+                if isinstance(self._thinking, dict)
+                else getattr(self._thinking, "budget_tokens", None)
+            )
+            if budget is not None and not isinstance(budget, bool) and budget > 0:
+                max_tokens = budget + 2048
             else:
                 max_tokens = 1024
         self._max_tokens = max_tokens

{evidor-1.10.7.dev1 → evidor-1.11.0.dev1}/src/evidor/agent/providers/gemini/builder.py

@@ -175,31 +175,34 @@ class GeminiPayloadBuilder:
         active_thinking = thinking if thinking is not None else self.thinking
         if active_thinking and isinstance(active_thinking, str):
             payload["generation_config"] = {"thinking_level": active_thinking}
-        elif active_thinking and not isinstance(active_thinking, bool):
+        elif active_thinking and not isinstance(active_thinking, (bool, int)):
             gen_config: dict[str, Any] = {}
-            thinking_level = (
-                active_thinking.get("thinking_level")
+            effort = (
+                active_thinking.get("effort") or active_thinking.get("thinking_level")
                 if isinstance(active_thinking, dict)
-                else getattr(active_thinking, "thinking_level", None)
+                else getattr(active_thinking, "effort", None) or getattr(active_thinking, "thinking_level", None)
             )
-            if isinstance(thinking_level, str):
-                gen_config["thinking_level"] = thinking_level
+            if isinstance(effort, str):
+                gen_config["thinking_level"] = effort
 
-            thinking_summaries = (
-                active_thinking.get("thinking_summaries")
+            summary = (
+                active_thinking.get("summary") or active_thinking.get("thinking_summaries")
                 if isinstance(active_thinking, dict)
-                else getattr(active_thinking, "thinking_summaries", None)
+                else getattr(active_thinking, "summary", None) or getattr(active_thinking, "thinking_summaries", None)
             )
-            if isinstance(thinking_summaries, str):
-                gen_config["thinking_summaries"] = thinking_summaries
+            if isinstance(summary, str):
+                if summary.lower() == "none":
+                    gen_config["thinking_summaries"] = "none"
+                else:
+                    gen_config["thinking_summaries"] = "auto"
 
-            thinking_budget = (
-                active_thinking.get("thinking_budget")
+            budget = (
+                active_thinking.get("budget_tokens") or active_thinking.get("thinking_budget")
                 if isinstance(active_thinking, dict)
-                else getattr(active_thinking, "thinking_budget", None)
+                else getattr(active_thinking, "budget_tokens", None) or getattr(active_thinking, "thinking_budget", None)
             )
-            if thinking_budget is not None and not isinstance(thinking_budget, bool):
-                gen_config["thinking_budget"] = thinking_budget
+            if budget is not None and not isinstance(budget, bool) and budget > 0:
+                gen_config["thinking_budget"] = budget
 
             if gen_config:
                 payload["generation_config"] = gen_config

{evidor-1.10.7.dev1 → evidor-1.11.0.dev1}/src/evidor/agent/providers/openai/builder.py

@@ -21,7 +21,7 @@ class OpenAIPayloadBuilder:
         self.thinking = thinking
         self.compact_threshold = compact_threshold
 
-    def build(self, request: GenerationRequest) -> dict[str, Any]:
+    def build(self, request: GenerationRequest, thinking: Any = None) -> dict[str, Any]:
         """Construct the full request dictionary for OpenAI Responses API."""
         payload: dict[str, Any] = {
             "model": self.model,
@@ -42,16 +42,27 @@ class OpenAIPayloadBuilder:
                 {"type": "compaction", "compact_threshold": self.compact_threshold}
             ]
 
-        if self.thinking is not None:
+        active_thinking = thinking if thinking is not None else self.thinking
+        if active_thinking and isinstance(active_thinking, str):
+            payload["reasoning"] = {"effort": active_thinking}
+        elif active_thinking and not isinstance(active_thinking, (bool, int)):
             reasoning_config: dict[str, Any] = {}
-            if self.thinking.enabled:
-                if self.thinking.effort:
-                    reasoning_config["effort"] = self.thinking.effort
-                summary_val = getattr(self.thinking, "summary", None)
-                if summary_val:
-                    reasoning_config["summary"] = summary_val
-            else:
-                reasoning_config["effort"] = "none"
+            effort = (
+                active_thinking.get("effort")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "effort", None)
+            )
+            if isinstance(effort, str):
+                reasoning_config["effort"] = effort
+
+            summary_val = (
+                active_thinking.get("summary")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "summary", None)
+            )
+            if isinstance(summary_val, str) and summary_val.lower() != "none":
+                reasoning_config["summary"] = summary_val
+
             if reasoning_config:
                 payload["reasoning"] = reasoning_config
 

{evidor-1.10.7.dev1 → evidor-1.11.0.dev1}/src/evidor/agent/providers/openai/provider.py

@@ -33,19 +33,7 @@ class OpenAIProvider(BaseProvider):
         compact_threshold: int | None = None,
         base_url: str | None = None,
     ) -> None:
-        if thinking is not None:
-            from evidor.models import OpenAIThinkingConfig
-
-            thinking_cfg: OpenAIThinkingConfig | None = (
-                thinking
-                if isinstance(thinking, OpenAIThinkingConfig)
-                else OpenAIThinkingConfig.from_value(thinking)
-            )
-            thinking_cfg.validate()
-        else:
-            thinking_cfg = None
-
-        super().__init__(model=model, api_key=api_key, thinking=thinking_cfg)
+        super().__init__(model=model, api_key=api_key, thinking=thinking)
         self._compact_threshold = compact_threshold
         self._base_url = base_url
         self._sync_client: Any = None

{evidor-1.10.7.dev1 → evidor-1.11.0.dev1}/src/evidor/models/__init__.py

@@ -14,20 +14,16 @@ from .streaming import (
     StreamResponse,
 )
 from .thinking import (
-    AnthropicThinkingConfig,
     AnyThinkingConfig,
-    GeminiThinkingConfig,
-    OpenAIThinkingConfig,
     ThinkingConfig,
     ThinkingEffort,
+    ThinkingSummary,
 )
 
 __all__ = [
     "ThinkingConfig",
     "ThinkingEffort",
-    "OpenAIThinkingConfig",
-    "AnthropicThinkingConfig",
-    "GeminiThinkingConfig",
+    "ThinkingSummary",
     "AnyThinkingConfig",
     "SearchResult",
     "ToolCall",

evidor-1.11.0.dev1/src/evidor/models/thinking.py

@@ -0,0 +1,51 @@
+"""Thinking and reasoning configuration for models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+ThinkingEffort = str
+ThinkingSummary = str
+
+
+@dataclass(frozen=True, slots=True)
+class ThinkingConfig:
+    """Centralized, provider-neutral reasoning and thinking configuration.
+
+    Attributes:
+        effort: Desired thinking depth or reasoning level (e.g. 'minimal', 'low', 'medium', 'high', 'xhigh', 'max').
+            Passed directly to the provider without client-side mapping or restriction.
+        budget_tokens: Token budget for reasoning where supported (e.g. Anthropic extended thinking or earlier Gemini models).
+        summary: Reasoning summary exposure (e.g. 'auto', 'concise', 'detailed', 'none').
+    """
+
+    effort: ThinkingEffort | None = None
+    budget_tokens: int | None = None
+    summary: ThinkingSummary | None = None
+
+    def validate(self) -> None:
+        """Provider-neutral constraint checks."""
+        pass
+
+    @classmethod
+    def from_value(cls, value: Any) -> ThinkingConfig:
+        """Coerce a value to ThinkingConfig."""
+        if isinstance(value, ThinkingConfig):
+            return value
+        if isinstance(value, str):
+            return cls(effort=value)
+        if isinstance(value, dict):
+            return cls(
+                effort=value.get("effort"),
+                budget_tokens=value.get("budget_tokens"),
+                summary=value.get("summary"),
+            )
+        raise TypeError(
+            f"Cannot coerce {type(value).__name__} to ThinkingConfig. "
+            "Thinking must be configured either as an effort string (e.g. thinking='high') "
+            "or via ThinkingConfig(effort=..., budget_tokens=..., summary=...)."
+        )
+
+
+AnyThinkingConfig = ThinkingConfig