vtx-coding-agent 0.1.4__tar.gz → 0.1.5__tar.gz

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/CHANGELOG.md

@@ -8,6 +8,63 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - No changes yet.
 
+## [0.1.5] - 2026-06-18 — Rate Limit Manager, Safe Max-Output & Gateway Fixes
+
+Internal rate-limit manager with exponential backoff, safe max-output token limits by context window tier, Kilo transient error retries, and built-in skill filesystem syncing.
+
+### Added
+
+#### Internal rate-limit manager with automatic retries
+- Added `RateLimitManager` (`src/vtx/llm/rate_limit.py`) that intercepts
+  429 / rate-limit errors at the provider stream layer and retries with
+  exponential backoff + jitter, transparently to the caller.
+- `BaseProvider.stream()` now delegates to `rate_limit_manager.retry_stream()`,
+  which re-calls `_stream_impl` on rate-limit errors up to 5 times by default.
+- Respects `Retry-After` headers from the server when present.
+
+#### Safe max-output token limits by context window tier
+- Replaced the ad-hoc safety cap in `dynamic_models.py` with a centralized
+  `safe_max_output_tokens()` function that tiers max output tokens by context
+  window size: 128k → 8k, 256k → 16k, >256k → 32k, 1M → 64k.
+- Auto-compaction now triggers at `context_window - max_output_tokens` instead
+  of a fixed percentage, ensuring the model always has enough room for its
+  max output regardless of window size.
+
+#### Built-in skills synced to `~/.vtx/skills/` for reliable filesystem access
+- Built-in skills are now auto-copied from the package to `~/.vtx/skills/` on
+  every `Context.load()` and `Context.reload()`, so they live on the real
+  filesystem and are readable by any tool.
+- `load_skills()` now scans `~/.vtx/skills/` as a third discovery location
+  (after project and user-global dirs), marking synced skills as `bundled=True`.
+- `find_skill_dir()` in the skill tool searches `~/.vtx/skills/` between the
+  user-global and package built-in locations, ensuring the model's `view`
+  action resolves to the synced copy on disk.
+
+### Changed
+
+- Removed `RateLimitError` from `should_retry_for_error()` in OpenAI and
+  Anthropic providers since rate limits are now handled internally by the
+  rate limit manager.
+- `is_overflow()` in `compaction.py` now accepts `max_output_tokens` instead
+  of `threshold_percent`.
+
+### Fixed
+
+#### Kilo "Provider returned error" now retried automatically
+- The OpenAI SDK raises `APIError("Provider returned error")` when an upstream
+  gateway like Kilo fails transiently. This was previously uncaught by any retry
+  path and surfaced directly to the user. Now retried at three layers:
+  SDK-level `_is_transient_error`, provider-level `should_retry_for_error`,
+  and the rate limit manager's `is_rate_limit_error`.
+- Also catches "overloaded" and "capacity" transient errors from gateways.
+
+#### Skill tool `file_path="None"` string normalization
+- Added a Pydantic `model_validator` to `SkillParams` that converts the literal
+  string `"None"` to Python `None` for nullable fields (`name`, `content`,
+  `old_string`, `new_string`, `file_path`). Previously the LLM could pass
+  `"file_path": "None"` which evaluated as truthy, causing the tool to construct
+  paths like `.../review/None` instead of falling back to `"SKILL.md"`.
+
 ## [0.1.4] - 2026-06-18 — Handoff Agents, Background Tasks & Subagents
 
 Switchable handoff agents, a built-in `Task` tool for Claude Code-style subagents, background concurrent task execution, a `grep` tool, custom TUI blocks for extension tools, and a context-length safety cap for gateway providers.

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vtx-coding-agent
-Version: 0.1.4
+Version: 0.1.5
 Summary: Minimalist coding agent harness with a Textual TUI and headless CLI. <1k-token system prompt, 18+ LLM providers, AGENTS.md + skills context, session tree, prompt/auto permissions.
 License-File: LICENSE
 Requires-Python: >=3.12

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/pyproject.toml

@@ -14,7 +14,7 @@ default = true
 
 [project]
 name = "vtx-coding-agent"
-version = "0.1.4"
+version = "0.1.5"
 description = "Minimalist coding agent harness with a Textual TUI and headless CLI. <1k-token system prompt, 18+ LLM providers, AGENTS.md + skills context, session tree, prompt/auto permissions."
 readme = "README.md"
 requires-python = ">=3.12"

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/context/loader.py

@@ -10,7 +10,13 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 
 from .agent_mds import ContextFile, load_agent_mds
-from .skills import Skill, load_builtin_cmd_skills, load_skills, merge_registered_skills
+from .skills import (
+    Skill,
+    load_builtin_cmd_skills,
+    load_skills,
+    merge_registered_skills,
+    sync_builtin_skills,
+)
 
 
 @dataclass
@@ -22,6 +28,7 @@ class Context:
 
     @classmethod
     def load(cls, cwd: str) -> Context:
+        sync_builtin_skills()
         agents_files = load_agent_mds(cwd)
         skills_result = load_skills(cwd)
         builtin_result = load_builtin_cmd_skills()
@@ -33,6 +40,7 @@ class Context:
         return cls(cwd=cwd, agents_files=agents_files, skills=skills, skill_warnings=warnings)
 
     def reload(self) -> None:
+        sync_builtin_skills()
         agents_files = load_agent_mds(self.cwd)
         skills_result = load_skills(self.cwd)
         builtin_result = load_builtin_cmd_skills()

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/context/skills.py

@@ -11,12 +11,14 @@ Discovery locations:
 
 import os
 import re
+import shutil
 from dataclasses import dataclass
 from importlib import resources
 from pathlib import Path
 from typing import Any
 
-from .. import get_agents_dir as get_config_dir
+from .. import get_agents_dir as get_user_skills_dir
+from ..config import get_config_dir as get_vtx_config_dir
 from ._xml import escape_xml
 
 MAX_NAME_LENGTH = 64
@@ -289,13 +291,39 @@ def _project_skill_dirs(cwd: Path) -> list[Path]:
     return dirs
 
 
+def sync_builtin_skills() -> None:
+    """Copy built-in skills from the package to ~/.vtx/skills/ for filesystem access."""
+    dst_root = (get_vtx_config_dir() / "skills").resolve(strict=False)
+    try:
+        builtin_resource = resources.files("vtx").joinpath("builtin_skills")
+        with resources.as_file(builtin_resource) as src_root:
+            if not src_root.is_dir():
+                return
+            dst_root.mkdir(parents=True, exist_ok=True)
+            for entry in src_root.iterdir():
+                if not entry.is_dir():
+                    continue
+                for skill_dir in entry.iterdir():
+                    if not skill_dir.is_dir() or skill_dir.name.startswith("."):
+                        continue
+                    if not (skill_dir / "SKILL.md").is_file():
+                        continue
+                    dst = dst_root / skill_dir.name
+                    if dst.exists():
+                        shutil.rmtree(dst)
+                    shutil.copytree(skill_dir, dst)
+    except Exception:
+        pass
+
+
 def load_skills(cwd: str | None = None) -> LoadSkillsResult:
     """
-    Load skills from ~/.agents and project .agents locations.
+    Load skills from ~/.vtx, ~/.agents and project .agents locations.
 
     Discovery:
     1. <cwd-or-ancestor>/.agents/skills/ - each subdirectory with SKILL.md is a skill
     2. ~/.agents/skills/ - each subdirectory with SKILL.md is a skill
+    3. ~/.vtx/skills/ - synced built-in skills (lowest priority)
 
     Local skills take precedence over global skills with the same name.
     """
@@ -323,10 +351,17 @@ def load_skills(cwd: str | None = None) -> LoadSkillsResult:
     for skills_dir in project_skills_dirs:
         add_skills(_load_skills_from_dir(skills_dir))
 
-    user_skills_dir = (get_config_dir() / "skills").resolve(strict=False)
+    user_skills_dir = (get_user_skills_dir() / "skills").resolve(strict=False)
     if user_skills_dir not in project_skills_dirs:
         add_skills(_load_skills_from_dir(user_skills_dir))
 
+    vtx_skills_dir = (get_vtx_config_dir() / "skills").resolve(strict=False)
+    if vtx_skills_dir not in project_skills_dirs and vtx_skills_dir != user_skills_dir:
+        result = _load_skills_from_dir(vtx_skills_dir)
+        for skill in result.skills:
+            skill.bundled = True
+        add_skills(result)
+
     return LoadSkillsResult(skills=list(skill_map.values()), warnings=all_warnings)
 
 

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/llm/base.py

@@ -194,7 +194,10 @@ class BaseProvider(ABC):
         temperature: float | None = None,
         max_tokens: int | None = None,
     ) -> LLMStream:
-        return await self._stream_impl(
+        from .rate_limit import rate_limit_manager
+
+        return await rate_limit_manager.retry_stream(
+            self,
             messages,
             system_prompt=system_prompt,
             tools=tools,

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/llm/providers/anthropic_sdk.py

@@ -3,7 +3,7 @@
 from collections.abc import AsyncIterator
 from typing import Any, ClassVar
 
-from anthropic import APIConnectionError, APIStatusError, RateLimitError
+from anthropic import APIConnectionError, APIStatusError
 
 from ...core.errors import format_error
 from ...core.types import (
@@ -248,8 +248,10 @@ class AnthropicSDKProvider(BaseProvider):
                 return StopReason.STOP
 
     def should_retry_for_error(self, error: Exception) -> bool:
-        if isinstance(error, RateLimitError):
-            return True
+        from ..rate_limit import is_rate_limit_error
+
+        if is_rate_limit_error(error):
+            return False
         if isinstance(error, APIConnectionError):
             return True
         if isinstance(error, APIStatusError):

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/llm/providers/openai_sdk.py

@@ -3,7 +3,7 @@
 from collections.abc import AsyncIterator
 from typing import Any, ClassVar
 
-from openai import APIConnectionError, APIStatusError, RateLimitError
+from openai import APIConnectionError, APIError, APIStatusError
 
 from ...core.errors import format_error
 from ...core.types import (
@@ -258,10 +258,15 @@ class OpenAISDKProvider(BaseProvider):
                 return StopReason.STOP
 
     def should_retry_for_error(self, error: Exception) -> bool:
-        if isinstance(error, RateLimitError):
-            return True
+        from ..rate_limit import is_rate_limit_error
+
+        if is_rate_limit_error(error):
+            return False
         if isinstance(error, APIConnectionError):
             return True
         if isinstance(error, APIStatusError):
             return error.status_code >= 500
+        if isinstance(error, APIError):
+            msg = str(error).lower()
+            return any(s in msg for s in ("provider returned error", "overloaded", "capacity"))
         return False

vtx_coding_agent-0.1.5/src/vtx/llm/rate_limit.py

@@ -0,0 +1,209 @@
+"""Internal rate-limit manager for LLM providers.
+
+Intercepts rate-limit errors (429 / Retry-After) at the provider stream
+layer and retries with exponential backoff + jitter.  Transparent to the
+caller — a successful stream is returned as if no rate limit occurred.
+
+Usage (automatic via BaseProvider.stream):
+    The manager is instantiated lazily on first use and shared across all
+    providers.  Each call to ``retry_stream`` tracks attempt count per
+    provider so backoff resets between independent requests.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import random
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base import BaseProvider, LLMStream
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+DEFAULT_MAX_RETRIES = 5
+DEFAULT_BASE_DELAY = 1.0  # seconds
+DEFAULT_MAX_DELAY = 60.0  # seconds
+JITTER_RANGE = 0.5  # ±50 % of computed delay
+
+
+# ---------------------------------------------------------------------------
+# Rate-limit detection helpers
+# ---------------------------------------------------------------------------
+
+
+def is_rate_limit_error(error: Exception) -> bool:
+    """Return True if *error* represents a rate-limit / 429 response."""
+    msg = str(error).lower()
+    name = type(error).__name__
+
+    # Direct keyword match
+    if "rate limit" in msg or "too many requests" in msg or "429" in msg:
+        return True
+
+    # Transient upstream errors from gateways (Kilo, OpenRouter, etc.)
+    if any(s in msg for s in ("provider returned error", "overloaded", "capacity")):
+        return True
+
+    # httpx / openai / anthropic SDK error classes
+    if name in ("RateLimitError", "TooManyRequestsError"):
+        return True
+
+    # HTTPStatusError variants — check status code attribute
+    status = getattr(error, "status_code", None)
+    return status == 429
+
+
+def parse_retry_after(error: Exception) -> float | None:
+    """Try to extract a ``Retry-After`` value (seconds) from the error."""
+    # Some SDKs expose headers on the error object
+    headers = getattr(error, "headers", None)
+    if headers is None:
+        resp = getattr(error, "response", None)
+        headers = getattr(resp, "headers", None) if resp else None
+
+    if headers:
+        raw = None
+        get_fn = getattr(headers, "get", None)
+        if get_fn is not None:
+            raw = get_fn("Retry-After") or get_fn("retry-after")
+        elif isinstance(headers, dict):
+            raw = headers.get("Retry-After") or headers.get("retry-after")
+
+        if raw is not None:
+            try:
+                return float(raw)
+            except (ValueError, TypeError):
+                pass
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# RateLimitManager
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class _ProviderState:
+    attempts: int = 0
+    last_error_time: float = 0.0
+
+
+class RateLimitManager:
+    """Stateful manager that applies exponential backoff on rate-limit errors.
+
+    Instantiate once and share across providers.  Call ``should_retry`` to
+    check whether a retry is allowed, then ``wait`` to block for the
+    appropriate delay.  Call ``reset`` after a successful stream to clear
+    the attempt counter.
+    """
+
+    def __init__(
+        self,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        base_delay: float = DEFAULT_BASE_DELAY,
+        max_delay: float = DEFAULT_MAX_DELAY,
+    ) -> None:
+        self.max_retries = max_retries
+        self.base_delay = base_delay
+        self.max_delay = max_delay
+        self._states: dict[str, _ProviderState] = {}
+
+    def _state(self, provider_name: str) -> _ProviderState:
+        if provider_name not in self._states:
+            self._states[provider_name] = _ProviderState()
+        return self._states[provider_name]
+
+    def should_retry(self, provider_name: str, error: Exception) -> bool:
+        """Return True if the error is retryable and retries remain."""
+        if not is_rate_limit_error(error):
+            return False
+        state = self._state(provider_name)
+        return state.attempts < self.max_retries
+
+    def wait_delay(self, provider_name: str, error: Exception) -> float:
+        """Compute and return the delay (seconds) before the next retry.
+
+        Respects ``Retry-After`` headers when present, otherwise uses
+        exponential backoff with jitter.
+        """
+        state = self._state(provider_name)
+        state.attempts += 1
+        state.last_error_time = time.monotonic()
+
+        # Prefer server-provided Retry-After
+        retry_after = parse_retry_after(error)
+        if retry_after is not None:
+            delay = min(retry_after, self.max_delay)
+        else:
+            delay = min(self.base_delay * (2 ** (state.attempts - 1)), self.max_delay)
+
+        # Add jitter
+        jitter = delay * JITTER_RANGE * (2 * random.random() - 1)
+        delay = max(0.1, delay + jitter)
+
+        logger.info(
+            "Rate limit hit for %s (attempt %d/%d), retrying in %.1fs",
+            provider_name,
+            state.attempts,
+            self.max_retries,
+            delay,
+        )
+        return delay
+
+    def reset(self, provider_name: str) -> None:
+        """Reset attempt counter after a successful request."""
+        state = self._state(provider_name)
+        state.attempts = 0
+
+    async def retry_stream(
+        self,
+        provider: BaseProvider,
+        messages: list,
+        *,
+        system_prompt: str | None = None,
+        tools=None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+    ) -> LLMStream:
+        """Call ``provider._stream_impl`` with internal rate-limit retries.
+
+        On success the attempt counter is reset.  On exhausted retries the
+        last error is re-raised.
+        """
+        provider_name = getattr(provider, "name", "unknown")
+        last_error: Exception | None = None
+
+        for _attempt in range(self.max_retries + 1):
+            try:
+                stream = await provider._stream_impl(
+                    messages,
+                    system_prompt=system_prompt,
+                    tools=tools,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                )
+                self.reset(provider_name)
+                return stream
+            except Exception as exc:
+                last_error = exc
+                if not self.should_retry(provider_name, exc):
+                    raise
+                delay = self.wait_delay(provider_name, exc)
+                await asyncio.sleep(delay)
+
+        # Should not reach here, but safety net
+        assert last_error is not None
+        raise last_error
+
+
+# Module-level singleton
+rate_limit_manager = RateLimitManager()

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/llm/sdk/openai.py

@@ -35,6 +35,9 @@ def _is_transient_error(e: Exception) -> bool:
             "bad gateway",
             "gateway timeout",
             "service unavailable",
+            "provider returned error",
+            "overloaded",
+            "capacity",
         ]
     )
 

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/tools/skill.py

@@ -4,10 +4,10 @@ import shutil
 from pathlib import Path
 from typing import Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 from ..context.skills import (
-    get_config_dir,
+    get_user_skills_dir,
     load_builtin_cmd_skills,
     load_skills,
     merge_registered_skills,
@@ -16,6 +16,14 @@ from .base import BaseTool, ToolResult
 
 
 class SkillParams(BaseModel):
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_none_strings(cls, data: dict) -> dict:
+        for key in ("name", "content", "old_string", "new_string", "file_path"):
+            if isinstance(data.get(key), str) and data[key].strip().lower() == "none":
+                data[key] = None
+        return data
+
     action: Literal["list", "view", "create", "patch", "edit", "delete"] = Field(
         description=(
             "The action to perform: list (shows all loaded skills), "
@@ -124,12 +132,20 @@ class SkillTool(BaseTool):
                         return skill_dir, False
 
             # 2. User global skills
-            user_skills_dir = (get_config_dir() / "skills").resolve(strict=False)
+            user_skills_dir = (get_user_skills_dir() / "skills").resolve(strict=False)
             skill_dir = user_skills_dir / name
             if (skill_dir / "SKILL.md").is_file():
                 return skill_dir, False
 
-            # 3. Builtin skills (search recursively through category folders)
+            # 3. Vtx config skills (~/.vtx/skills/ - synced builtins)
+            from ..config import get_config_dir as get_vtx_config_dir
+
+            vtx_skills_dir = (get_vtx_config_dir() / "skills").resolve(strict=False)
+            skill_dir = vtx_skills_dir / name
+            if (skill_dir / "SKILL.md").is_file():
+                return skill_dir, True
+
+            # 4. Builtin skills (search recursively through category folders)
             from importlib import resources
 
             try:
@@ -182,7 +198,7 @@ class SkillTool(BaseTool):
 
             # Resolve target path based on scope
             if params.scope == "global":
-                target_skills_dir = (get_config_dir() / "skills").resolve(strict=False)
+                target_skills_dir = (get_user_skills_dir() / "skills").resolve(strict=False)
             else:
                 target_skills_dir = Path(cwd) / ".agents" / "skills"
 

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/src/vtx/version.py

@@ -19,4 +19,4 @@ PACKAGE_NAME = _get_package_name()
 try:
     VERSION = version(PACKAGE_NAME)
 except PackageNotFoundError:
-    VERSION = "0.1.4"  # Fallback version if package metadata is not available
+    VERSION = "0.1.5"  # Fallback version if package metadata is not available

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/tests/context/test_skills.py

@@ -342,7 +342,7 @@ description: Global skill
 ---
 """)
 
-        monkeypatch.setattr("vtx.context.skills.get_config_dir", lambda: global_dir)
+        monkeypatch.setattr("vtx.context.skills.get_user_skills_dir", lambda: global_dir)
 
         result = load_skills(str(repo))
 
@@ -368,7 +368,7 @@ description: Global version
 ---
 """)
 
-        monkeypatch.setattr("vtx.context.skills.get_config_dir", lambda: global_dir)
+        monkeypatch.setattr("vtx.context.skills.get_user_skills_dir", lambda: global_dir)
         if sys.platform == "win32":
             monkeypatch.setenv("USERPROFILE", str(tmp_path))
         else:
@@ -396,7 +396,7 @@ description: Planning-only mode
 ---
 """)
 
-        monkeypatch.setattr("vtx.context.skills.get_config_dir", lambda: home_dir / ".agents")
+        monkeypatch.setattr("vtx.context.skills.get_user_skills_dir", lambda: home_dir / ".agents")
         monkeypatch.setenv("HOME", str(home_dir))
 
         result = load_skills(str(home_dir))
@@ -411,7 +411,7 @@ description: Planning-only mode
         repo.mkdir()
         global_dir = tmp_path / "global"
 
-        monkeypatch.setattr("vtx.context.skills.get_config_dir", lambda: global_dir)
+        monkeypatch.setattr("vtx.context.skills.get_user_skills_dir", lambda: global_dir)
 
         result = load_skills(str(repo))
 
@@ -429,7 +429,7 @@ name: invalid-skill
 """)
 
         global_dir = tmp_path / "global"
-        monkeypatch.setattr("vtx.context.skills.get_config_dir", lambda: global_dir)
+        monkeypatch.setattr("vtx.context.skills.get_user_skills_dir", lambda: global_dir)
 
         result = load_skills(str(repo))
 
@@ -446,7 +446,7 @@ description: Uses directory fallback
 """)
 
         global_dir = tmp_path / "global"
-        monkeypatch.setattr("vtx.context.skills.get_config_dir", lambda: global_dir)
+        monkeypatch.setattr("vtx.context.skills.get_user_skills_dir", lambda: global_dir)
 
         result = load_skills(str(repo))
 

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/tests/llm/test_anthropic_provider.py

@@ -77,11 +77,11 @@ def _make_mock_response(status_code: int) -> httpx.Response:
     return httpx.Response(status_code, request=httpx.Request("GET", "https://example.com"))
 
 
-def test_should_retry_for_rate_limit(anthropic_provider):
+def test_should_not_retry_rate_limit_internally_handled(anthropic_provider):
     from anthropic import RateLimitError
 
     error = RateLimitError(message="rate limited", response=_make_mock_response(429), body=None)
-    assert anthropic_provider.should_retry_for_error(error) is True
+    assert anthropic_provider.should_retry_for_error(error) is False
 
 
 def test_should_retry_for_server_error(anthropic_provider):

{vtx_coding_agent-0.1.4 → vtx_coding_agent-0.1.5}/tests/test_agentic_loop.py

@@ -396,16 +396,12 @@ async def test_run_single_turn_retries_scenario(sample_messages, tools):
     ):
         events.append(event)
 
-    # Should have 2 retry events
+    # Rate limit retries are now handled internally by the rate limit manager
+    # at the provider level, so turn-level retry events should not appear.
     retry_events = [e for e in events if isinstance(e, RetryEvent)]
-    assert len(retry_events) == 2
-    assert retry_events[0].attempt == 1
-    assert retry_events[0].total_attempts == 3
-    assert "Rate limit" in retry_events[0].error
-    assert retry_events[1].attempt == 2
-    assert retry_events[1].total_attempts == 3
-
-    # Eventually succeed with default scenario content
+    assert len(retry_events) == 0
+
+    # Should still succeed — rate limit manager retried internally
     thinking_start = next(e for e in events if isinstance(e, ThinkingStartEvent))
     assert thinking_start is not None