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

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 = (
@@ -211,7 +211,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)
@@ -268,14 +269,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 +385,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 +441,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 +503,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 +548,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 +557,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

@@ -11,8 +11,7 @@ from __future__ import annotations
 
 import re
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple
-from functools import lru_cache
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from ripperdoc.utils.git_utils import (
     get_git_root,
@@ -287,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)
@@ -361,7 +360,7 @@ class IgnoreFilter:
 
         return result
 
-    def test(self, path: str) -> Dict[str, any]:
+    def test(self, path: str) -> Dict[str, Any]:
         """Check if a path should be ignored and return details.
 
         Returns:
@@ -369,7 +368,7 @@ class IgnoreFilter:
         """
         path = path.replace("\\", "/").strip("/")
 
-        result = {"ignored": False, "rule": None}
+        result: Dict[str, Any] = {"ignored": False, "rule": None}
 
         for pattern, is_negation in self._patterns:
             if pattern.search(path):
@@ -384,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:
@@ -504,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()
@@ -513,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()
@@ -629,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