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

ripperdoc/core/providers/openai.py

@@ -7,6 +7,7 @@ import time
 from typing import Any, Dict, List, Optional, cast
 from uuid import uuid4
 
+import openai
 from openai import AsyncOpenAI
 
 from ripperdoc.core.config import ModelProfile
@@ -32,6 +33,113 @@ from ripperdoc.utils.session_usage import record_usage
 logger = get_logger()
 
 
+def _classify_openai_error(exc: Exception) -> tuple[str, str]:
+    """Classify an OpenAI exception into error code and user-friendly message."""
+    exc_type = type(exc).__name__
+    exc_msg = str(exc)
+
+    if isinstance(exc, openai.AuthenticationError):
+        return "authentication_error", f"Authentication failed: {exc_msg}"
+    if isinstance(exc, openai.PermissionDeniedError):
+        # Check for common permission denied reasons
+        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, openai.NotFoundError):
+        return "model_not_found", f"Model not found: {exc_msg}"
+    if isinstance(exc, openai.BadRequestError):
+        # Check for context length errors
+        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, openai.RateLimitError):
+        return "rate_limit", f"Rate limit exceeded: {exc_msg}"
+    if isinstance(exc, openai.APIConnectionError):
+        return "connection_error", f"Connection error: {exc_msg}"
+    if isinstance(exc, openai.APIStatusError):
+        return "api_error", f"API error ({exc.status_code}): {exc_msg}"
+    if isinstance(exc, asyncio.TimeoutError):
+        return "timeout", f"Request timed out: {exc_msg}"
+
+    # Generic fallback
+    return "unknown_error", f"Unexpected error ({exc_type}): {exc_msg}"
+
+
+def _effort_from_tokens(max_thinking_tokens: int) -> Optional[str]:
+    """Map a thinking token budget to a coarse effort label."""
+    if max_thinking_tokens <= 0:
+        return None
+    if max_thinking_tokens <= 1024:
+        return "low"
+    if max_thinking_tokens <= 8192:
+        return "medium"
+    return "high"
+
+
+def _detect_openai_vendor(model_profile: ModelProfile) -> str:
+    """Best-effort vendor hint for OpenAI-compatible endpoints."""
+    override = getattr(model_profile, "thinking_mode", None)
+    if isinstance(override, str) and override.strip():
+        return override.strip().lower()
+    base = (model_profile.api_base or "").lower()
+    name = (model_profile.model or "").lower()
+    if "openrouter.ai" in base:
+        return "openrouter"
+    if "deepseek" in base or name.startswith("deepseek"):
+        return "deepseek"
+    if "dashscope" in base or "qwen" in name:
+        return "qwen"
+    if "generativelanguage.googleapis.com" in base or name.startswith("gemini"):
+        return "gemini_openai"
+    if "gpt-5" in name:
+        return "openai_reasoning"
+    return "openai"
+
+
+def _build_thinking_kwargs(
+    model_profile: ModelProfile, max_thinking_tokens: int
+) -> tuple[Dict[str, Any], Dict[str, Any]]:
+    """Return (extra_body, top_level_kwargs) for thinking-enabled calls."""
+    extra_body: Dict[str, Any] = {}
+    top_level: Dict[str, Any] = {}
+    vendor = _detect_openai_vendor(model_profile)
+    effort = _effort_from_tokens(max_thinking_tokens)
+
+    if vendor == "deepseek":
+        if max_thinking_tokens != 0:
+            extra_body["thinking"] = {"type": "enabled"}
+    elif vendor == "qwen":
+        if max_thinking_tokens > 0:
+            extra_body["enable_thinking"] = True
+        elif max_thinking_tokens == 0:
+            extra_body["enable_thinking"] = False
+    elif vendor == "openrouter":
+        if max_thinking_tokens > 0:
+            extra_body["reasoning"] = {"max_tokens": max_thinking_tokens}
+        elif max_thinking_tokens == 0:
+            extra_body["reasoning"] = {"effort": "none"}
+    elif vendor == "gemini_openai":
+        google_cfg: Dict[str, Any] = {}
+        if max_thinking_tokens > 0:
+            google_cfg["thinking_budget"] = max_thinking_tokens
+            google_cfg["include_thoughts"] = True
+        if google_cfg:
+            extra_body["google"] = {"thinking_config": google_cfg}
+        if effort:
+            top_level["reasoning_effort"] = effort
+            extra_body.setdefault("reasoning", {"effort": effort})
+    elif vendor == "openai_reasoning":
+        if effort:
+            extra_body["reasoning"] = {"effort": effort}
+    else:
+        if effort:
+            extra_body["reasoning"] = {"effort": effort}
+
+    return extra_body, top_level
+
+
 class OpenAIClient(ProviderClient):
     """OpenAI-compatible client with streaming and non-streaming support."""
 
@@ -47,8 +155,60 @@ class OpenAIClient(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_openai_error(exc)
+            logger.error(
+                "[openai_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: List[Dict[str, 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."""
         openai_tools = await build_openai_tool_schemas(tools)
         openai_messages: List[Dict[str, object]] = [
             {"role": "system", "content": system_prompt}
@@ -57,10 +217,16 @@ class OpenAIClient(ProviderClient):
         streamed_tool_calls: Dict[int, Dict[str, Optional[str]]] = {}
         streamed_tool_text: List[str] = []
         streamed_usage: Dict[str, int] = {}
+        stream_reasoning_text: List[str] = []
+        stream_reasoning_details: List[Any] = []
+        response_metadata: Dict[str, Any] = {}
 
         can_stream_text = stream and tool_mode == "text" and not openai_tools
         can_stream_tools = stream and tool_mode != "text" and bool(openai_tools)
         can_stream = can_stream_text or can_stream_tools
+        thinking_extra_body, thinking_top_level = _build_thinking_kwargs(
+            model_profile, max_thinking_tokens
+        )
 
         async with AsyncOpenAI(
             api_key=model_profile.api_key, base_url=model_profile.api_base
@@ -68,14 +234,20 @@ class OpenAIClient(ProviderClient):
 
             async def _stream_request() -> Dict[str, Dict[str, int]]:
                 announced_tool_indexes: set[int] = set()
+                stream_kwargs: Dict[str, Any] = {
+                    "model": model_profile.model,
+                    "messages": cast(Any, openai_messages),
+                    "tools": openai_tools if openai_tools else None,
+                    "temperature": model_profile.temperature,
+                    "max_tokens": model_profile.max_tokens,
+                    "stream": True,
+                    "stream_options": {"include_usage": True},
+                    **thinking_top_level,
+                }
+                if thinking_extra_body:
+                    stream_kwargs["extra_body"] = thinking_extra_body
                 stream_coro = client.chat.completions.create(  # type: ignore[call-overload]
-                    model=model_profile.model,
-                    messages=cast(Any, openai_messages),
-                    tools=openai_tools if can_stream_tools else None,
-                    temperature=model_profile.temperature,
-                    max_tokens=model_profile.max_tokens,
-                    stream=True,
-                    stream_options={"include_usage": True},
+                    **stream_kwargs
                 )
                 stream_resp = (
                     await asyncio.wait_for(stream_coro, timeout=request_timeout)
@@ -105,14 +277,34 @@ class OpenAIClient(ProviderClient):
                                     text_delta += text_val
                         elif isinstance(delta_content, str):
                             text_delta += delta_content
+                    delta_reasoning = getattr(delta, "reasoning_content", None) or getattr(
+                        delta, "reasoning", None
+                    )
+                    if isinstance(delta_reasoning, str):
+                        stream_reasoning_text.append(delta_reasoning)
+                    elif isinstance(delta_reasoning, list):
+                        for item in delta_reasoning:
+                            if isinstance(item, str):
+                                stream_reasoning_text.append(item)
+                    delta_reasoning_details = getattr(delta, "reasoning_details", None)
+                    if delta_reasoning_details:
+                        if isinstance(delta_reasoning_details, list):
+                            stream_reasoning_details.extend(delta_reasoning_details)
+                        else:
+                            stream_reasoning_details.append(delta_reasoning_details)
                     if text_delta:
-                        target_collector = streamed_tool_text if can_stream_tools else collected_text
+                        target_collector = (
+                            streamed_tool_text if can_stream_tools else collected_text
+                        )
                         target_collector.append(text_delta)
                         if progress_callback:
                             try:
                                 await progress_callback(text_delta)
-                            except Exception:
-                                logger.exception("[openai_client] Stream callback failed")
+                            except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
+                                logger.warning(
+                                    "[openai_client] Stream callback failed: %s: %s",
+                                    type(cb_exc).__name__, cb_exc,
+                                )
 
                     # Tool call deltas for native tool mode
                     if not can_stream_tools:
@@ -120,7 +312,9 @@ class OpenAIClient(ProviderClient):
 
                     for tool_delta in getattr(delta, "tool_calls", []) or []:
                         idx = getattr(tool_delta, "index", 0) or 0
-                        state = streamed_tool_calls.get(idx, {"id": None, "name": None, "arguments": ""})
+                        state = streamed_tool_calls.get(
+                            idx, {"id": None, "name": None, "arguments": ""}
+                        )
 
                         if getattr(tool_delta, "id", None):
                             state["id"] = tool_delta.id
@@ -136,28 +330,40 @@ class OpenAIClient(ProviderClient):
                                 if progress_callback:
                                     try:
                                         await progress_callback(args_delta)
-                                    except Exception:
-                                        logger.exception("[openai_client] Stream callback failed")
+                                    except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
+                                        logger.warning(
+                                            "[openai_client] Stream callback failed: %s: %s",
+                                            type(cb_exc).__name__, cb_exc,
+                                        )
 
                         if idx not in announced_tool_indexes and state.get("name"):
                             announced_tool_indexes.add(idx)
                             if progress_callback:
                                 try:
                                     await progress_callback(f"[tool:{state['name']}]")
-                                except Exception:
-                                    logger.exception("[openai_client] Stream callback failed")
+                                except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
+                                    logger.warning(
+                                        "[openai_client] Stream callback failed: %s: %s",
+                                        type(cb_exc).__name__, cb_exc,
+                                    )
 
                         streamed_tool_calls[idx] = state
 
                 return {"usage": streamed_usage}
 
             async def _non_stream_request() -> Any:
+                kwargs: Dict[str, Any] = {
+                    "model": model_profile.model,
+                    "messages": cast(Any, openai_messages),
+                    "tools": openai_tools if openai_tools else None,  # type: ignore[arg-type]
+                    "temperature": model_profile.temperature,
+                    "max_tokens": model_profile.max_tokens,
+                    **thinking_top_level,
+                }
+                if thinking_extra_body:
+                    kwargs["extra_body"] = thinking_extra_body
                 return await client.chat.completions.create(  # type: ignore[call-overload]
-                    model=model_profile.model,
-                    messages=cast(Any, openai_messages),
-                    tools=openai_tools if openai_tools else None,  # type: ignore[arg-type]
-                    temperature=model_profile.temperature,
-                    max_tokens=model_profile.max_tokens,
+                    **kwargs
                 )
 
             timeout_for_call = None if can_stream else request_timeout
@@ -185,15 +391,19 @@ class OpenAIClient(ProviderClient):
                 )
 
         duration_ms = (time.time() - start_time) * 1000
-        usage_tokens = streamed_usage if can_stream else openai_usage_tokens(
-            getattr(openai_response, "usage", None)
+        usage_tokens = (
+            streamed_usage
+            if can_stream
+            else openai_usage_tokens(getattr(openai_response, "usage", None))
         )
         cost_usd = estimate_cost_usd(model_profile, usage_tokens)
         record_usage(
             model_profile.model, duration_ms=duration_ms, cost_usd=cost_usd, **usage_tokens
         )
 
-        if not can_stream and (not openai_response or not getattr(openai_response, "choices", None)):
+        if not can_stream and (
+            not openai_response or not getattr(openai_response, "choices", None)
+        ):
             logger.warning(
                 "[openai_client] No choices returned from OpenAI response",
                 extra={"model": model_profile.model},
@@ -204,6 +414,7 @@ class OpenAIClient(ProviderClient):
                 usage_tokens=usage_tokens,
                 cost_usd=cost_usd,
                 duration_ms=duration_ms,
+                metadata=response_metadata,
             )
 
         content_blocks: List[Dict[str, Any]] = []
@@ -233,6 +444,28 @@ class OpenAIClient(ProviderClient):
             choice = openai_response.choices[0]
             content_blocks = content_blocks_from_openai_choice(choice, tool_mode)
             finish_reason = cast(Optional[str], getattr(choice, "finish_reason", None))
+            message_obj = getattr(choice, "message", None) or choice
+            reasoning_content = getattr(message_obj, "reasoning_content", None)
+            if reasoning_content:
+                response_metadata["reasoning_content"] = reasoning_content
+            reasoning_field = getattr(message_obj, "reasoning", None)
+            if reasoning_field:
+                response_metadata["reasoning"] = reasoning_field
+                if "reasoning_content" not in response_metadata and isinstance(
+                    reasoning_field, str
+                ):
+                    response_metadata["reasoning_content"] = reasoning_field
+            reasoning_details = getattr(message_obj, "reasoning_details", None)
+            if reasoning_details:
+                response_metadata["reasoning_details"] = reasoning_details
+
+        if can_stream:
+            if stream_reasoning_text:
+                joined = "".join(stream_reasoning_text)
+                response_metadata["reasoning_content"] = joined
+                response_metadata.setdefault("reasoning", joined)
+            if stream_reasoning_details:
+                response_metadata["reasoning_details"] = stream_reasoning_details
 
         logger.info(
             "[openai_client] Response received",
@@ -250,4 +483,5 @@ class OpenAIClient(ProviderClient):
             usage_tokens=usage_tokens,
             cost_usd=cost_usd,
             duration_ms=duration_ms,
+            metadata=response_metadata,
         )