agentbyte 0.27.0__tar.gz → 0.28.0__tar.gz

{agentbyte-0.27.0 → agentbyte-0.28.0}/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to Agentbyte are documented in this file.
 
 The format follows Keep a Changelog principles and semantic versioning.
 
+## [0.28.0] - 2026-09-15
+
+### Changed
+
+- **Breaking:** A failed agent run no longer injects the raw `Error: ...` text as an assistant message into the run context. The error is surfaced on the new `AgentResponse.error` (`AgentErrorDetail`) field and via `final_content`; the conversation history stays clean so the error is not replayed to the model on later turns of the session. Consumers that read the error from `response.context.messages` must switch to `response.error`.
+
+### Added
+
+- `RetryPolicy.max_retries_on_opt_in` (default `None`): a separate, lower retry cap for errors matched via `retryable_error_substrings`, so a usually-terminal marker (e.g. `invalid_prompt`) can fail fast while transient errors keep the full `max_retries`.
+- Retry marker matching now also inspects structured provider fields (`code`, `body.error.code`) on the error and its cause, not just `str(error)`, so a provider rewording its message text cannot silently disable a marker.
+- Retry exhaustion now emits a structured `logger.warning` summary and attaches the attempt history to the raised exception as `agentbyte_retry_history`.
+
+## [0.27.1] - 2026-09-13
+
+### Changed
+
+- **Breaking:** Renamed `DuplicateToolResultMiddleware` (introduced in 0.27.0) to `DeduplicatingToolResultMiddleware`, an action-oriented name consistent with `DeduplicatingSkillsSource`. The old name is removed with no alias — update imports from `agentbyte.middleware`.
+
 ## [0.27.0] - 2026-09-12
 
 ### Added

{agentbyte-0.27.0 → agentbyte-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentbyte
-Version: 0.27.0
+Version: 0.28.0
 Summary: A toolkit for designing multiagent systems
 Author-email: MrDataPsycho <mr.data.psycho@gmail.com>
 License-Expression: LicenseRef-Proprietary
@@ -86,7 +86,7 @@ Description-Content-Type: text/markdown
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.27.0**
+Current release: **0.28.0**
 
 ## Building an Agent
 

{agentbyte-0.27.0 → agentbyte-0.28.0}/README.md

@@ -2,7 +2,7 @@
 
 Agentbyte is an observability-first agentic AI framework for building and studying multiagent systems with a learning-first, implementation-oriented workflow.
 
-Current release: **0.27.0**
+Current release: **0.28.0**
 
 ## Building an Agent
 

agentbyte-0.28.0/src/agentbyte/__about__.py

@@ -0,0 +1,2 @@
+__version__ = "0.28.0"
+VERSION = __version__

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/agents/__init__.py

@@ -13,6 +13,7 @@ from .base import (
 )
 from .embedding_agent import EmbeddingAgent
 from .types import (
+    AgentErrorDetail,
     AgentEvent,
     AgentResponse,
     BaseEvent,
@@ -58,4 +59,5 @@ __all__ = [
     "FatalErrorEvent",
     "EmbeddingBatchProgressEvent",
     "AgentResponse",
+    "AgentErrorDetail",
 ]

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/agents/agent.py

@@ -28,6 +28,7 @@ from agentbyte.tools import ApprovalMode, BaseTool
 
 from .base import AgentConfigurationError, AgentExecutionError, BaseAgent
 from .types import (
+    AgentErrorDetail,
     AgentEvent,
     AgentResponse,
     BaseEvent,
@@ -403,6 +404,7 @@ class Agent(BaseAgent):
         memory_operations = 0
         cost_estimate = 0.0
         finish_reason = "stop"
+        run_error: Optional[AgentErrorDetail] = None
 
         effective_stream_tokens = stream_tokens
         if stream_tokens and self.middleware_chain.middlewares:
@@ -694,12 +696,13 @@ class Agent(BaseAgent):
                 )
         except Exception as exc:
             finish_reason = "error"
-            error_message = AssistantMessage(
-                content=f"Error: {exc}",
-                source=self.name,
-            )
-            working_context.add_message(error_message)
-            yield error_message
+            run_error = AgentErrorDetail(message=str(exc), error_type=type(exc).__name__)
+            # Deliberately NOT added to working_context.messages: a raw provider
+            # error persisted as an assistant turn is replayed to the model as
+            # real history on every later turn of the session. It is surfaced via
+            # AgentResponse.error (and the ErrorEvent below) instead, leaving the
+            # conversation history clean.
+            yield AssistantMessage(content=f"Error: {exc}", source=self.name)
             if verbose:
                 yield ErrorEvent(
                     source=self.name,
@@ -725,6 +728,7 @@ class Agent(BaseAgent):
             source=self.name,
             finish_reason=finish_reason,
             usage=usage,
+            error=run_error,
         )
 
         if verbose:

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/agents/types.py

@@ -174,6 +174,24 @@ class EmbeddingBatchProgressEvent(BaseEvent):
     total_texts: int = Field(..., description="Total number of texts in this run")
 
 
+class AgentErrorDetail(BaseModel):
+    """Structured detail for a run that ended with ``finish_reason="error"``.
+
+    A data record, not an exception — distinct from the ``AgentError`` exception
+    hierarchy in ``agentbyte.agents.base``. Carried on :class:`AgentResponse`
+    instead of being written into the conversation as an assistant turn: a raw
+    provider error string persisted as an assistant message would be replayed to
+    the model as genuine history on every subsequent turn of the session.
+    Surfacing it here keeps the message list clean while still letting callers
+    render or classify the failure.
+    """
+
+    model_config = ConfigDict(frozen=True)
+
+    message: str = Field(..., description="Developer-facing error text (the raw exception string)")
+    error_type: str = Field(..., description="Exception class name, e.g. 'InvalidRequestError'")
+
+
 class AgentResponse(BaseModel):
     """Final response payload for a completed agent run."""
 
@@ -186,6 +204,10 @@ class AgentResponse(BaseModel):
         description="Why the agent stopped: stop, approval_needed, max_iterations, max_iterations_finalized, tool_executed, error, cancelled",
     )
     usage: Usage = Field(default_factory=Usage, description="Aggregated usage")
+    error: Optional[AgentErrorDetail] = Field(
+        default=None,
+        description="Set when finish_reason='error'; the failure detail, kept out of the message history",
+    )
     timestamp: datetime = Field(
         default_factory=datetime.now,
         description="When the response was created",
@@ -208,7 +230,14 @@ class AgentResponse(BaseModel):
 
     @property
     def final_content(self) -> str:
-        """Final message content if available."""
+        """Final message content if available.
+
+        When the run failed, the error text is not in ``context.messages`` (it is
+        deliberately kept out of the replayed history), so it is surfaced from
+        ``error`` here for display and logging.
+        """
+        if self.error is not None:
+            return f"Error: {self.error.message}"
         if not self.context.messages:
             return ""
         return self.context.messages[-1].content
@@ -315,4 +344,5 @@ __all__ = [
     "FatalErrorEvent",
     "EmbeddingBatchProgressEvent",
     "AgentResponse",
+    "AgentErrorDetail",
 ]

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/llm/azure/chat.py

@@ -389,6 +389,12 @@ class AzureOpenAIChatCompletionClient(
                 }
             return result
         except Exception as e:
+            if retry_history:
+                logger.warning(
+                    "LLM call failed after retries for model=%s: %s",
+                    self.model,
+                    build_retry_summary(retry_history),
+                )
             self._handle_error(e)
 
     async def _create_internal(

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/llm/openai/chat.py

@@ -156,6 +156,12 @@ class OpenAIChatCompletionClient(
                 }
             return result
         except Exception as e:
+            if retry_history:
+                logger.warning(
+                    "LLM call failed after retries for model=%s: %s",
+                    self.model,
+                    build_retry_summary(retry_history),
+                )
             self._handle_error(e)
 
     async def _create_internal(

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/llm/retry_policy.py

@@ -29,6 +29,16 @@ class RetryPolicy(BaseModel):
     generic word, or unrelated failures will only be slowed before they surface.
     """
 
+    max_retries_on_opt_in: Optional[int] = None
+    """Retry cap applied only to errors matched via ``retryable_error_substrings``.
+
+    ``None`` (default) means opted-in errors use ``max_retries`` like everything
+    else — unchanged behaviour. Set a lower value to fail fast on markers that are
+    usually terminal (for example, retry ``invalid_prompt`` at most once) while
+    still giving genuinely transient errors (rate limits) the full ``max_retries``.
+    The effective cap is ``min(max_retries, max_retries_on_opt_in)``.
+    """
+
     @field_validator("max_retries")
     @classmethod
     def _non_negative_retries(cls, v: int) -> int:
@@ -36,6 +46,13 @@ class RetryPolicy(BaseModel):
             raise ValueError("max_retries must be >= 0")
         return v
 
+    @field_validator("max_retries_on_opt_in")
+    @classmethod
+    def _non_negative_opt_in_retries(cls, v: Optional[int]) -> Optional[int]:
+        if v is not None and v < 0:
+            raise ValueError("max_retries_on_opt_in must be >= 0")
+        return v
+
     @field_validator("initial_retry_delay", "max_retry_delay")
     @classmethod
     def _no_negative_delays(cls, v: float) -> float:
@@ -59,18 +76,52 @@ class RetryMixin:
 
     retry_policy: RetryPolicy
 
+    def _error_marker_haystack(self, error: BaseException) -> str:
+        """Lowercased text to match markers against: the rendered string plus
+        structured provider fields (``code``, ``body['error']['code']``) from the
+        error and its ``__cause__``. Superset of ``str(error)``, so this never
+        matches *less* than before."""
+        parts: list[str] = [str(error)]
+        seen: set[int] = set()
+        for obj in (error, getattr(error, "__cause__", None)):
+            if obj is None or id(obj) in seen:
+                continue
+            seen.add(id(obj))
+            code = getattr(obj, "code", None)
+            if code:
+                parts.append(str(code))
+            body = getattr(obj, "body", None)
+            if isinstance(body, dict):
+                inner = body.get("error")
+                if isinstance(inner, dict) and inner.get("code"):
+                    parts.append(str(inner["code"]))
+        return " ".join(parts).lower()
+
     def _error_opted_into_retry(self, error: Exception) -> bool:
-        """Return True if the caller marked this error's text as retryable.
+        """Return True if the caller marked this error as retryable.
 
-        Matches ``str(error)`` case-insensitively against
-        ``retry_policy.retryable_error_substrings``. This only ever widens what is
-        retried; it never suppresses an error.
+        Matches ``retry_policy.retryable_error_substrings`` (case-insensitive)
+        against the rendered error string AND structured provider fields
+        (``code``, ``body.error.code``) of the error and its cause. This only ever
+        widens what is retried; it never suppresses an error.
         """
         markers = getattr(self.retry_policy, "retryable_error_substrings", None) or []
         if not markers:
             return False
-        text = str(error).lower()
-        return any(marker.lower() in text for marker in markers)
+        haystack = self._error_marker_haystack(error)
+        return any(marker.lower() in haystack for marker in markers)
+
+    def _effective_max_retries(self, error: Optional[Exception]) -> int:
+        """Retry cap for the current failure.
+
+        Opted-in (marker-matched) errors honour ``max_retries_on_opt_in`` when it
+        is set; everything else uses ``max_retries``. Never raises.
+        """
+        cap = self.retry_policy.max_retries
+        opt_cap = getattr(self.retry_policy, "max_retries_on_opt_in", None)
+        if opt_cap is not None and error is not None and self._error_opted_into_retry(error):
+            return min(cap, opt_cap)
+        return cap
 
     async def _retry_with_backoff(
         self,
@@ -82,7 +133,7 @@ class RetryMixin:
         """Execute *func* with exponential back-off on transient errors."""
         from .base import AuthenticationError, InvalidRequestError, RateLimitError
         from .types import ModelClientError
-        from ._retry_observability import build_retry_record
+        from ._retry_observability import build_retry_record, build_retry_summary
 
         last_exception: Optional[Exception] = None
         current_delay = self.retry_policy.initial_retry_delay
@@ -113,10 +164,30 @@ class RetryMixin:
                     raise
 
             # Reached only for a retryable error.
-            if attempt >= self.retry_policy.max_retries:
+            effective_max = self._effective_max_retries(last_exception)
+            if attempt >= effective_max:
+                if _retry_history is not None:
+                    _retry_history.append(
+                        build_retry_record(
+                            attempt + 1, current_delay, type(last_exception), "exhausted"
+                        )
+                    )
+                    summary = build_retry_summary(_retry_history)
+                else:
+                    summary = {}
                 logger.warning(
-                    f"Max retries ({self.retry_policy.max_retries}) reached for {func.__name__}"
+                    "Retries exhausted for %s after %d attempt(s): %s",
+                    func.__name__,
+                    attempt + 1,
+                    summary,
                 )
+                # Attach the history so a caller that catches the exception (or a
+                # provider adapter that re-wraps it) can still report what was
+                # tried. Best-effort: never let observability raise.
+                try:
+                    setattr(last_exception, "agentbyte_retry_history", list(_retry_history or []))
+                except Exception:  # noqa: BLE001 - attribute may be read-only on some exc types
+                    pass
                 raise last_exception
             if _retry_history is not None:
                 _retry_history.append(
@@ -160,7 +231,7 @@ class RetryMixin:
                 # already reached the caller (the response is half-said).
                 if (
                     saw_chunk
-                    or attempt >= self.retry_policy.max_retries
+                    or attempt >= self._effective_max_retries(e)
                     or not self._error_opted_into_retry(e)
                 ):
                     raise
@@ -184,7 +255,7 @@ class RetryMixin:
             except Exception as e:
                 if (
                     saw_chunk
-                    or attempt >= self.retry_policy.max_retries
+                    or attempt >= self._effective_max_retries(e)
                     or not self._error_opted_into_retry(e)
                 ):
                     raise

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/middleware/__init__.py

@@ -6,7 +6,7 @@ from .base import (
     ApprovalMiddleware,
     BaseMiddleware,
     ContextCompactionMiddleware,
-    DuplicateToolResultMiddleware,
+    DeduplicatingToolResultMiddleware,
     GuardrailMiddleware,
     LoggingMiddleware,
     MetricsMiddleware,
@@ -41,7 +41,7 @@ __all__ = [
     "MiddlewareChain",
     "ApprovalMiddleware",
     "ContextCompactionMiddleware",
-    "DuplicateToolResultMiddleware",
+    "DeduplicatingToolResultMiddleware",
     "LoggingMiddleware",
     "PIIRedactionMiddleware",
     "GuardrailMiddleware",

{agentbyte-0.27.0 → agentbyte-0.28.0}/src/agentbyte/middleware/base.py

@@ -1054,7 +1054,7 @@ class ContextCompactionMiddleware(BaseMiddleware):
         return None
 
 
-class DuplicateToolResultMiddleware(BaseMiddleware):
+class DeduplicatingToolResultMiddleware(BaseMiddleware):
     """Collapse repeated identical tool results in the model-call payload.
 
     A tool result stays in the conversation for the life of a session and is

agentbyte-0.28.0/tests/agents/test_agent_error_response.py

@@ -0,0 +1,99 @@
+"""A failed agent run surfaces the error on AgentResponse.error, not in history.
+
+Spec 0013 §3: the raw provider error must no longer be persisted into
+``context.messages`` as a synthetic assistant turn (which would be replayed to
+the model on every later turn of the session). It is carried on
+``AgentResponse.error`` (an ``AgentErrorDetail``) and reflected by
+``final_content`` instead.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import pytest
+
+from agentbyte.agents import Agent, AgentErrorDetail
+from agentbyte.llm.base import (
+    BaseChatCompletionClient,
+    BaseChatCompletionClientConfig,
+    InvalidRequestError,
+)
+from agentbyte.llm.types import ChatCompletionResult
+from agentbyte.messages import Message
+
+
+class _RaisingClientConfig(BaseChatCompletionClientConfig):
+    pass
+
+
+class _RaisingModelClient(BaseChatCompletionClient):
+    """Model client whose ``create()`` always fails with a marked error."""
+
+    def __init__(self, error: Exception) -> None:
+        super().__init__(model="fake", client=object())
+        self._error = error
+
+    async def create(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        output_format: Optional[type] = None,
+        **kwargs: Any,
+    ) -> ChatCompletionResult:
+        raise self._error
+
+    async def create_stream(self, *args: Any, **kwargs: Any):  # pragma: no cover - unused
+        raise self._error
+        yield  # pragma: no cover - generator marker
+
+    def _to_config(self) -> BaseChatCompletionClientConfig:
+        return _RaisingClientConfig(model=self.model, config=self.config)
+
+    @classmethod
+    def _from_config(cls, config: BaseChatCompletionClientConfig) -> "_RaisingModelClient":
+        return cls(error=RuntimeError("boom"))
+
+
+def _agent() -> Agent:
+    client = _RaisingModelClient(
+        InvalidRequestError("Azure request invalid: invalid_prompt flagged")
+    )
+    return Agent(
+        name="assistant",
+        description="desc",
+        instructions="help",
+        model_client=client,
+    )
+
+
+@pytest.mark.asyncio
+async def test_error_surfaced_on_response_not_in_history() -> None:
+    agent = _agent()
+
+    resp = await agent.run("hi")
+
+    assert resp.finish_reason == "error"
+    assert resp.error is not None
+    assert isinstance(resp.error, AgentErrorDetail)
+    assert resp.error.error_type == "InvalidRequestError"
+    assert "invalid_prompt" in resp.error.message
+    assert resp.final_content == f"Error: {resp.error.message}"
+
+    # The fix: the raw error is NOT in replayed history.
+    assert all("invalid_prompt" not in (m.content or "") for m in resp.context.messages)
+
+
+@pytest.mark.asyncio
+async def test_second_run_on_same_context_does_not_resurrect_error() -> None:
+    agent = _agent()
+
+    resp = await agent.run("hi")
+    resp2 = await agent.run("again", context=resp.context)
+
+    assert resp2.finish_reason == "error"
+    # No earlier turn carries the error text back into the prompt.
+    assert all(
+        "invalid_prompt" not in (m.content or "")
+        for m in resp2.context.messages[:-1]
+    )

{agentbyte-0.27.0 → agentbyte-0.28.0}/tests/llm/test_retry_observability.py

@@ -19,9 +19,10 @@ import pytest
 
 from agentbyte.llm.azure.chat import AzureOpenAIChatCompletionClient
 from agentbyte.llm.azure.embedding import AzureOpenAIEmbeddingClient
-from agentbyte.llm.base import RateLimitError
+from agentbyte.llm.base import InvalidRequestError, RateLimitError
 from agentbyte.llm.openai.chat import OpenAIChatCompletionClient
 from agentbyte.llm.openai.embedding import OpenAIEmbeddingClient
+from agentbyte.llm.retry_policy import RetryMixin, RetryPolicy
 from agentbyte.messages import UserMessage
 
 
@@ -72,6 +73,38 @@ def _fake_openai_client(chat_response=None, embedding_response=None) -> Any:
 # Helper: build a client that raises RateLimitError N times then succeeds
 # ---------------------------------------------------------------------------
 
+class _Harness(RetryMixin):
+    """Minimal RetryMixin host with a configurable retry policy."""
+
+    def __init__(self, policy: RetryPolicy) -> None:
+        self.retry_policy = policy
+
+
+@pytest.mark.asyncio
+async def test_exhaustion_records_history_and_attaches_to_exception():
+    """When opted-in retries are exhausted, the last record is 'exhausted' and the
+    history is attached to the raised exception as ``agentbyte_retry_history``."""
+    policy = RetryPolicy(
+        max_retries=2,
+        initial_retry_delay=0.0,
+        max_retry_delay=0.0,
+        retryable_error_substrings=["invalid_prompt"],
+    )
+    harness = _Harness(policy)
+    history: list = []
+
+    async def always_fail() -> str:
+        raise InvalidRequestError("invalid_prompt")
+
+    with pytest.raises(InvalidRequestError) as exc_info:
+        await harness._retry_with_backoff(always_fail, _retry_history=history)
+
+    assert history[-1]["outcome"] == "exhausted"
+    attached = getattr(exc_info.value, "agentbyte_retry_history", None)
+    assert attached is not None
+    assert attached[-1]["outcome"] == "exhausted"
+
+
 def _flaky_create(success_response: Any, fail_times: int):
     """Return an AsyncMock that raises RateLimitError fail_times then returns success."""
     call_count = 0

{agentbyte-0.27.0 → agentbyte-0.28.0}/tests/llm/test_retryable_error_substrings.py

@@ -166,6 +166,105 @@ async def test_rate_limit_still_transient_without_opt_in() -> None:
     assert calls["n"] == 2
 
 
+@pytest.mark.asyncio
+async def test_opt_in_cap_lowers_retries_for_matched_error() -> None:
+    policy = _fast_policy(
+        max_retries=3,
+        max_retries_on_opt_in=1,
+        retryable_error_substrings=["invalid_prompt"],
+    )
+    harness = _Harness(policy)
+    calls = {"n": 0}
+
+    async def always_fail() -> str:
+        calls["n"] += 1
+        raise InvalidRequestError("invalid_prompt")
+
+    with pytest.raises(InvalidRequestError):
+        await harness._retry_with_backoff(always_fail)
+    # 1 initial + 1 opt-in retry.
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_transient_error_keeps_full_cap_under_opt_in_cap() -> None:
+    policy = _fast_policy(
+        max_retries=3,
+        max_retries_on_opt_in=1,
+        retryable_error_substrings=["invalid_prompt"],
+    )
+    harness = _Harness(policy)
+    calls = {"n": 0}
+
+    async def always_fail() -> str:
+        calls["n"] += 1
+        raise RateLimitError("slow down")
+
+    with pytest.raises(RateLimitError):
+        await harness._retry_with_backoff(always_fail)
+    # Rate limit is not opted-in, so the opt-in cap must not shrink it: 1 + 3.
+    assert calls["n"] == 4
+
+
+@pytest.mark.asyncio
+async def test_structured_code_matches_without_marker_in_message() -> None:
+    policy = _fast_policy(max_retries=2, retryable_error_substrings=["invalid_prompt"])
+    harness = _Harness(policy)
+    calls = {"n": 0}
+
+    class CodedError(Exception):
+        def __init__(self, message: str, code: str) -> None:
+            super().__init__(message)
+            self.code = code
+
+    async def flaky() -> str:
+        calls["n"] += 1
+        if calls["n"] < 2:
+            raise CodedError("Error code: 400", code="invalid_prompt")
+        return "ok"
+
+    assert await harness._retry_with_backoff(flaky) == "ok"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_structured_body_error_code_matches() -> None:
+    policy = _fast_policy(max_retries=2, retryable_error_substrings=["invalid_prompt"])
+    harness = _Harness(policy)
+    calls = {"n": 0}
+
+    class BodyError(Exception):
+        def __init__(self, message: str, body: dict) -> None:
+            super().__init__(message)
+            self.body = body
+
+    async def flaky() -> str:
+        calls["n"] += 1
+        if calls["n"] < 2:
+            raise BodyError("Error code: 400", body={"error": {"code": "invalid_prompt"}})
+        return "ok"
+
+    assert await harness._retry_with_backoff(flaky) == "ok"
+    assert calls["n"] == 2
+
+
+@pytest.mark.asyncio
+async def test_default_opt_in_cap_none_is_unchanged() -> None:
+    policy = _fast_policy(max_retries=2, retryable_error_substrings=["invalid_prompt"])
+    harness = _Harness(policy)
+    assert policy.max_retries_on_opt_in is None
+    calls = {"n": 0}
+
+    async def always_fail() -> str:
+        calls["n"] += 1
+        raise InvalidRequestError("invalid_prompt")
+
+    with pytest.raises(InvalidRequestError):
+        await harness._retry_with_backoff(always_fail)
+    # Unchanged: 1 initial + max_retries.
+    assert calls["n"] == 3
+
+
 @pytest.mark.asyncio
 async def test_stream_retries_opted_in_error_before_any_chunk() -> None:
     policy = _fast_policy(max_retries=3, retryable_error_substrings=["invalid_prompt"])