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

ripperdoc/core/query.py

@@ -26,7 +26,7 @@ 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
@@ -43,7 +43,11 @@ from ripperdoc.core.query_utils import (
 from ripperdoc.core.tool import Tool, ToolProgress, ToolResult, ToolUseContext
 from ripperdoc.utils.coerce import parse_optional_int
 from ripperdoc.utils.context_length_errors import detect_context_length_error
-from ripperdoc.utils.file_watch import ChangedFileNotice, FileSnapshot, detect_changed_files
+from ripperdoc.utils.file_watch import (
+    BoundedFileCache,
+    ChangedFileNotice,
+    detect_changed_files,
+)
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.messages import (
     AssistantMessage,
@@ -65,6 +69,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]]:
@@ -95,7 +135,7 @@ async def _check_tool_permissions(
     parsed_input: Any,
     query_context: "QueryContext",
     can_use_tool_fn: Optional[ToolPermissionCallable],
-) -> tuple[bool, Optional[str]]:
+) -> tuple[bool, Optional[str], Optional[Any]]:
     """Evaluate whether a tool call is allowed."""
     try:
         if can_use_tool_fn is not None:
@@ -103,14 +143,16 @@ async def _check_tool_permissions(
             if inspect.isawaitable(decision):
                 decision = await decision
             if isinstance(decision, PermissionResult):
-                return decision.result, decision.message
+                return decision.result, decision.message, decision.updated_input
             if isinstance(decision, dict) and "result" in decision:
-                return bool(decision.get("result")), decision.get("message")
+                return bool(decision.get("result")), decision.get("message"), decision.get(
+                    "updated_input"
+                )
             if isinstance(decision, tuple) and len(decision) == 2:
-                return bool(decision[0]), decision[1]
-            return bool(decision), None
+                return bool(decision[0]), decision[1], None
+            return bool(decision), None, 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()
@@ -119,15 +161,15 @@ async def _check_tool_permissions(
             )
             prompt = f"Allow tool '{tool.name}' with input {input_preview}? [y/N]: "
             response = await loop.run_in_executor(None, lambda: input(prompt))
-            return response.strip().lower() in ("y", "yes"), None
+            return response.strip().lower() in ("y", "yes"), None, None
 
-        return True, None
+        return True, None, None
     except (TypeError, AttributeError, ValueError) as exc:
         logger.warning(
             f"Error checking permissions for tool '{tool.name}': {type(exc).__name__}: {exc}",
             extra={"tool": getattr(tool, "name", None), "error_type": type(exc).__name__},
         )
-        return False, None
+        return False, None, None
 
 
 def _format_changed_file_notice(notices: List[ChangedFileNotice]) -> str:
@@ -146,6 +188,18 @@ def _format_changed_file_notice(notices: List[ChangedFileNotice]) -> str:
     return "\n".join(lines)
 
 
+def _append_hook_context(context: Dict[str, str], label: str, payload: Optional[str]) -> None:
+    """Append hook-supplied context to the shared context dict."""
+    if not payload:
+        return
+    key = f"Hook:{label}"
+    existing = context.get(key)
+    if existing:
+        context[key] = f"{existing}\n{payload}"
+    else:
+        context[key] = payload
+
+
 async def _run_tool_use_generator(
     tool: Tool[Any, Any],
     tool_use_id: str,
@@ -153,13 +207,16 @@ async def _run_tool_use_generator(
     parsed_input: Any,
     sibling_ids: set[str],
     tool_context: ToolUseContext,
+    context: Dict[str, str],
 ) -> 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 {}
+        else dict(parsed_input)
+        if isinstance(parsed_input, dict)
+        else {}
     )
 
     # Run PreToolUse hooks
@@ -197,9 +254,11 @@ async def _run_tool_use_generator(
             f"[query] PreToolUse hook added context for {tool_name}",
             extra={"context": pre_result.additional_context[:100]},
         )
+        _append_hook_context(context, f"PreToolUse:{tool_name}", pre_result.additional_context)
+    if pre_result.system_message:
+        _append_hook_context(context, f"PreToolUse:{tool_name}:system", pre_result.system_message)
 
     tool_output = None
-    tool_error = None
 
     try:
         async for output in tool.call(parsed_input, tool_context):
@@ -224,18 +283,28 @@ async def _run_tool_use_generator(
     except CancelledError:
         raise  # Don't suppress task cancellation
     except (RuntimeError, ValueError, TypeError, OSError, IOError, AttributeError, KeyError) as exc:
-        tool_error = str(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(
+    post_result = await hook_manager.run_post_tool_use_async(
         tool_name, tool_input_dict, tool_response=tool_output, tool_use_id=tool_use_id
     )
+    if post_result.additional_context:
+        _append_hook_context(context, f"PostToolUse:{tool_name}", post_result.additional_context)
+    if post_result.system_message:
+        _append_hook_context(
+            context, f"PostToolUse:{tool_name}:system", post_result.system_message
+        )
+    if post_result.should_block:
+        reason = post_result.block_reason or post_result.stop_reason or "Blocked by hook."
+        yield create_user_message(f"PostToolUse hook blocked: {reason}")
 
 
 def _group_tool_calls_by_concurrency(prepared_calls: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
@@ -307,6 +376,7 @@ async def _run_concurrent_tool_uses(
     """Drain multiple tool generators concurrently and stream outputs."""
     if not generators:
         return
+        yield  # Make this a proper async generator that yields nothing
 
     queue: asyncio.Queue[Optional[Union[UserMessage, ProgressMessage]]] = asyncio.Queue()
 
@@ -321,7 +391,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)
@@ -374,7 +445,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
@@ -461,7 +533,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")
@@ -487,25 +560,43 @@ def _apply_skill_context_updates(
 class QueryContext:
     """Context for a query session."""
 
+    # Thresholds for memory warnings
+    MESSAGE_COUNT_WARNING_THRESHOLD = int(
+        os.getenv("RIPPERDOC_MESSAGE_WARNING_THRESHOLD", "500")
+    )
+    MESSAGE_COUNT_CRITICAL_THRESHOLD = int(
+        os.getenv("RIPPERDOC_MESSAGE_CRITICAL_THRESHOLD", "1000")
+    )
+
     def __init__(
         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,
         resume_ui: Optional[Callable[[], None]] = None,
+        stop_hook: str = "stop",
+        file_cache_max_entries: int = 500,
+        file_cache_max_memory_mb: float = 50.0,
     ) -> 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()
-        self.file_state_cache: Dict[str, FileSnapshot] = {}
+        # Use BoundedFileCache instead of plain Dict to prevent unbounded growth
+        self.file_state_cache: BoundedFileCache = BoundedFileCache(
+            max_entries=file_cache_max_entries,
+            max_memory_mb=file_cache_max_memory_mb,
+        )
         self.pause_ui = pause_ui
         self.resume_ui = resume_ui
+        self.stop_hook = stop_hook
+        self.stop_hook_active = False
+        self._last_message_warning_count = 0
 
     @property
     def tools(self) -> List[Tool[Any, Any]]:
@@ -525,6 +616,44 @@ class QueryContext:
         """Return all known tools (active + deferred)."""
         return self.tool_registry.all_tools
 
+    def check_message_count(self, message_count: int) -> None:
+        """Check message count and log warnings if thresholds are exceeded.
+
+        This helps detect potential memory issues in long sessions.
+        """
+        if message_count >= self.MESSAGE_COUNT_CRITICAL_THRESHOLD:
+            if self._last_message_warning_count < self.MESSAGE_COUNT_CRITICAL_THRESHOLD:
+                logger.warning(
+                    "[query] Critical: Message history is very large. "
+                    "Consider compacting or starting a new session.",
+                    extra={
+                        "message_count": message_count,
+                        "threshold": self.MESSAGE_COUNT_CRITICAL_THRESHOLD,
+                        "file_cache_stats": self.file_state_cache.stats(),
+                    },
+                )
+                self._last_message_warning_count = message_count
+        elif message_count >= self.MESSAGE_COUNT_WARNING_THRESHOLD:
+            # Only warn once per threshold crossing
+            if self._last_message_warning_count < self.MESSAGE_COUNT_WARNING_THRESHOLD:
+                logger.info(
+                    "[query] Message history growing large; automatic compaction may trigger soon",
+                    extra={
+                        "message_count": message_count,
+                        "threshold": self.MESSAGE_COUNT_WARNING_THRESHOLD,
+                        "file_cache_stats": self.file_state_cache.stats(),
+                    },
+                )
+                self._last_message_warning_count = message_count
+
+    def get_memory_stats(self) -> Dict[str, Any]:
+        """Return memory usage statistics for monitoring."""
+        return {
+            "file_cache": self.file_state_cache.stats(),
+            "tool_count": len(self.tool_registry.all_tools),
+            "active_tool_count": len(self.tool_registry.active_tools),
+        }
+
 
 async def query_llm(
     messages: List[Union[UserMessage, AssistantMessage, ProgressMessage]],
@@ -557,7 +686,6 @@ async def query_llm(
         AssistantMessage with the model's response
     """
     request_timeout = request_timeout or DEFAULT_REQUEST_TIMEOUT_SEC
-    request_timeout = request_timeout or DEFAULT_REQUEST_TIMEOUT_SEC
     model_profile = resolve_model_profile(model)
 
     # Normalize messages based on protocol family (Anthropic allows tool blocks; OpenAI-style prefers text-only)
@@ -572,8 +700,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",
@@ -584,6 +726,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,
         },
     )
@@ -601,13 +744,25 @@ async def query_llm(
     start_time = time.time()
 
     try:
-        client: Optional[ProviderClient] = get_provider_client(model_profile.provider)
+        try:
+            client: Optional[ProviderClient] = get_provider_client(model_profile.provider)
+        except RuntimeError as exc:
+            duration_ms = (time.time() - start_time) * 1000
+            error_msg = create_assistant_message(
+                content=str(exc),
+                duration_ms=duration_ms,
+            )
+            error_msg.is_api_error_message = True
+            return error_msg
         if client is None:
             duration_ms = (time.time() - start_time) * 1000
+            provider_label = getattr(model_profile.provider, "value", None) or str(
+                model_profile.provider
+            )
             error_msg = create_assistant_message(
                 content=(
-                    "Gemini protocol is not supported yet in Ripperdoc. "
-                    "Please configure an Anthropic or OpenAI-compatible model."
+                    f"No provider client available for '{provider_label}'. "
+                    "Check your model configuration and provider dependencies."
                 ),
                 duration_ms=duration_ms,
             )
@@ -659,6 +814,13 @@ async def query_llm(
             cost_usd=provider_response.cost_usd,
             duration_ms=provider_response.duration_ms,
             metadata=provider_response.metadata,
+            model=model_profile.model,
+            input_tokens=provider_response.usage_tokens.get("input_tokens", 0),
+            output_tokens=provider_response.usage_tokens.get("output_tokens", 0),
+            cache_read_tokens=provider_response.usage_tokens.get("cache_read_input_tokens", 0),
+            cache_creation_tokens=provider_response.usage_tokens.get(
+                "cache_creation_input_tokens", 0
+            ),
         )
 
     except CancelledError:
@@ -667,7 +829,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,
@@ -758,9 +921,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()
@@ -775,7 +936,7 @@ async def _run_query_iteration(
     )
 
     # Stream LLM response
-    progress_queue: asyncio.Queue[Optional[ProgressMessage]] = asyncio.Queue()
+    progress_queue: asyncio.Queue[Optional[ProgressMessage]] = asyncio.Queue(maxsize=1000)
 
     async def _stream_progress(chunk: str) -> None:
         if not chunk:
@@ -828,23 +989,23 @@ async def _run_query_iteration(
             progress = progress_queue.get_nowait()
         except asyncio.QueueEmpty:
             waiter = asyncio.create_task(progress_queue.get())
-            # Use timeout to periodically check abort_controller during LLM request
+            abort_waiter = asyncio.create_task(query_context.abort_controller.wait())
             done, pending = await asyncio.wait(
-                {assistant_task, waiter},
+                {assistant_task, waiter, abort_waiter},
                 return_when=asyncio.FIRST_COMPLETED,
-                timeout=0.1  # Check abort_controller every 100ms
             )
-            if not done:
-                # Timeout - cancel waiter and continue loop to check abort_controller
-                waiter.cancel()
-                try:
-                    await waiter
-                except asyncio.CancelledError:
-                    pass
+            for task in pending:
+                # Don't cancel assistant_task here - it should only be cancelled
+                # through abort_controller in the main loop
+                if task is not assistant_task:
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+            if abort_waiter in done:
                 continue
             if assistant_task in done:
-                for task in pending:
-                    task.cancel()
                 assistant_message = await assistant_task
                 break
             progress = waiter.result()
@@ -857,7 +1018,8 @@ async def _run_query_iteration(
         if residual:
             yield residual
 
-    assert assistant_message is not None
+    if assistant_message is None:
+        raise RuntimeError("assistant_message was unexpectedly None after LLM query")
     result.assistant_message = assistant_message
 
     # Check for abort
@@ -882,6 +1044,27 @@ async def _run_query_iteration(
 
     if not tool_use_blocks:
         logger.debug("[query] No tool_use blocks; returning response to user.")
+        stop_hook = query_context.stop_hook
+        stop_result = (
+            await hook_manager.run_subagent_stop_async(
+                stop_hook_active=query_context.stop_hook_active
+            )
+            if stop_hook == "subagent"
+            else await hook_manager.run_stop_async(stop_hook_active=query_context.stop_hook_active)
+        )
+        if stop_result.additional_context:
+            _append_hook_context(context, f"{stop_hook}:context", stop_result.additional_context)
+        if stop_result.system_message:
+            _append_hook_context(context, f"{stop_hook}:system", stop_result.system_message)
+        if stop_result.should_block:
+            reason = stop_result.block_reason or stop_result.stop_reason or "Blocked by hook."
+            result.tool_results = [create_user_message(f"{stop_hook} hook blocked: {reason}")]
+            for msg in result.tool_results:
+                yield msg
+            query_context.stop_hook_active = True
+            result.should_stop = False
+            return
+        query_context.stop_hook_active = False
         result.should_stop = True
         return
 
@@ -890,8 +1073,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]] = []
 
@@ -899,22 +1081,17 @@ 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
-        assert tool is not None
+        if tool is None:
+            raise RuntimeError(f"Tool '{tool_name}' resolved to None unexpectedly")
 
         try:
             parsed_input = tool.input_schema(**tool_input)
@@ -924,11 +1101,12 @@ 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,
                 file_state_cache=query_context.file_state_cache,
+                conversation_messages=messages,
                 abort_signal=query_context.abort_controller,
                 pause_ui=query_context.pause_ui,
                 resume_ui=query_context.resume_ui,
@@ -937,8 +1115,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,
@@ -949,23 +1126,43 @@ async def _run_query_iteration(
                 yield result_msg
                 continue
 
-            if query_context.safe_mode or can_use_tool_fn is not None:
-                allowed, denial_message = await _check_tool_permissions(
+            if not query_context.yolo_mode or can_use_tool_fn is not None:
+                allowed, denial_message, updated_input = 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
                     permission_denied = True
                     break
+                if updated_input:
+                    try:
+                        parsed_input = tool.input_schema(**updated_input)
+                    except ValidationError as ve:
+                        detail_text = format_pydantic_errors(ve)
+                        error_msg = tool_result_message(
+                            tool_use_id,
+                            f"Invalid permission-updated input for tool '{tool_name}': {detail_text}",
+                            is_error=True,
+                        )
+                        tool_results.append(error_msg)
+                        yield error_msg
+                        continue
+                    validation = await tool.validate_input(parsed_input, tool_context)
+                    if not validation.result:
+                        error_msg = tool_result_message(
+                            tool_use_id,
+                            validation.message or "Tool input validation failed.",
+                            is_error=True,
+                        )
+                        tool_results.append(error_msg)
+                        yield error_msg
+                        continue
 
             prepared_calls.append(
                 {
@@ -977,6 +1174,7 @@ async def _run_query_iteration(
                         parsed_input,
                         sibling_ids,
                         tool_context,
+                        context,
                     ),
                 }
             )
@@ -1070,7 +1268,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,
         },
     )
@@ -1078,6 +1276,9 @@ async def query(
     # do not interfere with the loop or normalization.
     messages = list(messages)
 
+    # Check initial message count for memory warnings
+    query_context.check_message_count(len(messages))
+
     for iteration in range(1, MAX_QUERY_ITERATIONS + 1):
         result = IterationResult()
 
@@ -1100,6 +1301,10 @@ async def query(
             messages = messages + [result.assistant_message] + result.tool_results  # type: ignore[operator]
         else:
             messages = messages + result.tool_results  # type: ignore[operator]
+
+        # Check message count after each iteration for memory warnings
+        query_context.check_message_count(len(messages))
+
         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)}")