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

ripperdoc/core/permissions.py

@@ -6,7 +6,7 @@ import asyncio
 from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Optional, Set
+from typing import Any, Awaitable, Callable, Optional, Set, TYPE_CHECKING, TYPE_CHECKING as TYPE_CHECKING
 
 from ripperdoc.core.config import config_manager
 from ripperdoc.core.hooks.manager import hook_manager
@@ -14,6 +14,10 @@ from ripperdoc.core.tool import Tool
 from ripperdoc.utils.permissions import PermissionDecision, ToolRule
 from ripperdoc.utils.log import get_logger
 
+if TYPE_CHECKING:
+    from rich.console import Console
+    from prompt_toolkit import PromptSession
+
 logger = get_logger()
 
 
@@ -89,7 +93,7 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
 
 
 def _render_options_prompt(prompt: str, options: list[tuple[str, str]]) -> str:
-    """Render a simple numbered prompt."""
+    """Render a simple numbered prompt (fallback for non-Rich environments)."""
     border = "─" * 120
     lines = [border, prompt, ""]
     for idx, (_, label) in enumerate(options, start=1):
@@ -101,6 +105,42 @@ def _render_options_prompt(prompt: str, options: list[tuple[str, str]]) -> str:
     return "\n".join(lines)
 
 
+def _render_options_prompt_rich(
+    console: "Console",
+    prompt: str,
+    options: list[tuple[str, str]]
+) -> None:
+    """Render permission dialog using Rich Panel for better visual consistency."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    # Build option lines with markup
+    option_lines = []
+    for idx, (_, label) in enumerate(options, start=1):
+        prefix = "[cyan]❯[/cyan]" if idx == 1 else " "
+        option_lines.append(f"{prefix} {idx}. {label}")
+
+    numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
+    shortcut_choices = "/".join(opt[0] for opt in options)
+
+    # Build the prompt content as a markup string
+    markup_content = f"{prompt}\n\n" + "\n".join(option_lines) + "\n"
+    markup_content += f"Choice ([cyan]{numeric_choices}[/cyan] or [cyan]{shortcut_choices}[/cyan]): "
+
+    # Parse markup to create a Text object
+    content = Text.from_markup(markup_content)
+
+    # Render the panel
+    panel = Panel(
+        content,
+        title=Text.from_markup("[yellow]Permission Required[/yellow]"),
+        title_align="left",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+    console.print(panel)
+
+
 def _rule_strings(rule_suggestions: Optional[Any]) -> list[str]:
     """Normalize rule suggestions to simple strings."""
     if not rule_suggestions:
@@ -118,9 +158,18 @@ def make_permission_checker(
     project_path: Path,
     yolo_mode: bool,
     prompt_fn: Optional[Callable[[str], str]] = None,
+    console: Optional["Console"] = None,
+    prompt_session: Optional["PromptSession"] = None,
 ) -> Callable[[Tool[Any, Any], Any], Awaitable[PermissionResult]]:
     """Create a permission checking function for the current project.
 
+    Args:
+        project_path: Path to the project directory
+        yolo_mode: If True, all tool calls are allowed without prompting
+        prompt_fn: Optional function to use for prompting (defaults to input())
+        console: Optional Rich console for rich permission dialogs
+        prompt_session: Optional PromptSession for better interrupt handling
+
     In yolo mode, all tool calls are allowed without prompting.
     """
 
@@ -131,13 +180,41 @@ def make_permission_checker(
     session_tool_rules: dict[str, Set[str]] = defaultdict(set)
 
     async def _prompt_user(prompt: str, options: list[tuple[str, str]]) -> str:
-        """Prompt the user without blocking the event loop."""
+        """Prompt the user with proper interrupt handling."""
+        # Build the prompt message
+        if console is not None:
+            # Use Rich Panel for the dialog
+            _render_options_prompt_rich(console, prompt, options)
+            # Build simple prompt for the input line
+            numeric_choices = "/".join(str(i) for i in range(1, len(options) + 1))
+            shortcut_choices = "/".join(opt[0] for opt in options)
+            input_prompt = f"Choice ({numeric_choices} or {shortcut_choices}): "
+        else:
+            # Use plain text rendering
+            rendered = _render_options_prompt(prompt, options)
+            input_prompt = rendered
+
+        # Try to use PromptSession if available (better interrupt handling)
+        if prompt_session is not None:
+            try:
+                # PromptSession.prompt() can handle Ctrl+C gracefully
+                return await prompt_session.prompt_async(input_prompt)
+            except KeyboardInterrupt:
+                logger.debug("[permissions] KeyboardInterrupt in prompt_session")
+                return "n"
+            except EOFError:
+                logger.debug("[permissions] EOFError in prompt_session")
+                return "n"
+
+        # Fallback to simple input() via executor
         loop = asyncio.get_running_loop()
         responder = prompt_fn or input
 
         def _ask() -> str:
-            rendered = _render_options_prompt(prompt, options)
-            return responder(rendered)
+            try:
+                return responder(input_prompt)
+            except (KeyboardInterrupt, EOFError):
+                return "n"
 
         return await loop.run_in_executor(None, _ask)
 

ripperdoc/core/providers/openai.py

@@ -80,10 +80,18 @@ def _effort_from_tokens(max_thinking_tokens: int) -> Optional[str]:
 
 
 def _detect_openai_vendor(model_profile: ModelProfile) -> str:
-    """Best-effort vendor hint for OpenAI-compatible endpoints."""
+    """Best-effort vendor hint for OpenAI-compatible endpoints.
+
+    If thinking_mode is explicitly set to "none" or "disabled", returns "none"
+    to skip all thinking protocol handling.
+    """
     override = getattr(model_profile, "thinking_mode", None)
     if isinstance(override, str) and override.strip():
-        return override.strip().lower()
+        mode = override.strip().lower()
+        # Allow explicit disable of thinking protocol
+        if mode in ("disabled", "off"):
+            return "none"
+        return mode
     base = (model_profile.api_base or "").lower()
     name = (model_profile.model or "").lower()
     if "openrouter.ai" in base:
@@ -106,21 +114,25 @@ def _build_thinking_kwargs(
     extra_body: Dict[str, Any] = {}
     top_level: Dict[str, Any] = {}
     vendor = _detect_openai_vendor(model_profile)
+
+    # Skip thinking protocol if explicitly disabled
+    if vendor == "none":
+        return extra_body, top_level
+
     effort = _effort_from_tokens(max_thinking_tokens)
 
     if vendor == "deepseek":
         if max_thinking_tokens != 0:
             extra_body["thinking"] = {"type": "enabled"}
     elif vendor == "qwen":
+        # Only send enable_thinking when explicitly enabling thinking mode
+        # Some qwen-compatible APIs don't support this parameter
         if max_thinking_tokens > 0:
             extra_body["enable_thinking"] = True
-        elif max_thinking_tokens == 0:
-            extra_body["enable_thinking"] = False
     elif vendor == "openrouter":
+        # Only send reasoning when explicitly enabling thinking mode
         if max_thinking_tokens > 0:
             extra_body["reasoning"] = {"max_tokens": max_thinking_tokens}
-        elif max_thinking_tokens == 0:
-            extra_body["reasoning"] = {"effort": "none"}
     elif vendor == "gemini_openai":
         google_cfg: Dict[str, Any] = {}
         if max_thinking_tokens > 0:
@@ -250,6 +262,15 @@ class OpenAIClient(ProviderClient):
             model_profile, max_thinking_tokens
         )
 
+        logger.debug(
+            "[openai_client] Starting API request",
+            extra={
+                "model": model_profile.model,
+                "api_base": model_profile.api_base,
+                "request_timeout": request_timeout,
+            },
+        )
+
         logger.debug(
             "[openai_client] Request parameters",
             extra={
@@ -420,12 +441,13 @@ class OpenAIClient(ProviderClient):
             )
 
             if (
-                can_stream_text
+                can_stream
                 and not collected_text
                 and not streamed_tool_calls
                 and not streamed_tool_text
+                and not stream_reasoning_text
             ):
-                logger.debug(
+                logger.warning(
                     "[openai_client] Streaming returned no content; retrying without stream",
                     extra={"model": model_profile.model},
                 )
@@ -450,6 +472,30 @@ class OpenAIClient(ProviderClient):
         if not can_stream and (
             not openai_response or not getattr(openai_response, "choices", None)
         ):
+            # Check for non-standard error response (e.g., iflow returns HTTP 200 with error JSON)
+            error_msg = (
+                getattr(openai_response, "msg", None)
+                or getattr(openai_response, "message", None)
+                or getattr(openai_response, "error", None)
+            )
+            error_status = getattr(openai_response, "status", None)
+            if error_msg or error_status:
+                error_text = f"API Error: {error_msg or 'Unknown error'}"
+                if error_status:
+                    error_text = f"API Error ({error_status}): {error_msg or 'Unknown error'}"
+                logger.error(
+                    "[openai_client] Non-standard error response from API",
+                    extra={
+                        "model": model_profile.model,
+                        "error_status": error_status,
+                        "error_msg": error_msg,
+                    },
+                )
+                return ProviderResponse.create_error(
+                    error_code="api_error",
+                    error_message=error_text,
+                    duration_ms=duration_ms,
+                )
             logger.warning(
                 "[openai_client] No choices returned from OpenAI response",
                 extra={"model": model_profile.model},
@@ -532,7 +578,7 @@ class OpenAIClient(ProviderClient):
             },
         )
 
-        logger.info(
+        logger.debug(
             "[openai_client] Response received",
             extra={
                 "model": model_profile.model,