ripperdoc 0.2.7__py3-none-any.whl → 0.2.9__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
                 )
@@ -303,7 +345,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 +376,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 +388,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
@@ -467,6 +512,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={

ripperdoc/core/query.py

@@ -26,9 +26,10 @@ from typing import (
 
 from pydantic import ValidationError
 
-from ripperdoc.core.config import provider_protocol
+from ripperdoc.core.config import ModelProfile, provider_protocol
 from ripperdoc.core.providers import ProviderClient, get_provider_client
 from ripperdoc.core.permissions import PermissionResult
+from ripperdoc.core.hooks.manager import hook_manager
 from ripperdoc.core.query_utils import (
     build_full_system_prompt,
     determine_tool_mode,
@@ -64,6 +65,42 @@ DEFAULT_REQUEST_TIMEOUT_SEC = float(os.getenv("RIPPERDOC_API_TIMEOUT", "120"))
 MAX_LLM_RETRIES = int(os.getenv("RIPPERDOC_MAX_RETRIES", "10"))
 
 
+def infer_thinking_mode(model_profile: ModelProfile) -> Optional[str]:
+    """Infer thinking mode from ModelProfile if not explicitly configured.
+
+    This function checks the model_profile.thinking_mode first. If it's set,
+    returns that value. Otherwise, auto-detects based on api_base and model name.
+
+    Args:
+        model_profile: The model profile to analyze
+
+    Returns:
+        Thinking mode string ("deepseek", "qwen", "openrouter", "gemini_openai")
+        or None if no thinking mode should be applied.
+    """
+    # Use explicit config if set
+    explicit_mode = model_profile.thinking_mode
+    if explicit_mode:
+        return explicit_mode
+
+    # Auto-detect based on API base and model name
+    base = (model_profile.api_base or "").lower()
+    name = (model_profile.model or "").lower()
+
+    if "deepseek" in base or name.startswith("deepseek"):
+        return "deepseek"
+    if "dashscope" in base or "qwen" in name:
+        return "qwen"
+    if "openrouter.ai" in base:
+        return "openrouter"
+    if "generativelanguage.googleapis.com" in base or name.startswith("gemini"):
+        return "gemini_openai"
+    if "openai" in base:
+        return "openai"
+
+    return None
+
+
 def _resolve_tool(
     tool_registry: "ToolRegistry", tool_name: str, tool_use_id: str
 ) -> tuple[Optional[Tool[Any, Any]], Optional[UserMessage]]:
@@ -109,7 +146,7 @@ async def _check_tool_permissions(
                 return bool(decision[0]), decision[1]
             return bool(decision), None
 
-        if query_context.safe_mode and tool.needs_permissions(parsed_input):
+        if not query_context.yolo_mode and tool.needs_permissions(parsed_input):
             loop = asyncio.get_running_loop()
             input_preview = (
                 parsed_input.model_dump()
@@ -154,6 +191,53 @@ async def _run_tool_use_generator(
     tool_context: ToolUseContext,
 ) -> AsyncGenerator[Union[UserMessage, ProgressMessage], None]:
     """Execute a single tool_use and yield progress/results."""
+    # Get tool input as dict for hooks
+    tool_input_dict = (
+        parsed_input.model_dump()
+        if hasattr(parsed_input, "model_dump")
+        else dict(parsed_input)
+        if isinstance(parsed_input, dict)
+        else {}
+    )
+
+    # Run PreToolUse hooks
+    pre_result = await hook_manager.run_pre_tool_use_async(
+        tool_name, tool_input_dict, tool_use_id=tool_use_id
+    )
+    if pre_result.should_block:
+        block_reason = pre_result.block_reason or f"Blocked by hook: {tool_name}"
+        logger.info(
+            f"[query] Tool {tool_name} blocked by PreToolUse hook",
+            extra={"tool_use_id": tool_use_id, "reason": block_reason},
+        )
+        yield tool_result_message(tool_use_id, f"Hook blocked: {block_reason}", is_error=True)
+        return
+
+    # Handle updated input from hooks
+    if pre_result.updated_input:
+        logger.debug(
+            f"[query] PreToolUse hook modified input for {tool_name}",
+            extra={"tool_use_id": tool_use_id},
+        )
+        # Re-parse the input with the updated values
+        try:
+            parsed_input = tool.input_schema(**pre_result.updated_input)
+            tool_input_dict = pre_result.updated_input
+        except (ValueError, TypeError) as exc:
+            logger.warning(
+                f"[query] Failed to apply updated input from hook: {exc}",
+                extra={"tool_use_id": tool_use_id},
+            )
+
+    # Add hook context if provided
+    if pre_result.additional_context:
+        logger.debug(
+            f"[query] PreToolUse hook added context for {tool_name}",
+            extra={"context": pre_result.additional_context[:100]},
+        )
+
+    tool_output = None
+
     try:
         async for output in tool.call(parsed_input, tool_context):
             if isinstance(output, ToolProgress):
@@ -164,6 +248,7 @@ async def _run_tool_use_generator(
                 )
                 logger.debug(f"[query] Progress from tool_use_id={tool_use_id}: {output.content}")
             elif isinstance(output, ToolResult):
+                tool_output = output.data
                 result_content = output.result_for_assistant or str(output.data)
                 result_msg = tool_result_message(
                     tool_use_id, result_content, tool_use_result=output.data
@@ -178,11 +263,18 @@ async def _run_tool_use_generator(
     except (RuntimeError, ValueError, TypeError, OSError, IOError, AttributeError, KeyError) as exc:
         logger.warning(
             "Error executing tool '%s': %s: %s",
-            tool_name, type(exc).__name__, exc,
+            tool_name,
+            type(exc).__name__,
+            exc,
             extra={"tool": tool_name, "tool_use_id": tool_use_id},
         )
         yield tool_result_message(tool_use_id, f"Error executing tool: {str(exc)}", is_error=True)
 
+    # Run PostToolUse hooks
+    await hook_manager.run_post_tool_use_async(
+        tool_name, tool_input_dict, tool_response=tool_output, tool_use_id=tool_use_id
+    )
+
 
 def _group_tool_calls_by_concurrency(prepared_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Group consecutive tool calls by their concurrency safety."""
@@ -267,7 +359,8 @@ async def _run_concurrent_tool_uses(
         except (RuntimeError, ValueError, TypeError) as exc:
             logger.warning(
                 "[query] Error while consuming tool generator: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
         finally:
             await queue.put(None)
@@ -320,7 +413,8 @@ class ToolRegistry:
             except (TypeError, AttributeError) as exc:
                 logger.warning(
                     "[tool_registry] Tool.defer_loading failed: %s: %s",
-                    type(exc).__name__, exc,
+                    type(exc).__name__,
+                    exc,
                     extra={"tool": getattr(tool, "name", None)},
                 )
                 deferred = False
@@ -407,7 +501,8 @@ def _apply_skill_context_updates(
             except (KeyError, ValueError, TypeError) as exc:
                 logger.warning(
                     "[query] Failed to activate tools listed in skill output: %s: %s",
-                    type(exc).__name__, exc,
+                    type(exc).__name__,
+                    exc,
                 )
 
         model_hint = data.get("model")
@@ -437,7 +532,7 @@ class QueryContext:
         self,
         tools: List[Tool[Any, Any]],
         max_thinking_tokens: int = 0,
-        safe_mode: bool = False,
+        yolo_mode: bool = False,
         model: str = "main",
         verbose: bool = False,
         pause_ui: Optional[Callable[[], None]] = None,
@@ -445,7 +540,7 @@ class QueryContext:
     ) -> None:
         self.tool_registry = ToolRegistry(tools)
         self.max_thinking_tokens = max_thinking_tokens
-        self.safe_mode = safe_mode
+        self.yolo_mode = yolo_mode
         self.model = model
         self.verbose = verbose
         self.abort_controller = asyncio.Event()
@@ -518,8 +613,22 @@ async def query_llm(
     else:
         messages_for_model = messages
 
+    # Get thinking_mode for provider-specific handling
+    # Apply when thinking is enabled (max_thinking_tokens > 0) OR when using a
+    # reasoning model like deepseek-reasoner which has thinking enabled by default
+    thinking_mode: Optional[str] = None
+    if protocol == "openai":
+        model_name = (model_profile.model or "").lower()
+        # DeepSeek Reasoner models have thinking enabled by default
+        is_reasoning_model = "reasoner" in model_name or "r1" in model_name
+        if max_thinking_tokens > 0 or is_reasoning_model:
+            thinking_mode = infer_thinking_mode(model_profile)
+
     normalized_messages: List[Dict[str, Any]] = normalize_messages_for_api(
-        messages_for_model, protocol=protocol, tool_mode=tool_mode
+        messages_for_model,
+        protocol=protocol,
+        tool_mode=tool_mode,
+        thinking_mode=thinking_mode,
     )
     logger.info(
         "[query_llm] Preparing model request",
@@ -530,6 +639,7 @@ async def query_llm(
             "normalized_messages": len(normalized_messages),
             "tool_count": len(tools),
             "max_thinking_tokens": max_thinking_tokens,
+            "thinking_mode": thinking_mode,
             "tool_mode": tool_mode,
         },
     )
@@ -613,7 +723,8 @@ async def query_llm(
         # Return error message
         logger.warning(
             "Error querying AI model: %s: %s",
-            type(e).__name__, e,
+            type(e).__name__,
+            e,
             extra={
                 "model": getattr(model_profile, "model", None),
                 "model_pointer": model,
@@ -624,12 +735,12 @@ async def query_llm(
         )
         duration_ms = (time.time() - start_time) * 1000
         context_error = detect_context_length_error(e)
-        metadata = None
+        error_metadata: Optional[Dict[str, Any]] = None
         content = f"Error querying AI model: {str(e)}"
 
         if context_error:
             content = f"The request exceeded the model's context window. {context_error.message}"
-            metadata = {
+            error_metadata = {
                 "context_length_exceeded": True,
                 "context_length_provider": context_error.provider,
                 "context_length_error_code": context_error.error_code,
@@ -645,7 +756,7 @@ async def query_llm(
             )
 
         error_msg = create_assistant_message(
-            content=content, duration_ms=duration_ms, metadata=metadata
+            content=content, duration_ms=duration_ms, metadata=error_metadata
         )
         error_msg.is_api_error_message = True
         return error_msg
@@ -704,9 +815,7 @@ async def _run_query_iteration(
 
     model_profile = resolve_model_profile(query_context.model)
     tool_mode = determine_tool_mode(model_profile)
-    tools_for_model: List[Tool[Any, Any]] = (
-        [] if tool_mode == "text" else query_context.all_tools()
-    )
+    tools_for_model: List[Tool[Any, Any]] = [] if tool_mode == "text" else query_context.all_tools()
 
     full_system_prompt = build_full_system_prompt(
         system_prompt, context, tool_mode, query_context.all_tools()
@@ -778,7 +887,7 @@ async def _run_query_iteration(
             done, pending = await asyncio.wait(
                 {assistant_task, waiter},
                 return_when=asyncio.FIRST_COMPLETED,
-                timeout=0.1  # Check abort_controller every 100ms
+                timeout=0.1,  # Check abort_controller every 100ms
             )
             if not done:
                 # Timeout - cancel waiter and continue loop to check abort_controller
@@ -836,8 +945,7 @@ async def _run_query_iteration(
     tool_results: List[UserMessage] = []
     permission_denied = False
     sibling_ids = set(
-        getattr(t, "tool_use_id", None) or getattr(t, "id", None) or ""
-        for t in tool_use_blocks
+        getattr(t, "tool_use_id", None) or getattr(t, "id", None) or "" for t in tool_use_blocks
     )
     prepared_calls: List[Dict[str, Any]] = []
 
@@ -845,18 +953,12 @@ async def _run_query_iteration(
         tool_name = tool_use.name
         if not tool_name:
             continue
-        tool_use_id = (
-            getattr(tool_use, "tool_use_id", None) or getattr(tool_use, "id", None) or ""
-        )
+        tool_use_id = getattr(tool_use, "tool_use_id", None) or getattr(tool_use, "id", None) or ""
         tool_input = getattr(tool_use, "input", {}) or {}
 
-        tool, missing_msg = _resolve_tool(
-            query_context.tool_registry, tool_name, tool_use_id
-        )
+        tool, missing_msg = _resolve_tool(query_context.tool_registry, tool_name, tool_use_id)
         if missing_msg:
-            logger.warning(
-                f"[query] Tool '{tool_name}' not found for tool_use_id={tool_use_id}"
-            )
+            logger.warning(f"[query] Tool '{tool_name}' not found for tool_use_id={tool_use_id}")
             tool_results.append(missing_msg)
             yield missing_msg
             continue
@@ -870,7 +972,7 @@ async def _run_query_iteration(
             )
 
             tool_context = ToolUseContext(
-                safe_mode=query_context.safe_mode,
+                yolo_mode=query_context.yolo_mode,
                 verbose=query_context.verbose,
                 permission_checker=can_use_tool_fn,
                 tool_registry=query_context.tool_registry,
@@ -883,8 +985,7 @@ async def _run_query_iteration(
             validation = await tool.validate_input(parsed_input, tool_context)
             if not validation.result:
                 logger.debug(
-                    f"[query] Validation failed for tool_use_id={tool_use_id}: "
-                    f"{validation.message}"
+                    f"[query] Validation failed for tool_use_id={tool_use_id}: {validation.message}"
                 )
                 result_msg = tool_result_message(
                     tool_use_id,
@@ -895,18 +996,15 @@ async def _run_query_iteration(
                 yield result_msg
                 continue
 
-            if query_context.safe_mode or can_use_tool_fn is not None:
+            if not query_context.yolo_mode or can_use_tool_fn is not None:
                 allowed, denial_message = await _check_tool_permissions(
                     tool, parsed_input, query_context, can_use_tool_fn
                 )
                 if not allowed:
                     logger.debug(
-                        f"[query] Permission denied for tool_use_id={tool_use_id}: "
-                        f"{denial_message}"
-                    )
-                    denial_text = (
-                        denial_message or f"User aborted the tool invocation: {tool_name}"
+                        f"[query] Permission denied for tool_use_id={tool_use_id}: {denial_message}"
                     )
+                    denial_text = denial_message or f"User aborted the tool invocation: {tool_name}"
                     denial_msg = tool_result_message(tool_use_id, denial_text, is_error=True)
                     tool_results.append(denial_msg)
                     yield denial_msg
@@ -1016,7 +1114,7 @@ async def query(
         extra={
             "message_count": len(messages),
             "tool_count": len(query_context.tools),
-            "safe_mode": query_context.safe_mode,
+            "yolo_mode": query_context.yolo_mode,
             "model_pointer": query_context.model,
         },
     )
@@ -1042,7 +1140,10 @@ async def query(
             return
 
         # Update messages for next iteration
-        messages = messages + [result.assistant_message] + result.tool_results
+        if result.assistant_message is not None:
+            messages = messages + [result.assistant_message] + result.tool_results  # type: ignore[operator]
+        else:
+            messages = messages + result.tool_results  # type: ignore[operator]
         logger.debug(
             f"[query] Continuing loop with {len(messages)} messages after tools; "
             f"tool_results_count={len(result.tool_results)}"

ripperdoc/core/query_utils.py

@@ -462,11 +462,13 @@ def log_openai_messages(normalized_messages: List[Dict[str, Any]]) -> None:
         role = message.get("role")
         tool_calls = message.get("tool_calls")
         tool_call_id = message.get("tool_call_id")
+        has_reasoning = "reasoning_content" in message and message.get("reasoning_content")
         ids = [tc.get("id") for tc in tool_calls] if tool_calls else []
         summary_parts.append(
             f"{idx}:{role}"
             + (f" tool_calls={ids}" if ids else "")
             + (f" tool_call_id={tool_call_id}" if tool_call_id else "")
+            + (" +reasoning" if has_reasoning else "")
         )
     logger.debug(f"[query_llm] OpenAI normalized messages: {' | '.join(summary_parts)}")