evidor 1.10.2.dev1__tar.gz → 1.10.3.dev1__tar.gz

{evidor-1.10.2.dev1 → evidor-1.10.3.dev1}/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 <!-- version list -->
 
+## v1.10.3-dev.1 (2026-10-22)
+
+### Bug Fixes
+
+- **agent**: Fix gemini streaming issues
+  ([`f9d64f2`](https://github.com/vedangiitb/evidor-core/commit/f9d64f25f195c97c3ee5dd01c18b1d852e92fb70))
+
+- **agent**: Fixing gemini request building, response parsing and adapter lifecycle issues
+  ([`a67efbe`](https://github.com/vedangiitb/evidor-core/commit/a67efbecc0c9331fc61a14ddbc7512b656ae5e95))
+
+### Documentation
+
+- **agent**: Docs update for stateless sessions update
+  ([`57569f8`](https://github.com/vedangiitb/evidor-core/commit/57569f843aa7ceeece9f47ac3abec5cfe48a175d))
+
+
+## v1.10.2 (2026-10-21)
+
+
 ## v1.10.2-dev.1 (2026-10-21)
 
 ### Bug Fixes

{evidor-1.10.2.dev1 → evidor-1.10.3.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.10.2-dev.1
+Version: 1.10.3-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
@@ -108,12 +108,13 @@ response = agent.send("Give a one-sentence explanation of dependency inversion."
 print(response.text)
 ```
 
-## Core Architecture: Two Execution Paradigms
+## Core Architecture: Execution Paradigms
 
-Evidor cleanly separates AI execution into two paradigms:
+Evidor cleanly separates AI execution into flexible paradigms:
 
-1. **Stateful Conversations (`Agent`) (Recommended)**: The primary and recommended way to build applications with Evidor. Conversations maintain state automatically across turns, so you don't have to pass the entire message history each time. Evidor manages session state, context continuation, and tool execution loops seamlessly under the hood.
-2. **Stateless LLM Calls (`provider.generate`)**: Direct single-turn or user-managed requests with tools, structured outputs, and raw message histories. Available when you need low-level control or want to manage message storage and persistence yourself.
+1. **Stateful Conversations (`Agent`) (Default & Recommended)**: The primary and recommended way to build applications with Evidor. Conversations maintain state automatically across turns, so you don't have to pass the entire message history each time. Evidor manages session state, context continuation, and tool execution loops seamlessly under the hood.
+2. **Stateless Agents (`Agent(..., stateless=True)`)**: When you want high-level agent capabilities (automatic multi-step tool execution loops, MCP tools, system prompts, and telemetry) but want every `.send()` / `.send_async()` call to execute completely independently without remembering past turns.
+3. **Stateless LLM Calls (`provider.generate`)**: Direct single-turn or user-managed requests with tools, structured outputs, and raw message histories. Available when you need low-level control or want to manage message storage and persistence yourself.
 
 ---
 
@@ -231,6 +232,38 @@ agent.reset()  # or agent.clear_history()
 print(agent.last_response_id)  # None
 ```
 
+### Stateless Agent (`stateless=True`)
+
+If you want the high-level capabilities of an `Agent`—automatic multi-step tool execution loops, MCP tools, system prompts, and telemetry—but want each `.send()` or `.send_async()` call to execute independently without remembering prior turns, pass `stateless=True`:
+
+```python
+from evidor import Agent, OpenAIProvider
+from evidor.tools import tool
+
+@tool
+def get_stock_price(ticker: str) -> float:
+    return 150.25
+
+# Each send() call executes independently without cross-turn memory
+agent = Agent(
+    OpenAIProvider(model="gpt-6-astra"),
+    system_prompt="You are a financial assistant.",
+    tools=[get_stock_price],
+    stateless=True,
+)
+
+# Turn 1: Invokes tool loop and returns answer
+resp1 = agent.send("What is AAPL's price?")
+
+# Turn 2: Starts completely fresh without prior turns or response chaining
+resp2 = agent.send("What did I just ask?")
+```
+
+**Key Advantages of `stateless=True`**:
+- **Automatic Inter-turn Isolation**: For OpenAI and Gemini, `previous_response_id` / `previous_interaction_id` are not chained across turns. For Anthropic, earlier turns are not replayed.
+- **Intra-turn Tool Loops Intact**: Multi-step tool calls *within* a single turn (tool call $\to$ tool result $\to$ final response) work seamlessly because state is preserved during the turn.
+- **Concurrency-Safe**: Each turn runs within an isolated ephemeral context frame, enabling concurrent `.send_async()` calls without cross-talk.
+
 ---
 
 ## 2. Stateless LLM Calls
@@ -514,15 +547,15 @@ provider = AnthropicProvider(
     thinking=AnthropicThinkingConfig(budget_tokens=4096),
 )
 
-# 3. Gemini: Configure thinking level ('minimal', 'low', 'medium', 'high') or budget
+# 3. Gemini: Configure thinking level ('minimal', 'low', 'medium', 'high') and summaries ('auto', 'none')
 # Shorthand string (Gemini 3.x thinking_level):
 provider = GeminiProvider(model="gemini-3.8-flash", thinking="high")
-# Shorthand bool (False disables thinking; True enables dynamic thinking):
+# Shorthand bool (False disables thinking; True enables default thinking):
 provider = GeminiProvider(model="gemini-3.8-flash", thinking=False)
 # Or via typed config:
 provider = GeminiProvider(
     model="gemini-3.8-flash",
-    thinking=GeminiThinkingConfig(thinking_level="high", include_thoughts=True),
+    thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto"),
 )
 ```
 
@@ -1253,7 +1286,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"`) or budget | `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"`) | `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.2.dev1 → evidor-1.10.3.dev1}/README.md

@@ -21,12 +21,13 @@ response = agent.send("Give a one-sentence explanation of dependency inversion."
 print(response.text)
 ```
 
-## Core Architecture: Two Execution Paradigms
+## Core Architecture: Execution Paradigms
 
-Evidor cleanly separates AI execution into two paradigms:
+Evidor cleanly separates AI execution into flexible paradigms:
 
-1. **Stateful Conversations (`Agent`) (Recommended)**: The primary and recommended way to build applications with Evidor. Conversations maintain state automatically across turns, so you don't have to pass the entire message history each time. Evidor manages session state, context continuation, and tool execution loops seamlessly under the hood.
-2. **Stateless LLM Calls (`provider.generate`)**: Direct single-turn or user-managed requests with tools, structured outputs, and raw message histories. Available when you need low-level control or want to manage message storage and persistence yourself.
+1. **Stateful Conversations (`Agent`) (Default & Recommended)**: The primary and recommended way to build applications with Evidor. Conversations maintain state automatically across turns, so you don't have to pass the entire message history each time. Evidor manages session state, context continuation, and tool execution loops seamlessly under the hood.
+2. **Stateless Agents (`Agent(..., stateless=True)`)**: When you want high-level agent capabilities (automatic multi-step tool execution loops, MCP tools, system prompts, and telemetry) but want every `.send()` / `.send_async()` call to execute completely independently without remembering past turns.
+3. **Stateless LLM Calls (`provider.generate`)**: Direct single-turn or user-managed requests with tools, structured outputs, and raw message histories. Available when you need low-level control or want to manage message storage and persistence yourself.
 
 ---
 
@@ -144,6 +145,38 @@ agent.reset()  # or agent.clear_history()
 print(agent.last_response_id)  # None
 ```
 
+### Stateless Agent (`stateless=True`)
+
+If you want the high-level capabilities of an `Agent`—automatic multi-step tool execution loops, MCP tools, system prompts, and telemetry—but want each `.send()` or `.send_async()` call to execute independently without remembering prior turns, pass `stateless=True`:
+
+```python
+from evidor import Agent, OpenAIProvider
+from evidor.tools import tool
+
+@tool
+def get_stock_price(ticker: str) -> float:
+    return 150.25
+
+# Each send() call executes independently without cross-turn memory
+agent = Agent(
+    OpenAIProvider(model="gpt-6-astra"),
+    system_prompt="You are a financial assistant.",
+    tools=[get_stock_price],
+    stateless=True,
+)
+
+# Turn 1: Invokes tool loop and returns answer
+resp1 = agent.send("What is AAPL's price?")
+
+# Turn 2: Starts completely fresh without prior turns or response chaining
+resp2 = agent.send("What did I just ask?")
+```
+
+**Key Advantages of `stateless=True`**:
+- **Automatic Inter-turn Isolation**: For OpenAI and Gemini, `previous_response_id` / `previous_interaction_id` are not chained across turns. For Anthropic, earlier turns are not replayed.
+- **Intra-turn Tool Loops Intact**: Multi-step tool calls *within* a single turn (tool call $\to$ tool result $\to$ final response) work seamlessly because state is preserved during the turn.
+- **Concurrency-Safe**: Each turn runs within an isolated ephemeral context frame, enabling concurrent `.send_async()` calls without cross-talk.
+
 ---
 
 ## 2. Stateless LLM Calls
@@ -427,15 +460,15 @@ provider = AnthropicProvider(
     thinking=AnthropicThinkingConfig(budget_tokens=4096),
 )
 
-# 3. Gemini: Configure thinking level ('minimal', 'low', 'medium', 'high') or budget
+# 3. Gemini: Configure thinking level ('minimal', 'low', 'medium', 'high') and summaries ('auto', 'none')
 # Shorthand string (Gemini 3.x thinking_level):
 provider = GeminiProvider(model="gemini-3.8-flash", thinking="high")
-# Shorthand bool (False disables thinking; True enables dynamic thinking):
+# Shorthand bool (False disables thinking; True enables default thinking):
 provider = GeminiProvider(model="gemini-3.8-flash", thinking=False)
 # Or via typed config:
 provider = GeminiProvider(
     model="gemini-3.8-flash",
-    thinking=GeminiThinkingConfig(thinking_level="high", include_thoughts=True),
+    thinking=GeminiThinkingConfig(thinking_level="high", thinking_summaries="auto"),
 )
 ```
 
@@ -1166,7 +1199,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"`) or budget | `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"`) | `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.2.dev1 → evidor-1.10.3.dev1}/pyproject.toml

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

{evidor-1.10.2.dev1 → evidor-1.10.3.dev1}/src/evidor/agent/core/agent.py

@@ -7,6 +7,12 @@ from collections.abc import Callable, Sequence
 import threading
 from typing import Any, Literal, overload
 
+from evidor.constants import (
+    AGENT_CLOSE_SYNC_ERROR,
+    AGENT_SEND_SYNC_ERROR,
+    AGENT_STREAM_SYNC_ERROR,
+    AGENT_SYNC_MCP_TOOLS_ERROR,
+)
 from evidor.models import (
     AsyncStreamResponse,
     GenerationResponse,
@@ -48,7 +54,15 @@ class Agent:
         store: bool | None = None,
         compact_threshold: int | None = None,
         telemetry: TelemetryRuntime | TelemetrySink | Sequence[TelemetrySink] | None = None,
+        stateless: bool = False,
     ) -> None:
+        if stateless:
+            if previous_response_id is not None:
+                raise ValueError("Cannot configure previous_response_id on a stateless Agent.")
+            if conversation_id is not None:
+                raise ValueError("Cannot configure conversation_id on a stateless Agent.")
+
+        self._stateless = stateless
         self._provider = provider
         self._system_prompt = system_prompt
         self._compact_threshold = compact_threshold or getattr(provider, "compact_threshold", None)
@@ -93,6 +107,7 @@ class Agent:
             tool_executor=self._tool_executor,
             telemetry_bridge=self._telemetry_bridge,
             max_tool_iterations=max_tool_iterations,
+            stateless=self._stateless,
         )
 
         # Background event loop and thread synchronization
@@ -117,6 +132,11 @@ class Agent:
         """
         return getattr(self._provider, "context_strategy", "stateless_replay")
 
+    @property
+    def stateless(self) -> bool:
+        """Whether this agent runs each turn statelessly without retaining conversation memory across turns."""
+        return self._stateless
+
     @property
     def last_response_id(self) -> str | None:
         """The identifier of the last response or interaction in this conversation."""
@@ -192,10 +212,7 @@ class Agent:
             return
         self._sync_loop.run(
             lambda: self._sync_mcp_tools_async(force=force),
-            error_message=(
-                "Cannot synchronize MCP tools synchronously from a running event loop. "
-                "Access agent.tools outside an event loop or run an async agent turn first."
-            ),
+            error_message=AGENT_SYNC_MCP_TOOLS_ERROR,
         )
 
     async def _sync_mcp_tools_async(self, force: bool = False) -> None:
@@ -230,16 +247,10 @@ class Agent:
             with self._lock:
                 return self._sync_loop.run(
                     lambda: self.send_async(message, stream=False),
-                    error_message=(
-                        "Agent.send() cannot be called from a running event loop. "
-                        "Use 'await agent.send_async()' instead."
-                    ),
+                    error_message=AGENT_SEND_SYNC_ERROR,
                 )
 
-        check_sync_allowed(
-            "Agent.send(..., stream=True) cannot be called from a running event loop. "
-            "Use 'await agent.send_async(..., stream=True)' instead."
-        )
+        check_sync_allowed(AGENT_STREAM_SYNC_ERROR)
         with self._lock:
             bridge = sync_stream_bridge(
                 self._sync_loop, lambda: self.send_async(message, stream=True)
@@ -282,10 +293,7 @@ class Agent:
                 if self._background_loop is not None and self._background_loop.is_running:
                     self._background_loop.run(
                         self._close_async_resources,
-                        error_message=(
-                            "Agent.close() cannot be called from a running event loop. "
-                            "Use 'await agent.close_async()' or 'async with agent:' instead."
-                        ),
+                        error_message=AGENT_CLOSE_SYNC_ERROR,
                     )
                 else:
                     running_loop = None
@@ -296,18 +304,12 @@ class Agent:
 
                     if running_loop is not None:
                         if self._mcp_client is not None:
-                            check_sync_allowed(
-                                "Agent.close() cannot be called from a running event loop. "
-                                "Use 'await agent.close_async()' or 'async with agent:' instead."
-                            )
+                            check_sync_allowed(AGENT_CLOSE_SYNC_ERROR)
                         running_loop.create_task(self._close_async_resources())
                     else:
                         run_async_in_sync(
                             self._close_async_resources,
-                            error_message=(
-                                "Agent.close() cannot be called from a running event loop. "
-                                "Use 'await agent.close_async()' or 'async with agent:' instead."
-                            ),
+                            error_message=AGENT_CLOSE_SYNC_ERROR,
                         )
                 self._close_sync_resources()
             finally:

{evidor-1.10.2.dev1 → evidor-1.10.3.dev1}/src/evidor/agent/core/context.py

@@ -50,6 +50,22 @@ class ConversationContext:
         if self.system_prompt:
             self._messages.append(Message(role="system", content=self.system_prompt))
 
+    def spawn_turn_context(self) -> ConversationContext:
+        """Create a fresh isolated turn context with the same configuration."""
+        return ConversationContext(
+            strategy=self.strategy,
+            system_prompt=self.system_prompt,
+            previous_response_id=None,
+            conversation_id=None,
+            store=self.store,
+            compact_threshold=self.compact_threshold,
+        )
+
+    def copy_from(self, other: ConversationContext) -> None:
+        """Update messages and last_response_id from another turn context."""
+        self._messages = list(other._messages)
+        self.last_response_id = other.last_response_id
+
     def append_user_message(self, message: str) -> Message:
         """Record a new user message in the conversation history."""
         msg = Message(role="user", content=message)

{evidor-1.10.2.dev1 → evidor-1.10.3.dev1}/src/evidor/agent/core/runner.py

@@ -38,12 +38,14 @@ class TurnExecutor:
         tool_executor: ToolExecutor,
         telemetry_bridge: AgentTelemetryBridge,
         max_tool_iterations: int = 10,
+        stateless: bool = False,
     ) -> None:
         self._provider = provider
         self._context = context
         self._tool_executor = tool_executor
         self._telemetry_bridge = telemetry_bridge
         self._max_tool_iterations = max_tool_iterations
+        self._stateless = stateless
 
     def update_tool_executor(self, executor: ToolExecutor) -> None:
         """Update the active ToolExecutor (e.g. after MCP tool synchronization)."""
@@ -78,8 +80,10 @@ class TurnExecutor:
         self,
         final_response: GenerationResponse,
         last_response: GenerationResponse | None,
+        context: ConversationContext | None = None,
     ) -> GenerationResponse:
         """Synthesize a fallback response if the model exhausts tool iterations without concluding."""
+        ctx = context or self._context
         final_text = (final_response.text or "").strip()
         if not final_text and last_response:
             final_text = (last_response.text or "").strip()
@@ -87,7 +91,7 @@ class TurnExecutor:
             final_text = (
                 f"Reached maximum tool iterations ({self._max_tool_iterations}) without a final response."
             )
-        self._context.append_assistant_response(text=final_text)
+        ctx.append_assistant_response(text=final_text)
         return GenerationResponse(
             id=final_response.id or (last_response.id if last_response else None),
             text=final_text,
@@ -96,20 +100,21 @@ class TurnExecutor:
 
     async def run_turn_async(self, message: str) -> GenerationResponse:
         """Asynchronously advance one complete user turn with automatic tool calling."""
+        turn_ctx = self._context.spawn_turn_context() if self._stateless else self._context
         run_id = f"run_{secrets.token_hex(6)}"
         with self._telemetry_bridge.run_scope(
-            run_id, message, self._context.system_prompt
+            run_id, message, turn_ctx.system_prompt
         ) as root_ctx:
             t0 = time.perf_counter()
             iterations = 0
             try:
-                user_msg = self._context.append_user_message(message)
+                user_msg = turn_ctx.append_user_message(message)
                 current_turn_messages: Sequence[Message] = [user_msg]
                 response: GenerationResponse | None = None
 
                 for _ in range(self._max_tool_iterations):
                     iterations += 1
-                    req = self._context.build_generation_request(
+                    req = turn_ctx.build_generation_request(
                         current_turn_messages, self._tool_executor.tools
                     )
 
@@ -117,9 +122,9 @@ class TurnExecutor:
                         self._provider, req
                     )
                     if response.id:
-                        self._context.last_response_id = response.id
+                        turn_ctx.last_response_id = response.id
 
-                    self._context.append_assistant_response(
+                    turn_ctx.append_assistant_response(
                         text=response.text,
                         tool_calls=response.tool_calls,
                         thinking=response.thinking,
@@ -128,6 +133,8 @@ class TurnExecutor:
                     )
 
                     if not response.tool_calls:
+                        if self._stateless:
+                            self._context.copy_from(turn_ctx)
                         duration_ms = (time.perf_counter() - t0) * 1000
                         self._telemetry_bridge.emit_run_end(
                             root_ctx=root_ctx,
@@ -141,19 +148,21 @@ class TurnExecutor:
 
                     # Execute tool calls and record results
                     tool_results = await self.execute_tool_calls_async(response.tool_calls)
-                    self._context.append_tool_results(tool_results)
+                    turn_ctx.append_tool_results(tool_results)
                     current_turn_messages = tool_results
 
                 # Iterations exhausted: perform terminal synthesis without tools
                 iterations += 1
-                final_req = self._context.build_final_request(current_turn_messages)
+                final_req = turn_ctx.build_final_request(current_turn_messages)
                 final_response = await self._telemetry_bridge.generate_with_telemetry_async(
                     self._provider, final_req
                 )
                 if final_response.id:
-                    self._context.last_response_id = final_response.id
+                    turn_ctx.last_response_id = final_response.id
 
-                result = self.finalize_loop_expiry(final_response, response)
+                result = self.finalize_loop_expiry(final_response, response, turn_ctx)
+                if self._stateless:
+                    self._context.copy_from(turn_ctx)
                 duration_ms = (time.perf_counter() - t0) * 1000
                 self._telemetry_bridge.emit_run_end(
                     root_ctx=root_ctx,
@@ -179,20 +188,21 @@ class TurnExecutor:
 
     async def stream_turn_async(self, message: str) -> AsyncIterator[StreamChunk]:
         """Asynchronously stream chunks across multi-turn tool execution."""
+        turn_ctx = self._context.spawn_turn_context() if self._stateless else self._context
         run_id = f"run_{secrets.token_hex(6)}"
         with self._telemetry_bridge.run_scope(
-            run_id, message, self._context.system_prompt
+            run_id, message, turn_ctx.system_prompt
         ) as root_ctx:
             t0 = time.perf_counter()
             iterations = 0
             try:
-                user_msg = self._context.append_user_message(message)
+                user_msg = turn_ctx.append_user_message(message)
                 current_turn_messages: Sequence[Message] = [user_msg]
                 response: GenerationResponse | None = None
 
                 for _ in range(self._max_tool_iterations):
                     iterations += 1
-                    req = self._context.build_generation_request(
+                    req = turn_ctx.build_generation_request(
                         current_turn_messages, self._tool_executor.tools, stream=True
                     )
 
@@ -207,9 +217,9 @@ class TurnExecutor:
                         response = await turn_stream.get_final_response()
 
                     if response.id:
-                        self._context.last_response_id = response.id
+                        turn_ctx.last_response_id = response.id
 
-                    self._context.append_assistant_response(
+                    turn_ctx.append_assistant_response(
                         text=response.text,
                         tool_calls=response.tool_calls,
                         thinking=response.thinking,
@@ -218,6 +228,8 @@ class TurnExecutor:
                     )
 
                     if not response.tool_calls:
+                        if self._stateless:
+                            self._context.copy_from(turn_ctx)
                         duration_ms = (time.perf_counter() - t0) * 1000
                         self._telemetry_bridge.emit_run_end(
                             root_ctx=root_ctx,
@@ -231,12 +243,12 @@ class TurnExecutor:
 
                     # Execute tool calls asynchronously
                     tool_results = await self.execute_tool_calls_async(response.tool_calls)
-                    self._context.append_tool_results(tool_results)
+                    turn_ctx.append_tool_results(tool_results)
                     current_turn_messages = tool_results
 
                 # Iterations exhausted: stream final synthesis without tools
                 iterations += 1
-                final_req = self._context.build_final_request(current_turn_messages, stream=True)
+                final_req = turn_ctx.build_final_request(current_turn_messages, stream=True)
                 final_stream = await self._telemetry_bridge.generate_with_telemetry_stream_async(
                     self._provider, final_req
                 )
@@ -247,9 +259,11 @@ class TurnExecutor:
                 if final_response is None:
                     final_response = await final_stream.get_final_response()
                 if final_response.id:
-                    self._context.last_response_id = final_response.id
+                    turn_ctx.last_response_id = final_response.id
 
-                result = self.finalize_loop_expiry(final_response, response)
+                result = self.finalize_loop_expiry(final_response, response, turn_ctx)
+                if self._stateless:
+                    self._context.copy_from(turn_ctx)
                 duration_ms = (time.perf_counter() - t0) * 1000
                 self._telemetry_bridge.emit_run_end(
                     root_ctx=root_ctx,

evidor-1.10.3.dev1/src/evidor/agent/providers/anthropic/__init__.py

@@ -0,0 +1,14 @@
+"""Anthropic provider package."""
+
+from .builder import AnthropicPayloadBuilder
+from .parser import AnthropicResponseParser
+from .provider import AnthropicProvider
+from .stream import AnthropicStreamHandler
+
+__all__ = [
+    "AnthropicPayloadBuilder",
+    "AnthropicProvider",
+    "AnthropicResponseParser",
+    "AnthropicStreamHandler",
+]
+