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

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,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
@@ -65,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]]:
@@ -110,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()
@@ -159,7 +195,9 @@ async def _run_tool_use_generator(
     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
@@ -199,7 +237,6 @@ async def _run_tool_use_generator(
         )
 
     tool_output = None
-    tool_error = None
 
     try:
         async for output in tool.call(parsed_input, tool_context):
@@ -224,10 +261,11 @@ 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)
@@ -321,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)
@@ -374,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
@@ -461,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")
@@ -491,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,
@@ -499,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()
@@ -572,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",
@@ -584,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,
         },
     )
@@ -667,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,
@@ -758,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()
@@ -832,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
@@ -890,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]] = []
 
@@ -899,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
@@ -924,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,
@@ -937,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,
@@ -949,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
@@ -1070,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,
         },
     )

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)}")
 

ripperdoc/core/skills.py

@@ -84,10 +84,15 @@ def _split_frontmatter(raw_text: str) -> Tuple[Dict[str, Any], str]:
                 body = "\n".join(lines[idx + 1 :])
                 try:
                     frontmatter = yaml.safe_load(frontmatter_text) or {}
-                except (yaml.YAMLError, ValueError, TypeError) as exc:  # pragma: no cover - defensive
+                except (
+                    yaml.YAMLError,
+                    ValueError,
+                    TypeError,
+                ) as exc:  # pragma: no cover - defensive
                     logger.warning(
                         "[skills] Invalid frontmatter in SKILL.md: %s: %s",
-                        type(exc).__name__, exc,
+                        type(exc).__name__,
+                        exc,
                     )
                     return {"__error__": f"Invalid frontmatter: {exc}"}, body
                 return frontmatter, body
@@ -118,7 +123,8 @@ def _load_skill_file(
     except (OSError, IOError, UnicodeDecodeError) as exc:
         logger.warning(
             "[skills] Failed to read skill file: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"path": str(path)},
         )
         return None, SkillLoadError(path=path, reason=f"Failed to read file: {exc}")

ripperdoc/core/system_prompt.py

@@ -49,7 +49,8 @@ def _detect_git_repo(cwd: Path) -> bool:
     except (OSError, subprocess.SubprocessError) as exc:
         logger.warning(
             "[system_prompt] Failed to detect git repository: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"cwd": str(cwd)},
         )
         return False
@@ -393,7 +394,8 @@ def build_system_prompt(
         except (OSError, ValueError, RuntimeError) as exc:
             logger.warning(
                 "Failed to load agent definitions: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
             agent_section = (
                 "# Subagents\nTask tool available, but agent definitions could not be loaded."

ripperdoc/core/tool.py

@@ -37,13 +37,15 @@ class ToolUseContext(BaseModel):
 
     message_id: Optional[str] = None
     agent_id: Optional[str] = None
-    safe_mode: bool = False
+    yolo_mode: bool = False
     verbose: bool = False
     permission_checker: Optional[Any] = None
     read_file_timestamps: Dict[str, float] = Field(default_factory=dict)
     # SkipValidation prevents Pydantic from copying the dict during validation,
     # ensuring Read and Edit tools share the same cache instance
-    file_state_cache: Annotated[Dict[str, FileSnapshot], SkipValidation] = Field(default_factory=dict)
+    file_state_cache: Annotated[Dict[str, FileSnapshot], SkipValidation] = Field(
+        default_factory=dict
+    )
     tool_registry: Optional[Any] = None
     abort_signal: Optional[Any] = None
     # UI control callbacks for tools that need user interaction
@@ -110,7 +112,7 @@ class Tool(ABC, Generic[TInput, TOutput]):
         pass
 
     @abstractmethod
-    async def prompt(self, safe_mode: bool = False) -> str:
+    async def prompt(self, yolo_mode: bool = False) -> str:
         """Get the system prompt for this tool."""
         pass
 
@@ -213,7 +215,8 @@ async def build_tool_description(
     except (TypeError, ValueError, AttributeError, KeyError) as exc:
         logger.warning(
             "[tool] Failed to build input example section: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"tool": getattr(tool, "name", None)},
         )
         return description_text
@@ -233,7 +236,8 @@ def tool_input_examples(tool: Tool[Any, Any], limit: int = 5) -> List[Dict[str,
         except (TypeError, ValueError, AttributeError) as exc:
             logger.warning(
                 "[tool] Failed to format tool input example: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"tool": getattr(tool, "name", None)},
             )
             continue

ripperdoc/sdk/client.py

@@ -83,7 +83,7 @@ class RipperdocOptions:
     tools: Optional[Sequence[Tool[Any, Any]]] = None
     allowed_tools: Optional[Sequence[str]] = None
     disallowed_tools: Optional[Sequence[str]] = None
-    safe_mode: bool = False
+    yolo_mode: bool = False
     verbose: bool = False
     model: str = "main"
     max_thinking_tokens: int = 0
@@ -227,7 +227,7 @@ class RipperdocClient:
         query_context = QueryContext(
             tools=self._tools,
             max_thinking_tokens=self.options.max_thinking_tokens,
-            safe_mode=self.options.safe_mode,
+            yolo_mode=self.options.yolo_mode,
             model=self.options.model,
             verbose=self.options.verbose,
         )

ripperdoc/tools/ask_user_question_tool.py

@@ -228,7 +228,8 @@ async def prompt_user_for_answer(
         except (OSError, RuntimeError, ValueError) as e:
             logger.warning(
                 "[ask_user_question_tool] Error during prompt: %s: %s",
-                type(e).__name__, e,
+                type(e).__name__,
+                e,
             )
             return None
 
@@ -275,7 +276,7 @@ class AskUserQuestionTool(Tool[AskUserQuestionToolInput, AskUserQuestionToolOutp
     def input_schema(self) -> type[AskUserQuestionToolInput]:
         return AskUserQuestionToolInput
 
-    async def prompt(self, safe_mode: bool = False) -> str:  # noqa: ARG002
+    async def prompt(self, yolo_mode: bool = False) -> str:  # noqa: ARG002
         return ASK_USER_QUESTION_PROMPT
 
     def user_facing_name(self) -> str:
@@ -410,7 +411,8 @@ class AskUserQuestionTool(Tool[AskUserQuestionToolInput, AskUserQuestionToolOutp
         except (OSError, RuntimeError, ValueError, KeyError) as exc:
             logger.warning(
                 "[ask_user_question_tool] Error collecting answers: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
             output = AskUserQuestionToolOutput(
                 questions=questions,

ripperdoc/tools/background_shell.py

@@ -162,7 +162,8 @@ async def _monitor_task(task: BackgroundTask) -> None:
     except (OSError, RuntimeError, ProcessLookupError) as exc:
         logger.warning(
             "Error monitoring background task: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"task_id": task.id, "command": task.command},
         )
         with _tasks_lock:

ripperdoc/tools/bash_output_tool.py

@@ -40,7 +40,7 @@ class BashOutputTool(Tool[BashOutputInput, BashOutputData]):
     async def description(self) -> str:
         return "Read output and status from a background bash command started with BashTool(run_in_background=True)."
 
-    async def prompt(self, safe_mode: bool = False) -> str:
+    async def prompt(self, yolo_mode: bool = False) -> str:
         return "Fetch buffered output and status for a background bash task by id."
 
     @property