ripperdoc 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

ripperdoc/__init__.py

@@ -1,3 +1,3 @@
 """Ripperdoc - AI-powered coding agent."""
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"

ripperdoc/cli/commands/context_cmd.py

@@ -9,11 +9,11 @@ from ripperdoc.core.query import QueryContext
 from ripperdoc.core.system_prompt import build_system_prompt
 from ripperdoc.utils.memory import build_memory_instructions
 from ripperdoc.utils.message_compaction import (
-    estimate_tokens_from_text,
     get_remaining_context_tokens,
     resolve_auto_compact_enabled,
     summarize_context_usage,
 )
+from ripperdoc.utils.token_estimation import estimate_tokens
 from ripperdoc.utils.mcp import (
     estimate_mcp_tokens,
     format_mcp_instructions,
@@ -60,7 +60,7 @@ def _handle(ui: Any, _: str) -> bool:
         mcp_instructions=mcp_instructions,
     )
     memory_instructions = build_memory_instructions()
-    memory_tokens = estimate_tokens_from_text(memory_instructions) if memory_instructions else 0
+    memory_tokens = estimate_tokens(memory_instructions) if memory_instructions else 0
     mcp_tokens = estimate_mcp_tokens(servers) if mcp_instructions else 0
 
     breakdown = summarize_context_usage(
@@ -98,7 +98,7 @@ def _handle(ui: Any, _: str) -> bool:
                     display = f"{display} ({server})"
                 try:
                     schema = tool.input_schema.model_json_schema()
-                    token_est = estimate_tokens_from_text(json.dumps(schema, sort_keys=True))
+                    token_est = estimate_tokens(json.dumps(schema, sort_keys=True))
                 except Exception:
                     token_est = 0
                 lines.append(f"     └ {display}: {format_tokens(token_est)} tokens")

ripperdoc/cli/ui/rich_ui.py

@@ -39,12 +39,12 @@ from ripperdoc.cli.ui.context_display import context_usage_lines
 from ripperdoc.utils.message_compaction import (
     compact_messages,
     estimate_conversation_tokens,
-    estimate_tokens_from_text,
     estimate_used_tokens,
     get_context_usage_status,
     get_remaining_context_tokens,
     resolve_auto_compact_enabled,
 )
+from ripperdoc.utils.token_estimation import estimate_tokens
 from ripperdoc.utils.mcp import (
     format_mcp_instructions,
     load_mcp_servers_async,
@@ -448,6 +448,13 @@ class RichUI:
             else:
                 success = getattr(tool_data, "success", None)
                 failed = failed or (success is False)
+            failed = failed or bool(self._get_tool_field(tool_data, "is_error"))
+
+        warning_text = None
+        token_estimate = None
+        if tool_data is not None:
+            warning_text = self._get_tool_field(tool_data, "warning")
+            token_estimate = self._get_tool_field(tool_data, "token_estimate")
 
         if failed:
             if content:
@@ -456,6 +463,17 @@ class RichUI:
                 self.console.print(f"  ⎿  [red]{escape(sender)} failed[/red]")
             return
 
+        if warning_text:
+            self.console.print(f"  ⎿  [yellow]{escape(str(warning_text))}[/yellow]")
+            if token_estimate:
+                self.console.print(
+                    f"      [dim]Estimated tokens: {escape(str(token_estimate))}[/dim]"
+                )
+        elif token_estimate and self.verbose:
+            self.console.print(
+                f"  ⎿  [dim]Estimated tokens: {escape(str(token_estimate))}[/dim]"
+            )
+
         if not content:
             self.console.print("  ⎿  [dim]Tool completed[/]")
             return
@@ -832,6 +850,21 @@ class RichUI:
 
             prompt_tokens_est = estimate_conversation_tokens(messages, protocol=protocol)
             spinner = ThinkingSpinner(console, prompt_tokens_est)
+
+            # Define pause/resume callbacks for tools that need user interaction
+            def pause_ui() -> None:
+                if spinner:
+                    spinner.stop()
+
+            def resume_ui() -> None:
+                if spinner:
+                    spinner.start()
+                    spinner.update("Thinking...")
+
+            # Set the UI callbacks on the query context
+            self.query_context.pause_ui = pause_ui
+            self.query_context.resume_ui = resume_ui
+
             # Wrap permission checker to pause the spinner while waiting for user input.
             base_permission_checker = self._permission_checker
 
@@ -947,7 +980,7 @@ class RichUI:
                             elif message.content.startswith("Subagent"):
                                 self.display_message("Subagent", message.content, is_tool=True)
                         if message.tool_use_id == "stream":
-                            delta_tokens = estimate_tokens_from_text(message.content)
+                            delta_tokens = estimate_tokens(message.content)
                             output_token_est += delta_tokens
                             spinner.update_tokens(output_token_est)
                         else:

ripperdoc/core/agents.py

@@ -11,11 +11,63 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple
 import yaml
 
 from ripperdoc.utils.log import get_logger
+from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
+from ripperdoc.tools.bash_output_tool import BashOutputTool
+from ripperdoc.tools.bash_tool import BashTool
+from ripperdoc.tools.enter_plan_mode_tool import EnterPlanModeTool
+from ripperdoc.tools.exit_plan_mode_tool import ExitPlanModeTool
+from ripperdoc.tools.file_edit_tool import FileEditTool
+from ripperdoc.tools.file_read_tool import FileReadTool
+from ripperdoc.tools.file_write_tool import FileWriteTool
+from ripperdoc.tools.glob_tool import GlobTool
+from ripperdoc.tools.grep_tool import GrepTool
+from ripperdoc.tools.kill_bash_tool import KillBashTool
+from ripperdoc.tools.ls_tool import LSTool
+from ripperdoc.tools.multi_edit_tool import MultiEditTool
+from ripperdoc.tools.notebook_edit_tool import NotebookEditTool
+from ripperdoc.tools.todo_tool import TodoReadTool, TodoWriteTool
+from ripperdoc.tools.tool_search_tool import ToolSearchTool
+from ripperdoc.tools.mcp_tools import (
+    ListMcpResourcesTool,
+    ListMcpServersTool,
+    ReadMcpResourceTool,
+)
 
 
 logger = get_logger()
 
 
+def _safe_tool_name(factory: Any, fallback: str) -> str:
+    try:
+        name = getattr(factory(), "name", None)
+        return str(name) if name else fallback
+    except Exception:
+        return fallback
+
+
+GLOB_TOOL_NAME = _safe_tool_name(GlobTool, "Glob")
+GREP_TOOL_NAME = _safe_tool_name(GrepTool, "Grep")
+VIEW_TOOL_NAME = _safe_tool_name(FileReadTool, "View")
+FILE_EDIT_TOOL_NAME = _safe_tool_name(FileEditTool, "FileEdit")
+MULTI_EDIT_TOOL_NAME = _safe_tool_name(MultiEditTool, "MultiEdit")
+NOTEBOOK_EDIT_TOOL_NAME = _safe_tool_name(NotebookEditTool, "NotebookEdit")
+FILE_WRITE_TOOL_NAME = _safe_tool_name(FileWriteTool, "FileWrite")
+LS_TOOL_NAME = _safe_tool_name(LSTool, "LS")
+BASH_TOOL_NAME = _safe_tool_name(BashTool, "Bash")
+BASH_OUTPUT_TOOL_NAME = _safe_tool_name(BashOutputTool, "BashOutput")
+KILL_BASH_TOOL_NAME = _safe_tool_name(KillBashTool, "KillBash")
+TODO_READ_TOOL_NAME = _safe_tool_name(TodoReadTool, "TodoRead")
+TODO_WRITE_TOOL_NAME = _safe_tool_name(TodoWriteTool, "TodoWrite")
+ASK_USER_QUESTION_TOOL_NAME = _safe_tool_name(AskUserQuestionTool, "AskUserQuestion")
+ENTER_PLAN_MODE_TOOL_NAME = _safe_tool_name(EnterPlanModeTool, "EnterPlanMode")
+EXIT_PLAN_MODE_TOOL_NAME = _safe_tool_name(ExitPlanModeTool, "ExitPlanMode")
+TOOL_SEARCH_TOOL_NAME = _safe_tool_name(ToolSearchTool, "ToolSearch")
+MCP_LIST_SERVERS_TOOL_NAME = _safe_tool_name(ListMcpServersTool, "ListMcpServers")
+MCP_LIST_RESOURCES_TOOL_NAME = _safe_tool_name(ListMcpResourcesTool, "ListMcpResources")
+MCP_READ_RESOURCE_TOOL_NAME = _safe_tool_name(ReadMcpResourceTool, "ReadMcpResource")
+TASK_TOOL_NAME = "Task"
+
+
 AGENT_DIR_NAME = "agents"
 
 
@@ -64,6 +116,86 @@ CODE_REVIEW_AGENT_PROMPT = (
     "Provide clear, actionable feedback that the parent agent can relay to the user."
 )
 
+EXPLORE_AGENT_PROMPT = (
+    "You are a file search specialist. "
+    "You excel at thoroughly navigating and exploring codebases.\n\n"
+    "=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===\n"
+    "This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:\n"
+    "- Creating new files (no Write, touch, or file creation of any kind)\n"
+    "- Modifying existing files (no Edit operations)\n"
+    "- Deleting files (no rm or deletion)\n"
+    "- Moving or copying files (no mv or cp)\n"
+    "- Creating temporary files anywhere, including /tmp\n"
+    "- Using redirect operators (>, >>, |) or heredocs to write to files\n"
+    "- Running ANY commands that change system state\n\n"
+    "Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access "
+    "to file editing tools - attempting to edit files will fail.\n\n"
+    "Your strengths:\n"
+    "- Rapidly finding files using glob patterns\n"
+    "- Searching code and text with powerful regex patterns\n"
+    "- Reading and analyzing file contents\n\n"
+    "Guidelines:\n"
+    f"- Use {GLOB_TOOL_NAME} for broad file pattern matching\n"
+    f"- Use {GREP_TOOL_NAME} for searching file contents with regex\n"
+    f"- Use {VIEW_TOOL_NAME} when you know the specific file path you need to read\n"
+    f"- Use {BASH_TOOL_NAME} ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)\n"
+    f"- NEVER use {BASH_TOOL_NAME} for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification\n"
+    "- Adapt your search approach based on the thoroughness level specified by the caller\n"
+    "- Return file paths as absolute paths in your final response\n"
+    "- For clear communication, avoid using emojis\n"
+    "- Communicate your final report directly as a regular message - do NOT attempt to create files\n\n"
+    "NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:\n"
+    "- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations\n"
+    "- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files\n\n"
+    "Complete the user's search request efficiently and report your findings clearly."
+)
+
+PLAN_AGENT_PROMPT = (
+    "You are a software architect and planning specialist. Your role is "
+    "to explore the codebase and design implementation plans.\n\n"
+    "=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===\n"
+    "This is a READ-ONLY planning task. You are STRICTLY PROHIBITED from:\n"
+    "- Creating new files (no Write, touch, or file creation of any kind)\n"
+    "- Modifying existing files (no Edit operations)\n"
+    "- Deleting files (no rm or deletion)\n"
+    "- Moving or copying files (no mv or cp)\n"
+    "- Creating temporary files anywhere, including /tmp\n"
+    "- Using redirect operators (>, >>, |) or heredocs to write to files\n"
+    "- Running ANY commands that change system state\n\n"
+    "Your role is EXCLUSIVELY to explore the codebase and design implementation plans. "
+    "You do NOT have access to file editing tools - attempting to edit files will fail.\n\n"
+    "You will be provided with a set of requirements and optionally a perspective on how "
+    "to approach the design process.\n\n"
+    "## Your Process\n\n"
+    "1. **Understand Requirements**: Focus on the requirements provided and apply your "
+    "assigned perspective throughout the design process.\n\n"
+    "2. **Explore Thoroughly**:\n"
+    "   - Read any files provided to you in the initial prompt\n"
+    f"   - Find existing patterns and conventions using {GLOB_TOOL_NAME}, {GREP_TOOL_NAME}, and {VIEW_TOOL_NAME}\n"
+    "   - Understand the current architecture\n"
+    "   - Identify similar features as reference\n"
+    "   - Trace through relevant code paths\n"
+    f"   - Use {BASH_TOOL_NAME} ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail)\n"
+    f"   - NEVER use {BASH_TOOL_NAME} for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification\n\n"
+    "3. **Design Solution**:\n"
+    "   - Create implementation approach based on your assigned perspective\n"
+    "   - Consider trade-offs and architectural decisions\n"
+    "   - Follow existing patterns where appropriate\n\n"
+    "4. **Detail the Plan**:\n"
+    "   - Provide step-by-step implementation strategy\n"
+    "   - Identify dependencies and sequencing\n"
+    "   - Anticipate potential challenges\n\n"
+    "## Required Output\n\n"
+    "End your response with:\n\n"
+    "### Critical Files for Implementation\n"
+    "List 3-5 files most critical for implementing this plan:\n"
+    "- path/to/file1.ts - [Brief reason: e.g., \"Core logic to modify\"]\n"
+    "- path/to/file2.ts - [Brief reason: e.g., \"Interfaces to implement\"]\n"
+    "- path/to/file3.ts - [Brief reason: e.g., \"Pattern to follow\"]\n\n"
+    "REMEMBER: You can ONLY explore and plan. You CANNOT and MUST NOT write, edit, or "
+    "modify any files. You do NOT have access to file editing tools."
+)
+
 
 def _built_in_agents() -> List[AgentDefinition]:
     return [
@@ -89,6 +221,34 @@ def _built_in_agents() -> List[AgentDefinition]:
             location=AgentLocation.BUILT_IN,
             color="yellow",
         ),
+        AgentDefinition(
+            agent_type="explore",
+            when_to_use=(
+                'Fast agent specialized for exploring codebases. Use this when you need to quickly find '
+                'files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), '
+                'or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, '
+                'specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, '
+                'or "very thorough" for comprehensive analysis across multiple locations and naming conventions.'
+            ),
+            tools=["View", "Glob", "Grep"],
+            system_prompt=EXPLORE_AGENT_PROMPT,
+            location=AgentLocation.BUILT_IN,
+            color="green",
+            model="task",
+        ),
+        AgentDefinition(
+            agent_type="plan",
+            when_to_use=(
+                "Software architect agent for designing implementation plans. Use this when "
+                "you need to plan the implementation strategy for a task. Returns step-by-step "
+                "plans, identifies critical files, and considers architectural trade-offs."
+            ),
+            tools=["View", "Glob", "Grep"],
+            system_prompt=PLAN_AGENT_PROMPT,
+            location=AgentLocation.BUILT_IN,
+            color="blue",
+            model=None,
+        ),
     ]
 
 

ripperdoc/core/default_tools.py

@@ -18,6 +18,9 @@ from ripperdoc.tools.glob_tool import GlobTool
 from ripperdoc.tools.ls_tool import LSTool
 from ripperdoc.tools.grep_tool import GrepTool
 from ripperdoc.tools.todo_tool import TodoReadTool, TodoWriteTool
+from ripperdoc.tools.ask_user_question_tool import AskUserQuestionTool
+from ripperdoc.tools.enter_plan_mode_tool import EnterPlanModeTool
+from ripperdoc.tools.exit_plan_mode_tool import ExitPlanModeTool
 from ripperdoc.tools.task_tool import TaskTool
 from ripperdoc.tools.tool_search_tool import ToolSearchTool
 from ripperdoc.tools.mcp_tools import (
@@ -47,6 +50,9 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         GrepTool(),
         TodoReadTool(),
         TodoWriteTool(),
+        AskUserQuestionTool(),
+        EnterPlanModeTool(),
+        ExitPlanModeTool(),
         ToolSearchTool(),
         ListMcpServersTool(),
         ListMcpResourcesTool(),

ripperdoc/core/providers/__init__.py

@@ -1,31 +1,47 @@
-"""Provider client registry."""
+"""Provider client registry with optional dependencies."""
 
 from __future__ import annotations
 
-from typing import Optional
+import importlib
+from typing import Optional, TYPE_CHECKING, Type, cast
 
 from ripperdoc.core.config import ProviderType
-from ripperdoc.core.providers.anthropic import AnthropicClient
 from ripperdoc.core.providers.base import ProviderClient
-from ripperdoc.core.providers.gemini import GeminiClient
-from ripperdoc.core.providers.openai import OpenAIClient
+from ripperdoc.utils.log import get_logger
+
+if TYPE_CHECKING:  # pragma: no cover - type checking only
+    from ripperdoc.core.providers.anthropic import AnthropicClient  # noqa: F401
+    from ripperdoc.core.providers.gemini import GeminiClient  # noqa: F401
+    from ripperdoc.core.providers.openai import OpenAIClient  # noqa: F401
+
+logger = get_logger()
+
+
+def _load_client(module: str, cls: str, extra: str) -> Type[ProviderClient]:
+    """Dynamically import a provider client, pointing users to the right extra."""
+    try:
+        mod = importlib.import_module(f"ripperdoc.core.providers.{module}")
+        client_cls = cast(Type[ProviderClient], getattr(mod, cls, None))
+        if client_cls is None:
+            raise ImportError(f"{cls} not found in {module}")
+        return client_cls
+    except ImportError as exc:
+        raise RuntimeError(
+            f"{cls} requires optional dependency group '{extra}'. "
+            f"Install with `pip install ripperdoc[{extra}]`."
+        ) from exc
 
 
 def get_provider_client(provider: ProviderType) -> Optional[ProviderClient]:
     """Return a provider client for the given protocol."""
     if provider == ProviderType.ANTHROPIC:
-        return AnthropicClient()
+        return _load_client("anthropic", "AnthropicClient", "anthropic")()
     if provider == ProviderType.OPENAI_COMPATIBLE:
-        return OpenAIClient()
+        return _load_client("openai", "OpenAIClient", "openai")()
     if provider == ProviderType.GEMINI:
-        return GeminiClient()
+        return _load_client("gemini", "GeminiClient", "gemini")()
+    logger.warning("[providers] Unsupported provider", extra={"provider": provider})
     return None
 
 
-__all__ = [
-    "ProviderClient",
-    "AnthropicClient",
-    "GeminiClient",
-    "OpenAIClient",
-    "get_provider_client",
-]
+__all__ = ["ProviderClient", "get_provider_client"]

ripperdoc/core/providers/anthropic.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import time
 from typing import Any, Awaitable, Callable, Dict, List, Optional
 
@@ -13,6 +14,7 @@ from ripperdoc.core.providers.base import (
     ProviderClient,
     ProviderResponse,
     call_with_timeout_and_retries,
+    iter_with_timeout,
     sanitize_tool_history,
 )
 from ripperdoc.core.query_utils import (
@@ -68,15 +70,21 @@ class AnthropicClient(ProviderClient):
         async with await self._client(anthropic_kwargs) as client:
 
             async def _stream_request() -> Any:
-                async with client.messages.stream(
+                stream_cm = client.messages.stream(
                     model=model_profile.model,
                     max_tokens=model_profile.max_tokens,
                     system=system_prompt,
                     messages=normalized_messages,  # type: ignore[arg-type]
                     tools=tool_schemas if tool_schemas else None,  # type: ignore
                     temperature=model_profile.temperature,
-                ) as stream_resp:
-                    async for text in stream_resp.text_stream:
+                )
+                stream_resp = (
+                    await asyncio.wait_for(stream_cm.__aenter__(), timeout=request_timeout)
+                    if request_timeout and request_timeout > 0
+                    else await stream_cm.__aenter__()
+                )
+                try:
+                    async for text in iter_with_timeout(stream_resp.text_stream, request_timeout):
                         if text:
                             collected_text.append(text)
                             if progress_callback:
@@ -90,6 +98,8 @@ class AnthropicClient(ProviderClient):
                     if getter:
                         return await getter()
                     return None
+                finally:
+                    await stream_cm.__aexit__(None, None, None)
 
             async def _non_stream_request() -> Any:
                 return await client.messages.create(
@@ -101,9 +111,10 @@ class AnthropicClient(ProviderClient):
                     temperature=model_profile.temperature,
                 )
 
+            timeout_for_call = None if stream else request_timeout
             response = await call_with_timeout_and_retries(
                 _stream_request if stream else _non_stream_request,
-                request_timeout,
+                timeout_for_call,
                 max_retries,
             )
 

ripperdoc/core/providers/base.py

@@ -3,9 +3,20 @@
 from __future__ import annotations
 
 import asyncio
+import random
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, Dict, List, Optional
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+)
 
 from ripperdoc.core.config import ModelProfile
 from ripperdoc.core.tool import Tool
@@ -153,35 +164,73 @@ def sanitize_tool_history(normalized_messages: List[Dict[str, Any]]) -> List[Dic
     return sanitized
 
 
+def _retry_delay_seconds(attempt: int, base_delay: float = 0.5, max_delay: float = 32.0) -> float:
+    """Calculate exponential backoff with jitter."""
+    capped_base: float = float(min(base_delay * (2 ** max(0, attempt - 1)), max_delay))
+    jitter: float = float(random.random() * 0.25 * capped_base)
+    return float(capped_base + jitter)
+
+async def iter_with_timeout(
+    stream: Iterable[Any] | AsyncIterable[Any], timeout: Optional[float]
+) -> AsyncIterator[Any]:
+    """Yield items from an async or sync iterable, enforcing per-item timeout if provided."""
+    if timeout is None or timeout <= 0:
+        if hasattr(stream, "__aiter__"):
+            async for item in stream:  # type: ignore[async-for]
+                yield item
+        else:
+            for item in stream:
+                yield item
+        return
+
+    if hasattr(stream, "__aiter__"):
+        aiter = stream.__aiter__()  # type: ignore[attr-defined]
+        while True:
+            try:
+                yield await asyncio.wait_for(aiter.__anext__(), timeout=timeout)  # type: ignore[attr-defined]
+            except StopAsyncIteration:
+                break
+    else:
+        iterator = iter(stream)
+        while True:
+            try:
+                next_item = await asyncio.wait_for(asyncio.to_thread(next, iterator), timeout=timeout)
+            except StopIteration:
+                break
+            yield next_item
+
+
 async def call_with_timeout_and_retries(
     coro_factory: Callable[[], Awaitable[Any]],
     request_timeout: Optional[float],
     max_retries: int,
 ) -> Any:
-    """Run a coroutine with timeout and limited retries."""
+    """Run a coroutine with timeout and limited retries (exponential backoff)."""
     attempts = max(0, int(max_retries)) + 1
     last_error: Optional[Exception] = None
+
     for attempt in range(1, attempts + 1):
         try:
             if request_timeout and request_timeout > 0:
                 return await asyncio.wait_for(coro_factory(), timeout=request_timeout)
             return await coro_factory()
         except asyncio.TimeoutError as exc:
-            last_error = exc
-            logger.warning(
-                "[provider_clients] Request timed out; retrying",
-                extra={"attempt": attempt, "max_retries": attempts - 1},
-            )
-            if attempt == attempts:
-                raise
-        except Exception as exc:
             last_error = exc
             if attempt == attempts:
-                raise
+                break
+            delay_seconds = _retry_delay_seconds(attempt)
             logger.warning(
-                "[provider_clients] Request failed; retrying",
-                extra={"attempt": attempt, "max_retries": attempts - 1, "error": str(exc)},
+                "[provider_clients] Request timed out; retrying",
+                extra={
+                    "attempt": attempt,
+                    "max_retries": attempts - 1,
+                    "delay_seconds": round(delay_seconds, 3),
+                },
             )
+            await asyncio.sleep(delay_seconds)
+        except Exception:
+            # Non-timeout errors are not retried; surface immediately.
+            raise
     if last_error:
-        raise last_error
+        raise RuntimeError(f"Request timed out after {attempts} attempts") from last_error
     raise RuntimeError("Unexpected error executing request with retries")