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

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 dataclasses import dataclass, field
+from typing import (
+    Any,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+)
 
 from ripperdoc.core.config import ModelProfile
 from ripperdoc.core.tool import Tool
@@ -24,6 +35,29 @@ class ProviderResponse:
     usage_tokens: Dict[str, int]
     cost_usd: float
     duration_ms: float
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    # Error handling fields
+    is_error: bool = False
+    error_code: Optional[str] = None  # e.g., "permission_denied", "context_length_exceeded"
+    error_message: Optional[str] = None
+
+    @classmethod
+    def create_error(
+        cls,
+        error_code: str,
+        error_message: str,
+        duration_ms: float = 0.0,
+    ) -> "ProviderResponse":
+        """Create an error response with a text block containing the error message."""
+        return cls(
+            content_blocks=[{"type": "text", "text": f"[API Error] {error_message}"}],
+            usage_tokens={},
+            cost_usd=0.0,
+            duration_ms=duration_ms,
+            is_error=True,
+            error_code=error_code,
+            error_message=error_message,
+        )
 
 
 class ProviderClient(ABC):
@@ -42,6 +76,7 @@ class ProviderClient(ABC):
         progress_callback: Optional[ProgressCallback],
         request_timeout: Optional[float],
         max_retries: int,
+        max_thinking_tokens: int,
     ) -> ProviderResponse:
         """Execute a model call and return a normalized response."""
 
@@ -153,14 +188,54 @@ 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:
@@ -168,20 +243,23 @@ async def call_with_timeout_and_retries(
             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 asyncio.CancelledError:
+            raise  # Don't suppress task cancellation
+        except (RuntimeError, ValueError, TypeError, OSError, ConnectionError) as exc:
+            # Non-timeout errors are not retried; surface immediately.
+            raise exc
     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")