ripperdoc 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

ripperdoc/core/providers/gemini.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import inspect
+import json
 import os
 import time
 from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, cast
@@ -240,9 +241,7 @@ async def _async_build_tool_declarations(tools: List[Tool[Any, Any]]) -> List[Di
                 description=description,
                 parameters_json_schema=parameters_schema,
             )
-            declarations.append(
-                func_decl.model_dump(mode="json", exclude_none=True)
-            )
+            declarations.append(func_decl.model_dump(mode="json", exclude_none=True))
         else:
             declarations.append(
                 {
@@ -385,6 +384,17 @@ class GeminiClient(ProviderClient):
     ) -> ProviderResponse:
         start_time = time.time()
 
+        logger.debug(
+            "[gemini_client] Preparing request",
+            extra={
+                "model": model_profile.model,
+                "tool_mode": tool_mode,
+                "stream": stream,
+                "max_thinking_tokens": max_thinking_tokens,
+                "num_tools": len(tools),
+            },
+        )
+
         try:
             client = await self._client(model_profile)
         except asyncio.CancelledError:
@@ -392,6 +402,15 @@ class GeminiClient(ProviderClient):
         except Exception as exc:
             duration_ms = (time.time() - start_time) * 1000
             error_code, error_message = _classify_gemini_error(exc)
+            logger.debug(
+                "[gemini_client] Exception details during init",
+                extra={
+                    "model": model_profile.model,
+                    "exception_type": type(exc).__name__,
+                    "exception_str": str(exc),
+                    "error_code": error_code,
+                },
+            )
             logger.error(
                 "[gemini_client] Initialization failed",
                 extra={
@@ -422,7 +441,12 @@ class GeminiClient(ProviderClient):
                 from google.genai import types as genai_types  # type: ignore
 
                 config["thinking_config"] = genai_types.ThinkingConfig(**thinking_config)
-            except (ImportError, ModuleNotFoundError, TypeError, ValueError):  # pragma: no cover - fallback when SDK not installed
+            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}]
@@ -432,6 +456,23 @@ class GeminiClient(ProviderClient):
             "contents": contents,
             "config": config,
         }
+
+        logger.debug(
+            "[gemini_client] Request parameters",
+            extra={
+                "model": model_profile.model,
+                "config": json.dumps(
+                    {k: v for k, v in config.items() if k != "system_instruction"},
+                    ensure_ascii=False,
+                    default=str,
+                )[:1000],
+                "num_declarations": len(declarations),
+                "thinking_config": json.dumps(thinking_config, ensure_ascii=False)
+                if thinking_config
+                else None,
+            },
+        )
+
         usage_tokens: Dict[str, int] = {}
         collected_text: List[str] = []
         function_calls: List[Dict[str, Any]] = []
@@ -483,6 +524,10 @@ class GeminiClient(ProviderClient):
 
         try:
             if stream:
+                logger.debug(
+                    "[gemini_client] Initiating stream request",
+                    extra={"model": model_profile.model},
+                )
                 stream_resp = await _call_generate(streaming=True)
 
                 # Normalize streams into an async iterator to avoid StopIteration surfacing through
@@ -523,7 +568,8 @@ class GeminiClient(ProviderClient):
                                 except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                                     logger.warning(
                                         "[gemini_client] Stream callback failed: %s: %s",
-                                        type(cb_exc).__name__, cb_exc,
+                                        type(cb_exc).__name__,
+                                        cb_exc,
                                     )
                         if text_chunk:
                             collected_text.append(text_chunk)
@@ -552,6 +598,15 @@ class GeminiClient(ProviderClient):
         except Exception as exc:
             duration_ms = (time.time() - start_time) * 1000
             error_code, error_message = _classify_gemini_error(exc)
+            logger.debug(
+                "[gemini_client] Exception details",
+                extra={
+                    "model": model_profile.model,
+                    "exception_type": type(exc).__name__,
+                    "exception_str": str(exc),
+                    "error_code": error_code,
+                },
+            )
             logger.error(
                 "[gemini_client] API call failed",
                 extra={
@@ -595,6 +650,16 @@ class GeminiClient(ProviderClient):
             **(usage_tokens or {}),
         )
 
+        logger.debug(
+            "[gemini_client] Response content blocks",
+            extra={
+                "model": model_profile.model,
+                "content_blocks": json.dumps(content_blocks, ensure_ascii=False)[:1000],
+                "usage_tokens": json.dumps(usage_tokens, ensure_ascii=False),
+                "metadata": json.dumps(response_metadata, ensure_ascii=False)[:500],
+            },
+        )
+
         logger.info(
             "[gemini_client] Response received",
             extra={

ripperdoc/core/providers/openai.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import time
 from typing import Any, Dict, List, Optional, cast
 from uuid import uuid4
@@ -94,7 +95,7 @@ def _detect_openai_vendor(model_profile: ModelProfile) -> str:
     if "generativelanguage.googleapis.com" in base or name.startswith("gemini"):
         return "gemini_openai"
     if "gpt-5" in name:
-        return "openai_reasoning"
+        return "openai"
     return "openai"
 
 
@@ -130,7 +131,7 @@ def _build_thinking_kwargs(
         if effort:
             top_level["reasoning_effort"] = effort
             extra_body.setdefault("reasoning", {"effort": effort})
-    elif vendor == "openai_reasoning":
+    elif vendor == "openai":
         if effort:
             extra_body["reasoning"] = {"effort": effort}
     else:
@@ -178,6 +179,15 @@ class OpenAIClient(ProviderClient):
         except Exception as exc:
             duration_ms = (time.time() - start_time) * 1000
             error_code, error_message = _classify_openai_error(exc)
+            logger.debug(
+                "[openai_client] Exception details",
+                extra={
+                    "model": model_profile.model,
+                    "exception_type": type(exc).__name__,
+                    "exception_str": str(exc),
+                    "error_code": error_code,
+                },
+            )
             logger.error(
                 "[openai_client] API call failed",
                 extra={
@@ -213,6 +223,18 @@ class OpenAIClient(ProviderClient):
         openai_messages: List[Dict[str, object]] = [
             {"role": "system", "content": system_prompt}
         ] + sanitize_tool_history(list(normalized_messages))
+
+        logger.debug(
+            "[openai_client] Preparing request",
+            extra={
+                "model": model_profile.model,
+                "tool_mode": tool_mode,
+                "stream": stream,
+                "max_thinking_tokens": max_thinking_tokens,
+                "num_tools": len(openai_tools),
+                "num_messages": len(openai_messages),
+            },
+        )
         collected_text: List[str] = []
         streamed_tool_calls: Dict[int, Dict[str, Optional[str]]] = {}
         streamed_tool_text: List[str] = []
@@ -228,6 +250,16 @@ class OpenAIClient(ProviderClient):
             model_profile, max_thinking_tokens
         )
 
+        logger.debug(
+            "[openai_client] Request parameters",
+            extra={
+                "model": model_profile.model,
+                "thinking_extra_body": json.dumps(thinking_extra_body, ensure_ascii=False),
+                "thinking_top_level": json.dumps(thinking_top_level, ensure_ascii=False),
+                "messages_preview": json.dumps(openai_messages[:2], ensure_ascii=False)[:500],
+            },
+        )
+
         async with AsyncOpenAI(
             api_key=model_profile.api_key, base_url=model_profile.api_base
         ) as client:
@@ -246,6 +278,16 @@ class OpenAIClient(ProviderClient):
                 }
                 if thinking_extra_body:
                     stream_kwargs["extra_body"] = thinking_extra_body
+                logger.debug(
+                    "[openai_client] Initiating stream request",
+                    extra={
+                        "model": model_profile.model,
+                        "stream_kwargs": json.dumps(
+                            {k: v for k, v in stream_kwargs.items() if k != "messages"},
+                            ensure_ascii=False,
+                        ),
+                    },
+                )
                 stream_coro = client.chat.completions.create(  # type: ignore[call-overload]
                     **stream_kwargs
                 )
@@ -258,9 +300,10 @@ class OpenAIClient(ProviderClient):
                     if getattr(chunk, "usage", None):
                         streamed_usage.update(openai_usage_tokens(chunk.usage))
 
-                    if not getattr(chunk, "choices", None):
+                    choices = getattr(chunk, "choices", None)
+                    if not choices or len(choices) == 0:
                         continue
-                    delta = getattr(chunk.choices[0], "delta", None)
+                    delta = getattr(choices[0], "delta", None)
                     if not delta:
                         continue
 
@@ -303,7 +346,8 @@ class OpenAIClient(ProviderClient):
                             except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                                 logger.warning(
                                     "[openai_client] Stream callback failed: %s: %s",
-                                    type(cb_exc).__name__, cb_exc,
+                                    type(cb_exc).__name__,
+                                    cb_exc,
                                 )
 
                     # Tool call deltas for native tool mode
@@ -333,7 +377,8 @@ class OpenAIClient(ProviderClient):
                                     except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                                         logger.warning(
                                             "[openai_client] Stream callback failed: %s: %s",
-                                            type(cb_exc).__name__, cb_exc,
+                                            type(cb_exc).__name__,
+                                            cb_exc,
                                         )
 
                         if idx not in announced_tool_indexes and state.get("name"):
@@ -344,7 +389,8 @@ class OpenAIClient(ProviderClient):
                                 except (RuntimeError, ValueError, TypeError, OSError) as cb_exc:
                                     logger.warning(
                                         "[openai_client] Stream callback failed: %s: %s",
-                                        type(cb_exc).__name__, cb_exc,
+                                        type(cb_exc).__name__,
+                                        cb_exc,
                                     )
 
                         streamed_tool_calls[idx] = state
@@ -441,23 +487,32 @@ class OpenAIClient(ProviderClient):
                 )
             finish_reason = "stream"
         else:
-            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
+            response_choices = getattr(openai_response, "choices", None)
+            if not response_choices or len(response_choices) == 0:
+                logger.warning(
+                    "[openai_client] Empty choices in response",
+                    extra={"model": model_profile.model},
+                )
+                content_blocks = [{"type": "text", "text": ""}]
+                finish_reason = "error"
+            else:
+                choice = 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:
@@ -467,6 +522,16 @@ class OpenAIClient(ProviderClient):
             if stream_reasoning_details:
                 response_metadata["reasoning_details"] = stream_reasoning_details
 
+        logger.debug(
+            "[openai_client] Response content blocks",
+            extra={
+                "model": model_profile.model,
+                "content_blocks": json.dumps(content_blocks, ensure_ascii=False)[:1000],
+                "usage_tokens": json.dumps(usage_tokens, ensure_ascii=False),
+                "metadata": json.dumps(response_metadata, ensure_ascii=False)[:500],
+            },
+        )
+
         logger.info(
             "[openai_client] Response received",
             extra={