evidor 1.10.6.dev1__tar.gz → 1.10.7.dev1__tar.gz

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

@@ -2,6 +2,17 @@
 
 <!-- version list -->
 
+## v1.10.7-dev.1 (2026-11-02)
+
+### Bug Fixes
+
+- **gemini**: Fixing thinking related issues
+  ([`4451ea1`](https://github.com/vedangiitb/evidor-core/commit/4451ea1d3d5039fd0cc276b9f6b0f6ceb88c5a92))
+
+
+## v1.10.6 (2026-10-31)
+
+
 ## v1.10.6-dev.1 (2026-10-30)
 
 ### Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.10.6-dev.1
+Version: 1.10.7-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
@@ -547,16 +547,21 @@ provider = AnthropicProvider(
     thinking=AnthropicThinkingConfig(budget_tokens=4096),
 )
 
-# 3. Gemini: Configure thinking level ('minimal', 'low', 'medium', 'high') and summaries ('auto', 'none')
-# Shorthand string (Gemini 3.x thinking_level):
+# 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")
-# Shorthand bool (False disables thinking; True enables default thinking):
-provider = GeminiProvider(model="gemini-3.8-flash", thinking=False)
-# Or via typed config:
+
+# Mode 2: Object supporting thinking_level, thinking_summaries ('auto', 'none'), or thinking_budget:
 provider = GeminiProvider(
     model="gemini-3.8-flash",
     thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto"),
 )
+
+# Earlier models supporting numeric thinking_budget can also be configured via GeminiThinkingConfig:
+provider = GeminiProvider(
+    model="gemini-2.5-flash",
+    thinking=GeminiThinkingConfig(thinking_budget=2048),
+)
 ```
 
 #### Inspecting Thinking Steps & Reasoning Tokens
@@ -1286,7 +1291,7 @@ Supported providers, example models, and reasoning/thinking support:
 | --- | --- | --- | --- | --- |
 | `OpenAIProvider` | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-luna`, `gpt-4.1-mini` | `reasoning_effort` (`"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`) | `OPENAI_API_KEY` | `evidor[openai]` |
 | `AnthropicProvider` | `claude-3-7-sonnet` | Extended budget (`budget_tokens >= 1024`) or adaptive | `ANTHROPIC_API_KEY` | `evidor[anthropic]` |
-| `GeminiProvider` | `gemini-3.8-flash`, `gemini-3.5-flash-lite`, `gemini-3.1-pro-preview` | `thinking_level` (`"minimal"`, `"low"`, `"medium"`, `"high"`), `thinking_summaries` (`"auto"`, `"none"`) | `GEMINI_API_KEY` | `evidor[gemini]` |
+| `GeminiProvider` | `gemini-3.8-flash`, `gemini-3.5-flash-lite`, `gemini-3.1-pro-preview` | `thinking_level` (`"minimal"`, `"low"`, `"medium"`, `"high"`), `thinking_summaries` (`"auto"`, `"none"`), or `thinking_budget` | `GEMINI_API_KEY` | `evidor[gemini]` |
 
 API keys can be supplied explicitly via the `api_key` constructor argument or read automatically from environment variables. Custom base URLs for OpenAI-compatible providers (such as DeepSeek) can be supplied via the `base_url` constructor argument or `OPENAI_BASE_URL` environment variable:
 

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

@@ -460,16 +460,21 @@ provider = AnthropicProvider(
     thinking=AnthropicThinkingConfig(budget_tokens=4096),
 )
 
-# 3. Gemini: Configure thinking level ('minimal', 'low', 'medium', 'high') and summaries ('auto', 'none')
-# Shorthand string (Gemini 3.x thinking_level):
+# 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")
-# Shorthand bool (False disables thinking; True enables default thinking):
-provider = GeminiProvider(model="gemini-3.8-flash", thinking=False)
-# Or via typed config:
+
+# Mode 2: Object supporting thinking_level, thinking_summaries ('auto', 'none'), or thinking_budget:
 provider = GeminiProvider(
     model="gemini-3.8-flash",
     thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto"),
 )
+
+# Earlier models supporting numeric thinking_budget can also be configured via GeminiThinkingConfig:
+provider = GeminiProvider(
+    model="gemini-2.5-flash",
+    thinking=GeminiThinkingConfig(thinking_budget=2048),
+)
 ```
 
 #### Inspecting Thinking Steps & Reasoning Tokens
@@ -1199,7 +1204,7 @@ Supported providers, example models, and reasoning/thinking support:
 | --- | --- | --- | --- | --- |
 | `OpenAIProvider` | `gpt-6-astra`, `gpt-6.1-sol`, `gpt-6-luna`, `gpt-4.1-mini` | `reasoning_effort` (`"low"`, `"medium"`, `"high"`, `"xhigh"`, `"max"`) | `OPENAI_API_KEY` | `evidor[openai]` |
 | `AnthropicProvider` | `claude-3-7-sonnet` | Extended budget (`budget_tokens >= 1024`) or adaptive | `ANTHROPIC_API_KEY` | `evidor[anthropic]` |
-| `GeminiProvider` | `gemini-3.8-flash`, `gemini-3.5-flash-lite`, `gemini-3.1-pro-preview` | `thinking_level` (`"minimal"`, `"low"`, `"medium"`, `"high"`), `thinking_summaries` (`"auto"`, `"none"`) | `GEMINI_API_KEY` | `evidor[gemini]` |
+| `GeminiProvider` | `gemini-3.8-flash`, `gemini-3.5-flash-lite`, `gemini-3.1-pro-preview` | `thinking_level` (`"minimal"`, `"low"`, `"medium"`, `"high"`), `thinking_summaries` (`"auto"`, `"none"`), or `thinking_budget` | `GEMINI_API_KEY` | `evidor[gemini]` |
 
 API keys can be supplied explicitly via the `api_key` constructor argument or read automatically from environment variables. Custom base URLs for OpenAI-compatible providers (such as DeepSeek) can be supplied via the `base_url` constructor argument or `OPENAI_BASE_URL` environment variable:
 

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

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

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

@@ -138,7 +138,12 @@ class GeminiPayloadBuilder:
 
         return cleaned
 
-    def build(self, request: GenerationRequest, types: Any = None) -> dict[str, Any]:
+    def build(
+        self,
+        request: GenerationRequest,
+        types: Any = None,
+        thinking: Any = None,
+    ) -> dict[str, Any]:
         """Construct the full request dictionary for Gemini Interactions API."""
         system_prompt = extract_system_prompt(request)
         input_steps = self.format_input_steps(request.messages)
@@ -167,19 +172,34 @@ class GeminiPayloadBuilder:
                 for t in sorted_tools
             ]
 
-        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["generation_config"] = {"thinking_level": active_thinking}
+        elif active_thinking and not isinstance(active_thinking, bool):
             gen_config: dict[str, Any] = {}
-            if not getattr(self.thinking, "enabled", True):
-                gen_config["thinking_level"] = "minimal"
-                gen_config["thinking_summaries"] = "none"
-            else:
-                thinking_level = getattr(self.thinking, "thinking_level", None)
-                if thinking_level:
-                    gen_config["thinking_level"] = thinking_level
-
-                thinking_summaries = getattr(self.thinking, "thinking_summaries", None)
-                if thinking_summaries:
-                    gen_config["thinking_summaries"] = thinking_summaries
+            thinking_level = (
+                active_thinking.get("thinking_level")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "thinking_level", None)
+            )
+            if isinstance(thinking_level, str):
+                gen_config["thinking_level"] = thinking_level
+
+            thinking_summaries = (
+                active_thinking.get("thinking_summaries")
+                if isinstance(active_thinking, dict)
+                else getattr(active_thinking, "thinking_summaries", None)
+            )
+            if isinstance(thinking_summaries, str):
+                gen_config["thinking_summaries"] = thinking_summaries
+
+            thinking_budget = (
+                active_thinking.get("thinking_budget")
+                if isinstance(active_thinking, dict)
+                else 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 gen_config:
                 payload["generation_config"] = gen_config

{evidor-1.10.6.dev1 → evidor-1.10.7.dev1}/src/evidor/agent/providers/gemini/provider.py

@@ -32,19 +32,7 @@ class GeminiProvider(BaseProvider):
         cached_content: str | None = None,
         thinking: Any = None,
     ) -> None:
-        if thinking is not None:
-            from evidor.models import GeminiThinkingConfig
-
-            thinking_cfg: GeminiThinkingConfig | None = (
-                thinking
-                if isinstance(thinking, GeminiThinkingConfig)
-                else GeminiThinkingConfig.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._cached_content = cached_content
         self._client: Any = None
         self._types: Any = None

{evidor-1.10.6.dev1 → evidor-1.10.7.dev1}/src/evidor/models/thinking.py

@@ -67,11 +67,12 @@ class AnthropicThinkingConfig(ThinkingConfig):
 
 
 @dataclass(frozen=True, slots=True)
-class GeminiThinkingConfig(ThinkingConfig):
+class GeminiThinkingConfig:
     """Configuration for Google Gemini thinking models in the Interactions API."""
 
     thinking_level: str | None = None  # Supported in Gemini 3.x Interactions API: 'minimal', 'low', 'medium', 'high'
-    thinking_summaries: str | None = "auto"  # Supported in Gemini Interactions API: 'auto', 'none'
+    thinking_summaries: str | None = None  # Supported in Gemini Interactions API: 'auto', 'none'
+    thinking_budget: int | None = None  # Supported in earlier Gemini models (e.g. Gemini 2.5)
 
     def validate(self) -> None:
         pass
@@ -81,15 +82,19 @@ class GeminiThinkingConfig(ThinkingConfig):
         if isinstance(value, GeminiThinkingConfig):
             return value
         if isinstance(value, bool):
-            if value:
-                return cls(enabled=True, thinking_summaries="auto")
-            return cls(enabled=False, thinking_level="minimal", thinking_summaries="none")
+            raise TypeError(
+                "Cannot coerce bool to GeminiThinkingConfig. "
+                "Gemini Interactions API supports thinking_level (e.g. 'minimal', 'low', 'medium', 'high'), "
+                "thinking_summaries ('auto', 'none'), or thinking_budget (int)."
+            )
+        if isinstance(value, int):
+            return cls(thinking_budget=value)
         if isinstance(value, str):
-            return cls(enabled=True, thinking_level=value, thinking_summaries="auto")
+            return cls(thinking_level=value)
         raise TypeError(
             f"Cannot coerce {type(value).__name__} to GeminiThinkingConfig. "
-            "Gemini Interactions API supports thinking_level (e.g. 'minimal', 'low', 'medium', 'high') "
-            "and thinking_summaries ('auto', 'none'). Numeric budgets are not supported."
+            "Gemini Interactions API supports thinking_level (e.g. 'minimal', 'low', 'medium', 'high'), "
+            "thinking_summaries ('auto', 'none'), or thinking_budget (int)."
         )
 
 

{evidor-1.10.6.dev1 → evidor-1.10.7.dev1}/tests/test_providers.py

@@ -1414,7 +1414,17 @@ def test_gemini_payload_builder_thinking_config() -> None:
 
     req = GenerationRequest(prompt="hello")
 
-    # 1. Arbitrary / future thinking_level (no model check, no whitelist)
+    # Mode 1: thinking="..." (user configures thinking as a string)
+    b_str = GeminiPayloadBuilder(
+        model="gemini-3.8-flash",
+        thinking="high",
+    )
+    p_str = b_str.build(req)
+    assert p_str["generation_config"] == {
+        "thinking_level": "high",
+    }
+
+    # Mode 2: Arbitrary / future thinking_level with thinking_summaries
     b_custom = GeminiPayloadBuilder(
         model="gemini-3.8-flash",
         thinking=GeminiThinkingConfig(thinking_level="experimental_deep", thinking_summaries="auto"),
@@ -1425,7 +1435,7 @@ def test_gemini_payload_builder_thinking_config() -> None:
         "thinking_summaries": "auto",
     }
 
-    # 2. thinking_summaries="none"
+    # Mode 2: thinking_summaries="none"
     b_no_thoughts = GeminiPayloadBuilder(
         model="gemini-3.8-flash",
         thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="none"),
@@ -1436,17 +1446,31 @@ def test_gemini_payload_builder_thinking_config() -> None:
         "thinking_summaries": "none",
     }
 
-    # 3. enabled=False disabled thinking -> minimal + none
-    b_off = GeminiPayloadBuilder(
+    # Mode 2: thinking_budget supported without error on client side
+    b_budget = GeminiPayloadBuilder(
         model="gemini-3.8-flash",
-        thinking=GeminiThinkingConfig(enabled=False),
+        thinking=GeminiThinkingConfig(thinking_budget=2048),
     )
-    p_off = b_off.build(req)
-    assert p_off["generation_config"] == {
-        "thinking_level": "minimal",
-        "thinking_summaries": "none",
+    p_budget = b_budget.build(req)
+    assert p_budget["generation_config"] == {
+        "thinking_budget": 2048,
     }
 
+    # Don't handle for thinking=False
+    b_false = GeminiPayloadBuilder(
+        model="gemini-3.8-flash",
+        thinking=False,
+    )
+    p_false = b_false.build(req)
+    assert "generation_config" not in p_false
+
+    # build() handles thinking passed directly without needing it at init
+    b_dynamic = GeminiPayloadBuilder(model="gemini-3.8-flash")
+    p_dyn_str = b_dynamic.build(req, thinking="low")
+    assert p_dyn_str["generation_config"] == {"thinking_level": "low"}
+    p_dyn_obj = b_dynamic.build(req, thinking=GeminiThinkingConfig(thinking_budget=4096))
+    assert p_dyn_obj["generation_config"] == {"thinking_budget": 4096}
+
 
 def test_gemini_payload_builder_types_optional() -> None:
     from evidor.agent.providers.gemini.builder import GeminiPayloadBuilder

{evidor-1.10.6.dev1 → evidor-1.10.7.dev1}/tests/test_thinking.py

@@ -104,34 +104,30 @@ def test_gemini_thinking_config() -> None:
     cfg = GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto")
     assert cfg.thinking_level == "high"
     assert cfg.thinking_summaries == "auto"
+    assert not hasattr(cfg, "enabled")
     cfg.validate()
 
     # Dynamic / None
     cfg_dyn = GeminiThinkingConfig(thinking_level=None)
     cfg_dyn.validate()
 
-    # Disabled
-    cfg_off = GeminiThinkingConfig(enabled=False)
-    cfg_off.validate()
-
-    # Coercion from int -> raises TypeError because Interactions API does not support numeric budgets
-    with pytest.raises(TypeError, match="Numeric budgets are not supported"):
-        GeminiThinkingConfig.from_value(1024)
-
-    # Coercion from bool False -> minimal + none
-    c_false = GeminiThinkingConfig.from_value(False)
-    assert c_false.enabled is False
-    assert c_false.thinking_level == "minimal"
-    assert c_false.thinking_summaries == "none"
-
-    # Coercion from bool True
-    c_true = GeminiThinkingConfig.from_value(True)
-    assert c_true.enabled is True
+    # Coercion from int -> thinking_budget supported
+    c_int = GeminiThinkingConfig.from_value(1024)
+    assert c_int.thinking_budget == 1024
+    assert not hasattr(c_int, "enabled")
 
     # Coercion from str -> thinking_level (Gemini 3.x)
     c_str = GeminiThinkingConfig.from_value("high")
-    assert c_str.enabled is True
     assert c_str.thinking_level == "high"
+    assert not hasattr(c_str, "enabled")
+
+    # Enabled is not a parameter on GeminiThinkingConfig
+    with pytest.raises(TypeError):
+        GeminiThinkingConfig(enabled=True)  # type: ignore[call-arg]
+
+    # Bool coercion is not supported on GeminiThinkingConfig
+    with pytest.raises(TypeError, match="Cannot coerce bool to GeminiThinkingConfig"):
+        GeminiThinkingConfig.from_value(False)
 
 
 # ==============================================================================
@@ -335,13 +331,20 @@ def test_gemini_provider_thinking_extraction_and_config(monkeypatch: pytest.Monk
     assert call_config["thinking_level"] == "medium"
     assert call_config["thinking_summaries"] == "auto"
 
-    # Test Gemini 3.x thinking_level parameter
+    # Test Gemini 3.x thinking_level parameter (Mode 1: thinking="high")
     p_gemini_3 = GeminiProvider(model="gemini-3.8-flash", thinking="high")
-    assert p_gemini_3.thinking.thinking_level == "high"
+    assert p_gemini_3.thinking == "high"
     res_3 = p_gemini_3.generate(GenerationRequest(prompt="Explain logic"))
     call_config_3 = mock_client.interactions.create.call_args.kwargs["generation_config"]
     assert call_config_3["thinking_level"] == "high"
-    assert call_config_3["thinking_summaries"] == "auto"
+    assert "thinking_summaries" not in call_config_3
+
+    # Test Mode 2 with thinking_budget (earlier models)
+    p_gemini_budget = GeminiProvider(model="gemini-2.5-flash", thinking=GeminiThinkingConfig(thinking_budget=2048))
+    assert p_gemini_budget.thinking.thinking_budget == 2048
+    p_gemini_budget.generate(GenerationRequest(prompt="Explain logic"))
+    call_config_budget = mock_client.interactions.create.call_args.kwargs["generation_config"]
+    assert call_config_budget["thinking_budget"] == 2048
 
 
 def test_gemini_provider_disable_thinking(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -358,8 +361,9 @@ def test_gemini_provider_disable_thinking(monkeypatch: pytest.MonkeyPatch) -> No
     provider = GeminiProvider(model="gemini-3.8-flash", thinking=False)
     provider.generate(GenerationRequest(prompt="Fast query"))
 
-    call_config = mock_client.interactions.create.call_args.kwargs["generation_config"]
-    assert call_config["thinking_level"] == "minimal"
+    # When thinking=False, it is not handled, so no generation_config is passed
+    call_kwargs = mock_client.interactions.create.call_args.kwargs
+    assert "generation_config" not in call_kwargs
 
 
 # ==============================================================================