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

ripperdoc/utils/mcp.py

@@ -92,7 +92,8 @@ def _ensure_str_dict(raw: object) -> Dict[str, str]:
         except (TypeError, ValueError) as exc:
             logger.warning(
                 "[mcp] Failed to coerce env/header value to string: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"key": key},
             )
             continue
@@ -365,10 +366,17 @@ class McpRuntime:
                     "capabilities": list(info.capabilities.keys()),
                 },
             )
-        except (OSError, RuntimeError, ConnectionError, ValueError, TimeoutError) as exc:  # pragma: no cover - network/process errors
+        except (
+            OSError,
+            RuntimeError,
+            ConnectionError,
+            ValueError,
+            TimeoutError,
+        ) as exc:  # pragma: no cover - network/process errors
             logger.warning(
                 "Failed to connect to MCP server: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
                 extra={"server": config.name},
             )
             info.status = "failed"

ripperdoc/utils/memory.py

@@ -48,7 +48,8 @@ def _is_path_under_directory(path: Path, directory: Path) -> bool:
     except (ValueError, OSError) as exc:
         logger.warning(
             "[memory] Failed to compare path containment: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"path": str(path), "directory": str(directory)},
         )
         return False
@@ -126,7 +127,8 @@ def _collect_files(
     except (OSError, ValueError) as exc:
         logger.warning(
             "[memory] Failed to resolve memory file path: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"path": str(resolved_path)},
         )
 

ripperdoc/utils/message_compaction.py

@@ -27,7 +27,7 @@ MAX_TOKENS_SOFT = 20_000
 MAX_TOKENS_HARD = 40_000
 MAX_TOOL_USES_TO_PRESERVE = 3
 IMAGE_TOKEN_COST = 2_000
-AUTO_COMPACT_BUFFER = 13_000
+AUTO_COMPACT_BUFFER = 24_000
 WARNING_THRESHOLD = 20_000
 ERROR_THRESHOLD = 20_000
 MICRO_PLACEHOLDER = "[Old tool result content cleared]"
@@ -270,7 +270,9 @@ def get_remaining_context_tokens(
     """Context window minus configured output tokens."""
     context_limit = max(get_model_context_limit(model_profile, explicit_limit), MIN_CONTEXT_TOKENS)
     try:
-        max_output_tokens = int(getattr(model_profile, "max_tokens", 0) or 0) if model_profile else 0
+        max_output_tokens = (
+            int(getattr(model_profile, "max_tokens", 0) or 0) if model_profile else 0
+        )
     except (TypeError, ValueError):
         max_output_tokens = 0
     return max(MIN_CONTEXT_TOKENS, context_limit - max(0, max_output_tokens))
@@ -298,7 +300,9 @@ def get_context_usage_status(
     )
 
     tokens_left = max(effective_limit - used_tokens, 0)
-    percent_left = 0.0 if effective_limit <= 0 else min(100.0, (tokens_left / effective_limit) * 100)
+    percent_left = (
+        0.0 if effective_limit <= 0 else min(100.0, (tokens_left / effective_limit) * 100)
+    )
     percent_used = 100.0 - percent_left
 
     warning_limit = max(0, effective_limit - WARNING_THRESHOLD)
@@ -419,7 +423,9 @@ def _estimate_message_tokens(content_block: Any) -> int:
     if isinstance(content, list):
         total = 0
         for part in content:
-            part_type = getattr(part, "type", None) or (part.get("type") if isinstance(part, dict) else None)
+            part_type = getattr(part, "type", None) or (
+                part.get("type") if isinstance(part, dict) else None
+            )
             if part_type == "text":
                 text_val = getattr(part, "text", None) if hasattr(part, "text") else None
                 if text_val is None and isinstance(part, dict):
@@ -501,7 +507,9 @@ def micro_compact_messages(
                 token_counts_by_tool_use_id[tool_use_id] = token_count
 
     latest_tool_use_ids = (
-        tool_use_ids_to_compact[-MAX_TOOL_USES_TO_PRESERVE:] if MAX_TOOL_USES_TO_PRESERVE > 0 else []
+        tool_use_ids_to_compact[-MAX_TOOL_USES_TO_PRESERVE:]
+        if MAX_TOOL_USES_TO_PRESERVE > 0
+        else []
     )
     total_token_count = sum(token_counts_by_tool_use_id.values())
 
@@ -525,7 +533,9 @@ def micro_compact_messages(
             messages, protocol=protocol, precomputed_total_tokens=tokens_before
         )
         status = get_context_usage_status(
-            usage_tokens, max_context_tokens=context_limit, auto_compact_enabled=resolved_auto_compact
+            usage_tokens,
+            max_context_tokens=context_limit,
+            auto_compact_enabled=resolved_auto_compact,
         )
         if not status.is_above_warning_threshold or total_tokens_removed < MAX_TOKENS_SOFT:
             ids_to_remove.clear()
@@ -571,7 +581,11 @@ def micro_compact_messages(
                     new_block = content_item.model_copy()
                     new_block.text = MICRO_PLACEHOLDER
                 else:
-                    block_dict = dict(content_item) if isinstance(content_item, dict) else {"type": "tool_result"}
+                    block_dict = (
+                        dict(content_item)
+                        if isinstance(content_item, dict)
+                        else {"type": "tool_result"}
+                    )
                     block_dict["text"] = MICRO_PLACEHOLDER
                     block_dict["tool_use_id"] = tool_use_id
                     new_block = MessageContent(**block_dict)

ripperdoc/utils/message_formatting.py

@@ -12,9 +12,7 @@ from ripperdoc.utils.messages import UserMessage, AssistantMessage, ProgressMess
 ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
 
 
-def stringify_message_content(
-    content: Any, *, include_tool_details: bool = False
-) -> str:
+def stringify_message_content(content: Any, *, include_tool_details: bool = False) -> str:
     """Convert message content to plain string.
 
     Args:
@@ -128,14 +126,16 @@ def format_tool_result_detail(result_text: str, is_error: bool = False) -> str:
     return f"{prefix}: {result_preview}"
 
 
-def format_reasoning_preview(reasoning: Any) -> str:
+def format_reasoning_preview(reasoning: Any, show_full_thinking: bool = False) -> str:
     """Return a short preview of reasoning/thinking content.
 
     Args:
         reasoning: The reasoning content (string, list, or other).
+        show_full_thinking: If True, return full reasoning content without truncation.
+            If False, return a truncated preview (max 250 chars).
 
     Returns:
-        A short preview string (max ~80 chars with ellipsis).
+        A short preview string or full reasoning content.
     """
     if reasoning is None:
         return ""
@@ -151,11 +151,18 @@ def format_reasoning_preview(reasoning: Any) -> str:
         text = "\n".join(p for p in parts if p)
     else:
         text = str(reasoning)
+    
+    if show_full_thinking:
+        return text
+    
     lines = text.strip().splitlines()
     if not lines:
         return ""
-    preview = lines[0][:80]
-    if len(lines) > 1 or len(lines[0]) > 80:
+    first_line = lines[0]
+    if not first_line:
+        return "..." if len(lines) > 1 else ""
+    preview = first_line[:250]
+    if len(lines) > 1 or len(first_line) > 250:
         preview += "..."
     return preview
 

ripperdoc/utils/messages.py

@@ -4,7 +4,6 @@ This module provides utilities for creating and normalizing messages
 for communication with AI models.
 """
 
-import json
 from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field
 from uuid import uuid4
@@ -93,7 +92,8 @@ def _content_block_to_openai(block: MessageContent) -> Dict[str, Any]:
         except (TypeError, ValueError) as exc:
             logger.warning(
                 "[_content_block_to_openai] Failed to serialize tool arguments: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
             args_str = "{}"
         tool_call_id = (
@@ -169,6 +169,12 @@ class AssistantMessage(BaseModel):
     cost_usd: float = 0.0
     duration_ms: float = 0.0
     is_api_error_message: bool = False
+    # Model and token usage information
+    model: Optional[str] = None
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_creation_tokens: int = 0
 
     def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
@@ -211,7 +217,8 @@ def create_user_message(
             # Fallback: keep as-is if conversion fails
             logger.warning(
                 "[create_user_message] Failed to normalize tool_use_result: %s: %s",
-                type(exc).__name__, exc,
+                type(exc).__name__,
+                exc,
             )
 
     message = Message(role=MessageRole.USER, content=message_content)
@@ -236,6 +243,11 @@ def create_assistant_message(
     duration_ms: float = 0.0,
     reasoning: Optional[Any] = None,
     metadata: Optional[Dict[str, Any]] = None,
+    model: Optional[str] = None,
+    input_tokens: int = 0,
+    output_tokens: int = 0,
+    cache_read_tokens: int = 0,
+    cache_creation_tokens: int = 0,
 ) -> AssistantMessage:
     """Create an assistant message."""
     if isinstance(content, str):
@@ -250,7 +262,16 @@ def create_assistant_message(
         metadata=metadata or {},
     )
 
-    return AssistantMessage(message=message, cost_usd=cost_usd, duration_ms=duration_ms)
+    return AssistantMessage(
+        message=message,
+        cost_usd=cost_usd,
+        duration_ms=duration_ms,
+        model=model,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cache_read_tokens=cache_read_tokens,
+        cache_creation_tokens=cache_creation_tokens,
+    )
 
 
 def create_progress_message(
@@ -268,14 +289,80 @@ def create_progress_message(
     )
 
 
+def _apply_deepseek_reasoning_content(
+    normalized: List[Dict[str, Any]],
+    is_new_turn: bool = False,
+) -> List[Dict[str, Any]]:
+    """Apply DeepSeek reasoning_content handling to normalized messages.
+
+    DeepSeek thinking mode requires special handling for tool calls:
+    1. During a tool call loop (same turn), reasoning_content MUST be preserved
+       in assistant messages that contain tool_calls
+    2. When a new user turn starts, we can optionally clear previous reasoning_content
+       to save bandwidth (the API will ignore them anyway)
+
+    According to DeepSeek docs, an assistant message with tool_calls should look like:
+    {
+        'role': 'assistant',
+        'content': response.choices[0].message.content,
+        'reasoning_content': response.choices[0].message.reasoning_content,
+        'tool_calls': response.choices[0].message.tool_calls,
+    }
+
+    Args:
+        normalized: The normalized messages list
+        is_new_turn: If True, clear reasoning_content from historical messages
+                     to save network bandwidth
+
+    Returns:
+        The processed messages list
+    """
+    if not normalized:
+        return normalized
+
+    # Find the last user message index to determine the current turn boundary
+    last_user_idx = -1
+    for idx in range(len(normalized) - 1, -1, -1):
+        if normalized[idx].get("role") == "user":
+            last_user_idx = idx
+            break
+
+    if is_new_turn and last_user_idx > 0:
+        # Clear reasoning_content from messages before the last user message
+        # This is optional but recommended by DeepSeek to save bandwidth
+        for idx in range(last_user_idx):
+            msg = normalized[idx]
+            if msg.get("role") == "assistant" and "reasoning_content" in msg:
+                # Set to None instead of deleting to match DeepSeek's example
+                msg["reasoning_content"] = None
+
+    # Validate: ensure all assistant messages with tool_calls have reasoning_content
+    # within the current turn (after last_user_idx)
+    for idx in range(max(0, last_user_idx), len(normalized)):
+        msg = normalized[idx]
+        if msg.get("role") == "assistant" and msg.get("tool_calls"):
+            if "reasoning_content" not in msg:
+                # This is a problem - DeepSeek requires reasoning_content for tool_calls
+                logger.warning(
+                    f"[deepseek] Assistant message at index {idx} has tool_calls "
+                    f"but missing reasoning_content - this may cause API errors"
+                )
+
+    return normalized
+
+
 def normalize_messages_for_api(
     messages: List[Union[UserMessage, AssistantMessage, ProgressMessage]],
     protocol: str = "anthropic",
     tool_mode: str = "native",
+    thinking_mode: Optional[str] = None,
 ) -> List[Dict[str, Any]]:
     """Normalize messages for API submission.
 
     Progress messages are filtered out as they are not sent to the API.
+
+    For DeepSeek thinking mode, this function ensures reasoning_content is properly
+    included in assistant messages that contain tool_calls, as required by the API.
     """
 
     def _msg_type(msg: Any) -> Optional[str]:
@@ -318,58 +405,6 @@ def normalize_messages_for_api(
                 return meta_dict
         return {}
 
-    def _block_type(block: Any) -> Optional[str]:
-        if hasattr(block, "type"):
-            return getattr(block, "type", None)
-        if isinstance(block, dict):
-            return block.get("type")
-        return None
-
-    def _block_attr(block: Any, attr: str, default: Any = None) -> Any:
-        if hasattr(block, attr):
-            return getattr(block, attr, default)
-        if isinstance(block, dict):
-            return block.get(attr, default)
-        return default
-
-    def _flatten_blocks_to_text(blocks: List[Any]) -> str:
-        parts: List[str] = []
-        for blk in blocks:
-            btype = _block_type(blk)
-            if btype == "text":
-                text = _block_attr(blk, "text") or _block_attr(blk, "content") or ""
-                if text:
-                    parts.append(str(text))
-            elif btype == "tool_result":
-                text = _block_attr(blk, "text") or _block_attr(blk, "content") or ""
-                tool_id = _block_attr(blk, "tool_use_id") or _block_attr(blk, "id")
-                prefix = "Tool error" if _block_attr(blk, "is_error") else "Tool result"
-                label = f"{prefix}{f' ({tool_id})' if tool_id else ''}"
-                parts.append(f"{label}: {text}" if text else label)
-            elif btype == "tool_use":
-                name = _block_attr(blk, "name") or ""
-                input_data = _block_attr(blk, "input")
-                input_preview = ""
-                if input_data not in (None, {}):
-                    try:
-                        input_preview = json.dumps(input_data)
-                    except (TypeError, ValueError):
-                        input_preview = str(input_data)
-                tool_id = _block_attr(blk, "tool_use_id") or _block_attr(blk, "id")
-                desc = "Tool call"
-                if name:
-                    desc += f" {name}"
-                if tool_id:
-                    desc += f" ({tool_id})"
-                if input_preview:
-                    desc += f": {input_preview}"
-                parts.append(desc)
-            else:
-                text = _block_attr(blk, "text") or _block_attr(blk, "content") or ""
-                if text:
-                    parts.append(str(text))
-        return "\n".join(p for p in parts if p)
-
     effective_tool_mode = (tool_mode or "native").lower()
     if effective_tool_mode not in {"native", "text"}:
         effective_tool_mode = "native"
@@ -426,7 +461,9 @@ def normalize_messages_for_api(
                         if block_type == "tool_result":
                             tool_results_seen += 1
                             # Skip tool_result blocks that lack a preceding tool_use
-                            tool_id = getattr(block, "tool_use_id", None) or getattr(block, "id", None)
+                            tool_id = getattr(block, "tool_use_id", None) or getattr(
+                                block, "id", None
+                            )
                             if not tool_id:
                                 skipped_tool_results_no_call += 1
                                 continue
@@ -486,19 +523,35 @@ def normalize_messages_for_api(
                             mapped = _content_block_to_openai(block)
                             if mapped:
                                 assistant_openai_msgs.append(mapped)
-                    if text_parts:
-                        assistant_openai_msgs.append(
-                            {"role": "assistant", "content": "\n".join(text_parts)}
-                        )
                     if tool_calls:
+                        # For DeepSeek thinking mode, we must include reasoning_content
+                        # in the assistant message that contains tool_calls
+                        tool_call_msg: Dict[str, Any] = {
+                            "role": "assistant",
+                            "content": "\n".join(text_parts) if text_parts else None,
+                            "tool_calls": tool_calls,
+                        }
+                        # Add reasoning_content if present (required for DeepSeek thinking mode)
+                        reasoning_content = meta.get("reasoning_content") if meta else None
+                        if reasoning_content is not None:
+                            tool_call_msg["reasoning_content"] = reasoning_content
+                            logger.debug(
+                                f"[normalize_messages_for_api] Added reasoning_content to "
+                                f"tool_call message (len={len(str(reasoning_content))})"
+                            )
+                        elif thinking_mode == "deepseek":
+                            logger.warning(
+                                f"[normalize_messages_for_api] DeepSeek mode: assistant "
+                                f"message with tool_calls but no reasoning_content in metadata. "
+                                f"meta_keys={list(meta.keys()) if meta else []}"
+                            )
+                        assistant_openai_msgs.append(tool_call_msg)
+                    elif text_parts:
                         assistant_openai_msgs.append(
-                            {
-                                "role": "assistant",
-                                "content": None,
-                                "tool_calls": tool_calls,
-                            }
+                            {"role": "assistant", "content": "\n".join(text_parts)}
                         )
-                    if meta and assistant_openai_msgs:
+                    # For non-tool-call messages, add reasoning metadata to the last message
+                    if meta and assistant_openai_msgs and not tool_calls:
                         for key in ("reasoning_content", "reasoning_details", "reasoning"):
                             if key in meta and meta[key] is not None:
                                 assistant_openai_msgs[-1][key] = meta[key]
@@ -515,6 +568,7 @@ def normalize_messages_for_api(
 
     logger.debug(
         f"[normalize_messages_for_api] protocol={protocol} tool_mode={effective_tool_mode} "
+        f"thinking_mode={thinking_mode} "
         f"input_msgs={len(messages)} normalized={len(normalized)} "
         f"tool_results_seen={tool_results_seen} tool_uses_seen={tool_uses_seen} "
         f"tool_result_positions={len(tool_result_positions)} "
@@ -523,6 +577,11 @@ def normalize_messages_for_api(
         f"skipped_tool_uses_no_id={skipped_tool_uses_no_id} "
         f"skipped_tool_results_no_call={skipped_tool_results_no_call}"
     )
+
+    # Apply DeepSeek-specific reasoning_content handling
+    if thinking_mode == "deepseek":
+        normalized = _apply_deepseek_reasoning_content(normalized, is_new_turn=False)
+
     return normalized
 
 

ripperdoc/utils/path_ignore.py

@@ -286,7 +286,7 @@ def _compile_pattern(pattern: str) -> re.Pattern[str]:
             while j < len(pattern) and pattern[j] != "]":
                 j += 1
             if j < len(pattern):
-                regex += pattern[i:j + 1]
+                regex += pattern[i : j + 1]
                 i = j
             else:
                 regex += re.escape(c)
@@ -383,7 +383,9 @@ class IgnoreFilter:
 # =============================================================================
 
 
-def parse_ignore_pattern(pattern: str, settings_path: Optional[Path] = None) -> Tuple[str, Optional[Path]]:
+def parse_ignore_pattern(
+    pattern: str, settings_path: Optional[Path] = None
+) -> Tuple[str, Optional[Path]]:
     """Parse an ignore pattern and return (relative_pattern, root_path).
 
     Supports prefixes:
@@ -503,6 +505,7 @@ def is_path_ignored(
     file_path = Path(file_path)
     if not file_path.is_absolute():
         from ripperdoc.utils.safe_get_cwd import safe_get_cwd
+
         file_path = Path(safe_get_cwd()) / file_path
 
     file_path = file_path.resolve()
@@ -512,6 +515,7 @@ def is_path_ignored(
         root_path = get_git_root(file_path.parent)
         if root_path is None:
             from ripperdoc.utils.safe_get_cwd import safe_get_cwd
+
             root_path = Path(safe_get_cwd())
 
     root_path = root_path.resolve()
@@ -628,12 +632,35 @@ def check_path_for_tool(
         # Check if it's a binary/media file
         suffix = file_path.suffix.lower()
         binary_extensions = {
-            ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp",
-            ".mp4", ".avi", ".mkv", ".mov", ".mp3", ".wav", ".flac",
-            ".zip", ".tar", ".gz", ".7z", ".rar",
-            ".exe", ".dll", ".so", ".dylib",
-            ".db", ".sqlite", ".parquet",
-            ".ttf", ".otf", ".woff",
+            ".png",
+            ".jpg",
+            ".jpeg",
+            ".gif",
+            ".bmp",
+            ".ico",
+            ".webp",
+            ".mp4",
+            ".avi",
+            ".mkv",
+            ".mov",
+            ".mp3",
+            ".wav",
+            ".flac",
+            ".zip",
+            ".tar",
+            ".gz",
+            ".7z",
+            ".rar",
+            ".exe",
+            ".dll",
+            ".so",
+            ".dylib",
+            ".db",
+            ".sqlite",
+            ".parquet",
+            ".ttf",
+            ".otf",
+            ".woff",
         }
         if suffix in binary_extensions:
             reasons.append("binary/media file")

ripperdoc/utils/permissions/path_validation_utils.py

@@ -51,7 +51,8 @@ def _resolve_path(raw_path: str, cwd: str) -> Path:
     except (OSError, ValueError) as exc:
         logger.warning(
             "[path_validation] Failed to resolve path: %s: %s",
-            type(exc).__name__, exc,
+            type(exc).__name__,
+            exc,
             extra={"raw_path": raw_path, "cwd": cwd},
         )
         return candidate