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

ripperdoc/core/providers/anthropic.py

@@ -6,6 +6,7 @@ import asyncio
 import time
 from typing import Any, Awaitable, Callable, Dict, List, Optional
 
+import anthropic
 from anthropic import AsyncAnthropic
 
 from ripperdoc.core.config import ModelProfile
@@ -30,6 +31,38 @@ from ripperdoc.utils.session_usage import record_usage
 logger = get_logger()
 
 
+def _classify_anthropic_error(exc: Exception) -> tuple[str, str]:
+    """Classify an Anthropic exception into error code and user-friendly message."""
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    if isinstance(exc, anthropic.AuthenticationError):
+        return "authentication_error", f"Authentication failed: {exc_msg}"
+    if isinstance(exc, anthropic.PermissionDeniedError):
+        if "balance" in exc_msg.lower() or "insufficient" in exc_msg.lower():
+            return "insufficient_balance", f"Insufficient balance: {exc_msg}"
+        return "permission_denied", f"Permission denied: {exc_msg}"
+    if isinstance(exc, anthropic.NotFoundError):
+        return "model_not_found", f"Model not found: {exc_msg}"
+    if isinstance(exc, anthropic.BadRequestError):
+        if "context" in exc_msg.lower() or "token" in exc_msg.lower():
+            return "context_length_exceeded", f"Context length exceeded: {exc_msg}"
+        if "content" in exc_msg.lower() and "policy" in exc_msg.lower():
+            return "content_policy_violation", f"Content policy violation: {exc_msg}"
+        return "bad_request", f"Invalid request: {exc_msg}"
+    if isinstance(exc, anthropic.RateLimitError):
+        return "rate_limit", f"Rate limit exceeded: {exc_msg}"
+    if isinstance(exc, anthropic.APIConnectionError):
+        return "connection_error", f"Connection error: {exc_msg}"
+    if isinstance(exc, anthropic.APIStatusError):
+        status = getattr(exc, "status_code", "unknown")
+        return "api_error", f"API error ({status}): {exc_msg}"
+    if isinstance(exc, asyncio.TimeoutError):
+        return "timeout", f"Request timed out: {exc_msg}"
+
+    return "unknown_error", f"Unexpected error ({exc_type}): {exc_msg}"
+
+
 class AnthropicClient(ProviderClient):
     """Anthropic client with streaming and non-streaming support."""
 
@@ -53,10 +86,64 @@ class AnthropicClient(ProviderClient):
         progress_callback: Optional[ProgressCallback],
         request_timeout: Optional[float],
         max_retries: int,
+        max_thinking_tokens: int,
     ) -> ProviderResponse:
         start_time = time.time()
+
+        try:
+            return await self._call_impl(
+                model_profile=model_profile,
+                system_prompt=system_prompt,
+                normalized_messages=normalized_messages,
+                tools=tools,
+                tool_mode=tool_mode,
+                stream=stream,
+                progress_callback=progress_callback,
+                request_timeout=request_timeout,
+                max_retries=max_retries,
+                max_thinking_tokens=max_thinking_tokens,
+                start_time=start_time,
+            )
+        except asyncio.CancelledError:
+            raise  # Don't suppress task cancellation
+        except Exception as exc:
+            duration_ms = (time.time() - start_time) * 1000
+            error_code, error_message = _classify_anthropic_error(exc)
+            logger.error(
+                "[anthropic_client] API call failed",
+                extra={
+                    "model": model_profile.model,
+                    "error_code": error_code,
+                    "error_message": error_message,
+                    "duration_ms": round(duration_ms, 2),
+                },
+            )
+            return ProviderResponse.create_error(
+                error_code=error_code,
+                error_message=error_message,
+                duration_ms=duration_ms,
+            )
+
+    async def _call_impl(
+        self,
+        *,
+        model_profile: ModelProfile,
+        system_prompt: str,
+        normalized_messages: Any,
+        tools: List[Tool[Any, Any]],
+        tool_mode: str,
+        stream: bool,
+        progress_callback: Optional[ProgressCallback],
+        request_timeout: Optional[float],
+        max_retries: int,
+        max_thinking_tokens: int,
+        start_time: float,
+    ) -> ProviderResponse:
+        """Internal implementation of call, may raise exceptions."""
         tool_schemas = await build_anthropic_tool_schemas(tools)
         collected_text: List[str] = []
+        reasoning_parts: List[str] = []
+        response_metadata: Dict[str, Any] = {}
 
         anthropic_kwargs = {"base_url": model_profile.api_base}
         if model_profile.api_key:
@@ -67,6 +154,10 @@ class AnthropicClient(ProviderClient):
 
         normalized_messages = sanitize_tool_history(list(normalized_messages))
 
+        thinking_payload: Optional[Dict[str, Any]] = None
+        if max_thinking_tokens > 0:
+            thinking_payload = {"type": "enabled", "budget_tokens": max_thinking_tokens}
+
         async with await self._client(anthropic_kwargs) as client:
 
             async def _stream_request() -> Any:
@@ -77,6 +168,7 @@ class AnthropicClient(ProviderClient):
                     messages=normalized_messages,  # type: ignore[arg-type]
                     tools=tool_schemas if tool_schemas else None,  # type: ignore
                     temperature=model_profile.temperature,
+                    thinking=thinking_payload,  # type: ignore[arg-type]
                 )
                 stream_resp = (
                     await asyncio.wait_for(stream_cm.__aenter__(), timeout=request_timeout)
@@ -90,8 +182,11 @@ class AnthropicClient(ProviderClient):
                             if progress_callback:
                                 try:
                                     await progress_callback(text)
-                                except Exception:
-                                    logger.exception("[anthropic_client] Stream callback failed")
+                                except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
+                                    logger.warning(
+                                        "[anthropic_client] Stream callback failed: %s: %s",
+                                        type(cb_exc).__name__, cb_exc,
+                                    )
                     getter = getattr(stream_resp, "get_final_response", None) or getattr(
                         stream_resp, "get_final_message", None
                     )
@@ -109,6 +204,7 @@ class AnthropicClient(ProviderClient):
                     messages=normalized_messages,  # type: ignore[arg-type]
                     tools=tool_schemas if tool_schemas else None,  # type: ignore
                     temperature=model_profile.temperature,
+                    thinking=thinking_payload,  # type: ignore[arg-type]
                 )
 
             timeout_for_call = None if stream else request_timeout
@@ -126,8 +222,14 @@ class AnthropicClient(ProviderClient):
         )
 
         content_blocks = content_blocks_from_anthropic_response(response, tool_mode)
-        if stream and collected_text and tool_mode == "text":
-            content_blocks = [{"type": "text", "text": "".join(collected_text)}]
+        for blk in content_blocks:
+            if blk.get("type") == "thinking":
+                thinking_text = blk.get("thinking") or blk.get("text") or ""
+                if thinking_text:
+                    reasoning_parts.append(str(thinking_text))
+        if reasoning_parts:
+            response_metadata["reasoning_content"] = "\n".join(reasoning_parts)
+        # Streaming progress is handled via text_stream; final content retains thinking blocks.
 
         logger.info(
             "[anthropic_client] Response received",
@@ -144,4 +246,5 @@ class AnthropicClient(ProviderClient):
             usage_tokens=usage_tokens,
             cost_usd=cost_usd,
             duration_ms=duration_ms,
+            metadata=response_metadata,
         )

ripperdoc/core/providers/base.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import random
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import (
     Any,
     AsyncIterable,
@@ -35,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):
@@ -53,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."""
 
@@ -170,6 +194,7 @@ def _retry_delay_seconds(attempt: int, base_delay: float = 0.5, max_delay: float
     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]:
@@ -194,7 +219,9 @@ async def iter_with_timeout(
         iterator = iter(stream)
         while True:
             try:
-                next_item = await asyncio.wait_for(asyncio.to_thread(next, iterator), timeout=timeout)
+                next_item = await asyncio.wait_for(
+                    asyncio.to_thread(next, iterator), timeout=timeout
+                )
             except StopIteration:
                 break
             yield next_item
@@ -228,9 +255,11 @@ async def call_with_timeout_and_retries(
                 },
             )
             await asyncio.sleep(delay_seconds)
-        except Exception:
+        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
+            raise exc
     if last_error:
         raise RuntimeError(f"Request timed out after {attempts} attempts") from last_error
     raise RuntimeError("Unexpected error executing request with retries")

ripperdoc/core/providers/gemini.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
+import asyncio
 import copy
 import inspect
 import os
 import time
-from typing import Any, AsyncIterable, AsyncIterator, Dict, List, Optional, Tuple, cast
+from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, cast
 from uuid import uuid4
 
 from ripperdoc.core.config import ModelProfile
@@ -27,13 +28,55 @@ logger = get_logger()
 
 # Constants
 GEMINI_SDK_IMPORT_ERROR = (
-    "Gemini client requires the 'google-genai' package. "
-    "Install it with: pip install google-genai"
+    "Gemini client requires the 'google-genai' package. Install it with: pip install google-genai"
 )
 GEMINI_MODELS_ENDPOINT_ERROR = "Gemini client is missing 'models' endpoint"
 GEMINI_GENERATE_CONTENT_ERROR = "Gemini client is missing generate_content() method"
 
 
+def _classify_gemini_error(exc: Exception) -> tuple[str, str]:
+    """Classify a Gemini exception into error code and user-friendly message."""
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    # Try to import Google's exception types for more specific handling
+    try:
+        from google.api_core import exceptions as google_exceptions  # type: ignore
+
+        if isinstance(exc, google_exceptions.Unauthenticated):
+            return "authentication_error", f"Authentication failed: {exc_msg}"
+        if isinstance(exc, google_exceptions.PermissionDenied):
+            return "permission_denied", f"Permission denied: {exc_msg}"
+        if isinstance(exc, google_exceptions.NotFound):
+            return "model_not_found", f"Model not found: {exc_msg}"
+        if isinstance(exc, google_exceptions.InvalidArgument):
+            if "context" in exc_msg.lower() or "token" in exc_msg.lower():
+                return "context_length_exceeded", f"Context length exceeded: {exc_msg}"
+            return "bad_request", f"Invalid request: {exc_msg}"
+        if isinstance(exc, google_exceptions.ResourceExhausted):
+            return "rate_limit", f"Rate limit exceeded: {exc_msg}"
+        if isinstance(exc, google_exceptions.ServiceUnavailable):
+            return "service_unavailable", f"Service unavailable: {exc_msg}"
+        if isinstance(exc, google_exceptions.GoogleAPICallError):
+            return "api_error", f"API error: {exc_msg}"
+    except ImportError:
+        pass
+
+    # Fallback for generic exceptions
+    if isinstance(exc, asyncio.TimeoutError):
+        return "timeout", f"Request timed out: {exc_msg}"
+    if isinstance(exc, ConnectionError):
+        return "connection_error", f"Connection error: {exc_msg}"
+    if "quota" in exc_msg.lower() or "limit" in exc_msg.lower():
+        return "rate_limit", f"Rate limit exceeded: {exc_msg}"
+    if "auth" in exc_msg.lower() or "key" in exc_msg.lower():
+        return "authentication_error", f"Authentication error: {exc_msg}"
+    if "not found" in exc_msg.lower():
+        return "model_not_found", f"Model not found: {exc_msg}"
+
+    return "unknown_error", f"Unexpected error ({exc_type}): {exc_msg}"
+
+
 def _extract_usage_metadata(payload: Any) -> Dict[str, int]:
     """Best-effort token extraction from Gemini responses."""
     usage = getattr(payload, "usage_metadata", None) or getattr(payload, "usageMetadata", None)
@@ -49,9 +92,13 @@ def _extract_usage_metadata(payload: Any) -> Dict[str, int]:
         value = getattr(usage, key, 0)
         return int(value) if value else 0
 
+    thought_tokens = safe_get_int("thoughts_token_count")
+    candidate_tokens = safe_get_int("candidates_token_count")
+
     return {
-        "input_tokens": safe_get_int("prompt_token_count") + safe_get_int("cached_content_token_count"),
-        "output_tokens": safe_get_int("candidates_token_count"),
+        "input_tokens": safe_get_int("prompt_token_count")
+        + safe_get_int("cached_content_token_count"),
+        "output_tokens": candidate_tokens + thought_tokens,
         "cache_read_input_tokens": safe_get_int("cached_content_token_count"),
         "cache_creation_input_tokens": 0,
     }
@@ -72,8 +119,10 @@ def _collect_parts(candidate: Any) -> List[Any]:
 def _collect_text_from_parts(parts: List[Any]) -> str:
     texts: List[str] = []
     for part in parts:
-        text_val = getattr(part, "text", None) or getattr(part, "content", None) or getattr(
-            part, "raw_text", None
+        text_val = (
+            getattr(part, "text", None)
+            or getattr(part, "content", None)
+            or getattr(part, "raw_text", None)
         )
         if isinstance(text_val, str):
             texts.append(text_val)
@@ -143,27 +192,64 @@ def _supports_stream_arg(fn: Any) -> bool:
     return False
 
 
+def _build_thinking_config(max_thinking_tokens: int, model_name: str) -> Dict[str, Any]:
+    """Map max_thinking_tokens to Gemini thinking_config settings."""
+    if max_thinking_tokens <= 0:
+        return {}
+    name = (model_name or "").lower()
+    config: Dict[str, Any] = {"include_thoughts": True}
+    if "gemini-3" in name:
+        config["thinking_level"] = "low" if max_thinking_tokens <= 2048 else "high"
+    else:
+        config["thinking_budget"] = max_thinking_tokens
+    return config
+
+
+def _collect_thoughts_from_parts(parts: List[Any]) -> List[str]:
+    """Extract thought summaries from parts flagged as thoughts."""
+    snippets: List[str] = []
+    for part in parts:
+        is_thought = getattr(part, "thought", None)
+        if is_thought is None and isinstance(part, dict):
+            is_thought = part.get("thought")
+        if not is_thought:
+            continue
+        text_val = (
+            getattr(part, "text", None)
+            or getattr(part, "content", None)
+            or getattr(part, "raw_text", None)
+        )
+        if isinstance(text_val, str):
+            snippets.append(text_val)
+    return snippets
+
+
 async def _async_build_tool_declarations(tools: List[Tool[Any, Any]]) -> List[Dict[str, Any]]:
     declarations: List[Dict[str, Any]] = []
     try:
         from google.genai import types as genai_types  # type: ignore
-    except Exception:  # pragma: no cover - fallback when SDK not installed
-        genai_types = None
+    except (ImportError, ModuleNotFoundError):  # pragma: no cover - fallback when SDK not installed
+        genai_types = None  # type: ignore[assignment]
 
     for tool in tools:
         description = await build_tool_description(tool, include_examples=True, max_examples=2)
         parameters_schema = _flatten_schema(tool.input_schema.model_json_schema())
         if genai_types:
+            func_decl = genai_types.FunctionDeclaration(
+                name=tool.name,
+                description=description,
+                parameters_json_schema=parameters_schema,
+            )
             declarations.append(
-                genai_types.FunctionDeclaration(
-                    name=tool.name,
-                    description=description,
-                    parameters=genai_types.Schema(**parameters_schema),
-                )
+                func_decl.model_dump(mode="json", exclude_none=True)
             )
         else:
             declarations.append(
-                {"name": tool.name, "description": description, "parameters": parameters_schema}
+                {
+                    "name": tool.name,
+                    "description": description,
+                    "parameters_json_schema": parameters_schema,
+                }
             )
     return declarations
 
@@ -183,8 +269,8 @@ def _convert_messages_to_genai_contents(
     # Lazy import to avoid hard dependency in tests.
     try:
         from google.genai import types as genai_types  # type: ignore
-    except Exception:  # pragma: no cover - fallback when SDK not installed
-        genai_types = None
+    except (ImportError, ModuleNotFoundError):  # pragma: no cover - fallback when SDK not installed
+        genai_types = None  # type: ignore[assignment]
 
     def _mk_part_from_text(text: str) -> Any:
         if genai_types:
@@ -268,19 +354,19 @@ class GeminiClient(ProviderClient):
 
         try:
             from google import genai  # type: ignore
-        except Exception as exc:  # pragma: no cover - import guard
+        except (ImportError, ModuleNotFoundError) as exc:  # pragma: no cover - import guard
             raise RuntimeError(GEMINI_SDK_IMPORT_ERROR) from exc
 
         client_kwargs: Dict[str, Any] = {}
-        api_key = model_profile.api_key or os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+        api_key = (
+            model_profile.api_key or os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+        )
         if api_key:
             client_kwargs["api_key"] = api_key
         if model_profile.api_base:
             from google.genai import types as genai_types  # type: ignore
 
-            client_kwargs["http_options"] = genai_types.HttpOptions(
-                base_url=model_profile.api_base
-            )
+            client_kwargs["http_options"] = genai_types.HttpOptions(base_url=model_profile.api_base)
         return genai.Client(**client_kwargs)
 
     async def call(
@@ -295,19 +381,30 @@ class GeminiClient(ProviderClient):
         progress_callback: Optional[ProgressCallback],
         request_timeout: Optional[float],
         max_retries: int,
+        max_thinking_tokens: int,
     ) -> ProviderResponse:
         start_time = time.time()
 
         try:
             client = await self._client(model_profile)
+        except asyncio.CancelledError:
+            raise  # Don't suppress task cancellation
         except Exception as exc:
-            msg = str(exc)
-            logger.warning("[gemini_client] Initialization failed", extra={"error": msg})
-            return ProviderResponse(
-                content_blocks=[{"type": "text", "text": msg}],
-                usage_tokens={},
-                cost_usd=0.0,
-                duration_ms=(time.time() - start_time) * 1000,
+            duration_ms = (time.time() - start_time) * 1000
+            error_code, error_message = _classify_gemini_error(exc)
+            logger.error(
+                "[gemini_client] Initialization failed",
+                extra={
+                    "model": model_profile.model,
+                    "error_code": error_code,
+                    "error_message": error_message,
+                    "duration_ms": round(duration_ms, 2),
+                },
+            )
+            return ProviderResponse.create_error(
+                error_code=error_code,
+                error_message=error_message,
+                duration_ms=duration_ms,
             )
 
         declarations: List[Dict[str, Any]] = []
@@ -319,13 +416,16 @@ class GeminiClient(ProviderClient):
         config: Dict[str, Any] = {"system_instruction": system_prompt}
         if model_profile.max_tokens:
             config["max_output_tokens"] = model_profile.max_tokens
-        if declarations:
+        thinking_config = _build_thinking_config(max_thinking_tokens, model_profile.model)
+        if thinking_config:
             try:
                 from google.genai import types as genai_types  # type: ignore
 
-                config["tools"] = [genai_types.Tool(function_declarations=declarations)]
-            except Exception:  # pragma: no cover - fallback when SDK not installed
-                config["tools"] = [{"function_declarations": declarations}]
+                config["thinking_config"] = genai_types.ThinkingConfig(**thinking_config)
+            except (ImportError, ModuleNotFoundError, TypeError, ValueError):  # pragma: no cover - fallback when SDK not installed
+                config["thinking_config"] = thinking_config
+        if declarations:
+            config["tools"] = [{"function_declarations": declarations}]
 
         generate_kwargs: Dict[str, Any] = {
             "model": model_profile.model,
@@ -335,6 +435,8 @@ class GeminiClient(ProviderClient):
         usage_tokens: Dict[str, int] = {}
         collected_text: List[str] = []
         function_calls: List[Dict[str, Any]] = []
+        reasoning_parts: List[str] = []
+        response_metadata: Dict[str, Any] = {}
 
         async def _call_generate(streaming: bool) -> Any:
             models_api = getattr(client, "models", None) or getattr(
@@ -379,11 +481,6 @@ class GeminiClient(ProviderClient):
             if generate_fn is None:
                 raise RuntimeError(GEMINI_GENERATE_CONTENT_ERROR)
 
-                result = generate_fn(**generate_kwargs)
-                if inspect.isawaitable(result):
-                    return await result
-                return result
-
         try:
             if stream:
                 stream_resp = await _call_generate(streaming=True)
@@ -393,12 +490,14 @@ class GeminiClient(ProviderClient):
                 def _to_async_iter(obj: Any) -> AsyncIterator[Any]:
                     """Convert various iterable types to async generator."""
                     if inspect.isasyncgen(obj) or hasattr(obj, "__aiter__"):
+
                         async def _wrap_async() -> AsyncIterator[Any]:
                             async for item in obj:
                                 yield item
 
                         return _wrap_async()
                     if hasattr(obj, "__iter__"):
+
                         async def _wrap_sync() -> AsyncIterator[Any]:
                             for item in obj:
                                 yield item
@@ -416,14 +515,19 @@ class GeminiClient(ProviderClient):
                     candidates = getattr(chunk, "candidates", None) or []
                     for candidate in candidates:
                         parts = _collect_parts(candidate)
+                        text_chunk = _collect_text_from_parts(parts)
                         if progress_callback:
-                            text_delta = _collect_text_from_parts(parts)
-                            if text_delta:
+                            if text_chunk:
                                 try:
-                                    await progress_callback(text_delta)
-                                except Exception:
-                                    logger.exception("[gemini_client] Stream callback failed")
-                        collected_text.append(_collect_text_from_parts(parts))
+                                    await progress_callback(text_chunk)
+                                except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
+                                    logger.warning(
+                                        "[gemini_client] Stream callback failed: %s: %s",
+                                        type(cb_exc).__name__, cb_exc,
+                                    )
+                        if text_chunk:
+                            collected_text.append(text_chunk)
+                        reasoning_parts.extend(_collect_thoughts_from_parts(parts))
                         function_calls.extend(_extract_function_calls(parts))
                     usage_tokens = _extract_usage_metadata(chunk) or usage_tokens
             else:
@@ -437,24 +541,38 @@ class GeminiClient(ProviderClient):
                 if candidates:
                     parts = _collect_parts(candidates[0])
                     collected_text.append(_collect_text_from_parts(parts))
+                    reasoning_parts.extend(_collect_thoughts_from_parts(parts))
                     function_calls.extend(_extract_function_calls(parts))
                 else:
                     # Fallback: try to read text directly
                     collected_text.append(getattr(response, "text", "") or "")
                 usage_tokens = _extract_usage_metadata(response)
+        except asyncio.CancelledError:
+            raise  # Don't suppress task cancellation
         except Exception as exc:
-            logger.exception("[gemini_client] Error during call", extra={"error": str(exc)})
-            return ProviderResponse(
-                content_blocks=[{"type": "text", "text": f"Gemini call failed: {exc}"}],
-                usage_tokens={},
-                cost_usd=0.0,
-                duration_ms=(time.time() - start_time) * 1000,
+            duration_ms = (time.time() - start_time) * 1000
+            error_code, error_message = _classify_gemini_error(exc)
+            logger.error(
+                "[gemini_client] API call failed",
+                extra={
+                    "model": model_profile.model,
+                    "error_code": error_code,
+                    "error_message": error_message,
+                    "duration_ms": round(duration_ms, 2),
+                },
+            )
+            return ProviderResponse.create_error(
+                error_code=error_code,
+                error_message=error_message,
+                duration_ms=duration_ms,
             )
 
         content_blocks: List[Dict[str, Any]] = []
         combined_text = "".join(collected_text).strip()
         if combined_text:
             content_blocks.append({"type": "text", "text": combined_text})
+        if reasoning_parts:
+            response_metadata["reasoning_content"] = "".join(reasoning_parts)
 
         for call in function_calls:
             if not call.get("name"):
@@ -493,4 +611,5 @@ class GeminiClient(ProviderClient):
             usage_tokens=usage_tokens,
             cost_usd=cost_usd,
             duration_ms=duration_ms,
+            metadata=response_metadata,
         )