ripperdoc 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

ripperdoc/core/config.py

@@ -7,7 +7,7 @@ including API keys, model settings, and user preferences.
 import json
 import os
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, Literal
 from pydantic import BaseModel, Field
 from enum import Enum
 
@@ -100,11 +100,19 @@ class ModelProfile(BaseModel):
     provider: ProviderType
     model: str
     api_key: Optional[str] = None
+    # Anthropic supports either api_key or auth_token; api_key takes precedence when both are set.
+    auth_token: Optional[str] = None
     api_base: Optional[str] = None
     max_tokens: int = 4096
     temperature: float = 0.7
     # Total context window in tokens (if known). Falls back to heuristics when unset.
     context_window: Optional[int] = None
+    # Tool handling for OpenAI-compatible providers. "native" uses tool_calls, "text" flattens tool
+    # interactions into plain text to support providers that reject tool roles.
+    openai_tool_mode: Literal["native", "text"] = "native"
+    # Pricing (USD per 1M tokens). Leave as 0 to skip cost calculation.
+    input_cost_per_million_tokens: float = 0.0
+    output_cost_per_million_tokens: float = 0.0
 
 
 class ModelPointers(BaseModel):
@@ -185,17 +193,36 @@ class ConfigManager:
                 try:
                     data = json.loads(self.global_config_path.read_text())
                     self._global_config = GlobalConfig(**data)
+                    logger.debug(
+                        "[config] Loaded global configuration",
+                        extra={
+                            "path": str(self.global_config_path),
+                            "profile_count": len(self._global_config.model_profiles),
+                        },
+                    )
                 except Exception as e:
-                    logger.error(f"Error loading global config: {e}")
+                    logger.exception("Error loading global config", extra={"error": str(e)})
                     self._global_config = GlobalConfig()
             else:
                 self._global_config = GlobalConfig()
+                logger.debug(
+                    "[config] Global config not found; using defaults",
+                    extra={"path": str(self.global_config_path)},
+                )
         return self._global_config
 
     def save_global_config(self, config: GlobalConfig) -> None:
         """Save global configuration."""
         self._global_config = config
         self.global_config_path.write_text(config.model_dump_json(indent=2))
+        logger.debug(
+            "[config] Saved global configuration",
+            extra={
+                "path": str(self.global_config_path),
+                "profile_count": len(config.model_profiles),
+                "pointers": config.model_pointers.model_dump(),
+            },
+        )
 
     def get_project_config(self, project_path: Optional[Path] = None) -> ProjectConfig:
         """Load and return project configuration."""
@@ -215,11 +242,29 @@ class ConfigManager:
                 try:
                     data = json.loads(config_path.read_text())
                     self._project_config = ProjectConfig(**data)
+                    logger.debug(
+                        "[config] Loaded project config",
+                        extra={
+                            "path": str(config_path),
+                            "project_path": str(self.current_project_path),
+                            "allowed_tools": len(self._project_config.allowed_tools),
+                        },
+                    )
                 except Exception as e:
-                    logger.error(f"Error loading project config: {e}")
+                    logger.exception(
+                        "Error loading project config",
+                        extra={"error": str(e), "path": str(config_path)},
+                    )
                     self._project_config = ProjectConfig()
             else:
                 self._project_config = ProjectConfig()
+                logger.debug(
+                    "[config] Project config not found; using defaults",
+                    extra={
+                        "path": str(config_path),
+                        "project_path": str(self.current_project_path),
+                    },
+                )
 
         return self._project_config
 
@@ -239,6 +284,14 @@ class ConfigManager:
         config_path = config_dir / "config.json"
         self._project_config = config
         config_path.write_text(config.model_dump_json(indent=2))
+        logger.debug(
+            "[config] Saved project config",
+            extra={
+                "path": str(config_path),
+                "project_path": str(self.current_project_path),
+                "allowed_tools": len(config.allowed_tools),
+            },
+        )
 
     def get_api_key(self, provider: ProviderType) -> Optional[str]:
         """Get API key for a provider."""

ripperdoc/core/default_tools.py

@@ -26,6 +26,9 @@ from ripperdoc.tools.mcp_tools import (
     ReadMcpResourceTool,
     load_dynamic_mcp_tools_sync,
 )
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 def get_default_tools() -> List[Tool[Any, Any]]:
@@ -49,15 +52,26 @@ def get_default_tools() -> List[Tool[Any, Any]]:
         ListMcpResourcesTool(),
         ReadMcpResourceTool(),
     ]
+    dynamic_tools: List[Tool[Any, Any]] = []
     try:
         mcp_tools = load_dynamic_mcp_tools_sync()
         # Filter to ensure only Tool instances are added
         for tool in mcp_tools:
             if isinstance(tool, Tool):
                 base_tools.append(tool)
+                dynamic_tools.append(tool)
     except Exception:
         # If MCP runtime is not available, continue with base tools only.
-        pass
+        logger.exception("[default_tools] Failed to load dynamic MCP tools")
 
     task_tool = TaskTool(lambda: base_tools)
-    return base_tools + [task_tool]
+    all_tools = base_tools + [task_tool]
+    logger.debug(
+        "[default_tools] Built tool inventory",
+        extra={
+            "base_tools": len(base_tools),
+            "dynamic_mcp_tools": len(dynamic_tools),
+            "total_tools": len(all_tools),
+        },
+    )
+    return all_tools

ripperdoc/core/permissions.py

@@ -11,6 +11,9 @@ from typing import Any, Awaitable, Callable, Optional, Set
 from ripperdoc.core.config import config_manager
 from ripperdoc.core.tool import Tool
 from ripperdoc.utils.permissions import PermissionDecision, ToolRule
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 @dataclass
@@ -46,11 +49,19 @@ def permission_key(tool: Tool[Any, Any], parsed_input: Any) -> str:
         try:
             return f"{tool.name}::path::{Path(getattr(parsed_input, 'file_path')).resolve()}"
         except Exception:
+            logger.exception(
+                "[permissions] Failed to resolve file_path for permission key",
+                extra={"tool": getattr(tool, "name", None)},
+            )
             return f"{tool.name}::path::{getattr(parsed_input, 'file_path')}"
     if hasattr(parsed_input, "path"):
         try:
             return f"{tool.name}::path::{Path(getattr(parsed_input, 'path')).resolve()}"
         except Exception:
+            logger.exception(
+                "[permissions] Failed to resolve path for permission key",
+                extra={"tool": getattr(tool, "name", None)},
+            )
             return f"{tool.name}::path::{getattr(parsed_input, 'path')}"
     return tool.name
 
@@ -116,6 +127,10 @@ def make_permission_checker(
             if hasattr(tool, "needs_permissions") and not tool.needs_permissions(parsed_input):
                 return PermissionResult(result=True)
         except Exception:
+            logger.exception(
+                "[permissions] Tool needs_permissions check failed",
+                extra={"tool": getattr(tool, "name", None)},
+            )
             return PermissionResult(
                 result=False,
                 message="Permission check failed for this tool invocation.",
@@ -153,6 +168,10 @@ def make_permission_checker(
                 if isinstance(decision, dict) and "behavior" in decision:
                     decision = PermissionDecision(**decision)
             except Exception:
+                logger.exception(
+                    "[permissions] Tool check_permissions failed",
+                    extra={"tool": getattr(tool, "name", None)},
+                )
                 decision = PermissionDecision(
                     behavior="ask",
                     message="Error checking permissions for this tool.",

ripperdoc/core/providers/__init__.py

@@ -0,0 +1,31 @@
+"""Provider client registry."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ripperdoc.core.config import ProviderType
+from ripperdoc.core.providers.anthropic import AnthropicClient
+from ripperdoc.core.providers.base import ProviderClient
+from ripperdoc.core.providers.gemini import GeminiClient
+from ripperdoc.core.providers.openai import OpenAIClient
+
+
+def get_provider_client(provider: ProviderType) -> Optional[ProviderClient]:
+    """Return a provider client for the given protocol."""
+    if provider == ProviderType.ANTHROPIC:
+        return AnthropicClient()
+    if provider == ProviderType.OPENAI_COMPATIBLE:
+        return OpenAIClient()
+    if provider == ProviderType.GEMINI:
+        return GeminiClient()
+    return None
+
+
+__all__ = [
+    "ProviderClient",
+    "AnthropicClient",
+    "GeminiClient",
+    "OpenAIClient",
+    "get_provider_client",
+]

ripperdoc/core/providers/anthropic.py

@@ -0,0 +1,136 @@
+"""Anthropic provider client."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+from anthropic import AsyncAnthropic
+
+from ripperdoc.core.config import ModelProfile
+from ripperdoc.core.providers.base import (
+    ProgressCallback,
+    ProviderClient,
+    ProviderResponse,
+    call_with_timeout_and_retries,
+    sanitize_tool_history,
+)
+from ripperdoc.core.query_utils import (
+    anthropic_usage_tokens,
+    build_anthropic_tool_schemas,
+    content_blocks_from_anthropic_response,
+    estimate_cost_usd,
+)
+from ripperdoc.core.tool import Tool
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.session_usage import record_usage
+
+logger = get_logger()
+
+
+class AnthropicClient(ProviderClient):
+    """Anthropic client with streaming and non-streaming support."""
+
+    def __init__(self, client_factory: Optional[Callable[[], Awaitable[AsyncAnthropic]]] = None):
+        self._client_factory = client_factory
+
+    async def _client(self, kwargs: Dict[str, Any]) -> AsyncAnthropic:
+        if self._client_factory:
+            return await self._client_factory()
+        return AsyncAnthropic(**kwargs)
+
+    async def call(
+        self,
+        *,
+        model_profile: ModelProfile,
+        system_prompt: str,
+        normalized_messages: Any,
+        tools: List[Tool[Any, Any]],
+        tool_mode: str,
+        stream: bool,
+        progress_callback: Optional[ProgressCallback],
+        request_timeout: Optional[float],
+        max_retries: int,
+    ) -> ProviderResponse:
+        start_time = time.time()
+        tool_schemas = await build_anthropic_tool_schemas(tools)
+        collected_text: List[str] = []
+
+        anthropic_kwargs = {"base_url": model_profile.api_base}
+        if model_profile.api_key:
+            anthropic_kwargs["api_key"] = model_profile.api_key
+        auth_token = getattr(model_profile, "auth_token", None)
+        if auth_token:
+            anthropic_kwargs["auth_token"] = auth_token
+
+        normalized_messages = sanitize_tool_history(list(normalized_messages))
+
+        async with await self._client(anthropic_kwargs) as client:
+
+            async def _stream_request() -> Any:
+                async with client.messages.stream(
+                    model=model_profile.model,
+                    max_tokens=model_profile.max_tokens,
+                    system=system_prompt,
+                    messages=normalized_messages,  # type: ignore[arg-type]
+                    tools=tool_schemas if tool_schemas else None,  # type: ignore
+                    temperature=model_profile.temperature,
+                ) as stream_resp:
+                    async for text in stream_resp.text_stream:
+                        if text:
+                            collected_text.append(text)
+                            if progress_callback:
+                                try:
+                                    await progress_callback(text)
+                                except Exception:
+                                    logger.exception("[anthropic_client] Stream callback failed")
+                    getter = getattr(stream_resp, "get_final_response", None) or getattr(
+                        stream_resp, "get_final_message", None
+                    )
+                    if getter:
+                        return await getter()
+                    return None
+
+            async def _non_stream_request() -> Any:
+                return await client.messages.create(
+                    model=model_profile.model,
+                    max_tokens=model_profile.max_tokens,
+                    system=system_prompt,
+                    messages=normalized_messages,  # type: ignore[arg-type]
+                    tools=tool_schemas if tool_schemas else None,  # type: ignore
+                    temperature=model_profile.temperature,
+                )
+
+            response = await call_with_timeout_and_retries(
+                _stream_request if stream else _non_stream_request,
+                request_timeout,
+                max_retries,
+            )
+
+        duration_ms = (time.time() - start_time) * 1000
+        usage_tokens = anthropic_usage_tokens(getattr(response, "usage", None))
+        cost_usd = estimate_cost_usd(model_profile, usage_tokens)
+        record_usage(
+            model_profile.model, duration_ms=duration_ms, cost_usd=cost_usd, **usage_tokens
+        )
+
+        content_blocks = content_blocks_from_anthropic_response(response, tool_mode)
+        if stream and collected_text and tool_mode == "text":
+            content_blocks = [{"type": "text", "text": "".join(collected_text)}]
+
+        logger.info(
+            "[anthropic_client] Response received",
+            extra={
+                "model": model_profile.model,
+                "duration_ms": round(duration_ms, 2),
+                "tool_mode": tool_mode,
+                "tool_schemas": len(tool_schemas),
+            },
+        )
+
+        return ProviderResponse(
+            content_blocks=content_blocks,
+            usage_tokens=usage_tokens,
+            cost_usd=cost_usd,
+            duration_ms=duration_ms,
+        )

ripperdoc/core/providers/base.py

@@ -0,0 +1,187 @@
+"""Shared abstractions for provider clients."""
+
+from __future__ import annotations
+
+import asyncio
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+from ripperdoc.core.config import ModelProfile
+from ripperdoc.core.tool import Tool
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
+
+ProgressCallback = Callable[[str], Awaitable[None]]
+
+
+@dataclass
+class ProviderResponse:
+    """Normalized provider response payload."""
+
+    content_blocks: List[Dict[str, Any]]
+    usage_tokens: Dict[str, int]
+    cost_usd: float
+    duration_ms: float
+
+
+class ProviderClient(ABC):
+    """Abstract base for model provider clients."""
+
+    @abstractmethod
+    async def call(
+        self,
+        *,
+        model_profile: ModelProfile,
+        system_prompt: str,
+        normalized_messages: List[Dict[str, Any]],
+        tools: List[Tool[Any, Any]],
+        tool_mode: str,
+        stream: bool,
+        progress_callback: Optional[ProgressCallback],
+        request_timeout: Optional[float],
+        max_retries: int,
+    ) -> ProviderResponse:
+        """Execute a model call and return a normalized response."""
+
+
+def sanitize_tool_history(normalized_messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Strip tool_use blocks that lack a following tool_result to satisfy provider constraints."""
+
+    def _tool_result_ids(msg: Dict[str, Any]) -> set[str]:
+        ids: set[str] = set()
+        content = msg.get("content")
+        if isinstance(content, list):
+            for part in content:
+                part_type = getattr(
+                    part, "get", lambda k, default=None: part.__dict__.get(k, default)
+                )("type", None)
+                if part_type == "tool_result":
+                    tid = (
+                        getattr(part, "tool_use_id", None)
+                        or getattr(part, "id", None)
+                        or part.get("tool_use_id")
+                        or part.get("id")
+                    )
+                    if tid:
+                        ids.add(str(tid))
+        return ids
+
+    # Build a lookahead map so we can pair tool_use blocks with tool_results that may
+    # appear in any later message (not just the immediate next one).
+    tool_results_after: List[set[str]] = []
+    if normalized_messages:
+        tool_results_after = [set() for _ in normalized_messages]
+        future_ids: set[str] = set()
+        for idx in range(len(normalized_messages) - 1, -1, -1):
+            tool_results_after[idx] = set(future_ids)
+            future_ids.update(_tool_result_ids(normalized_messages[idx]))
+
+    sanitized: List[Dict[str, Any]] = []
+    for idx, message in enumerate(normalized_messages):
+        if message.get("role") != "assistant":
+            sanitized.append(message)
+            continue
+
+        content = message.get("content")
+        if not isinstance(content, list):
+            sanitized.append(message)
+            continue
+
+        tool_use_blocks = [
+            part
+            for part in content
+            if (
+                getattr(part, "type", None)
+                or (part.get("type") if isinstance(part, dict) else None)
+            )
+            == "tool_use"
+        ]
+        if not tool_use_blocks:
+            sanitized.append(message)
+            continue
+
+        future_results = tool_results_after[idx] if tool_results_after else set()
+
+        # Identify unpaired tool_use IDs
+        unpaired_ids: set[str] = set()
+        for block in tool_use_blocks:
+            block_id = (
+                getattr(block, "tool_use_id", None)
+                or getattr(block, "id", None)
+                or (block.get("tool_use_id") if isinstance(block, dict) else None)
+                or (block.get("id") if isinstance(block, dict) else None)
+            )
+            if block_id and str(block_id) not in future_results:
+                unpaired_ids.add(str(block_id))
+
+        if not unpaired_ids:
+            sanitized.append(message)
+            continue
+
+        # Drop unpaired tool_use blocks
+        filtered_content = []
+        for part in content:
+            part_type = getattr(part, "type", None) or (
+                part.get("type") if isinstance(part, dict) else None
+            )
+            if part_type == "tool_use":
+                block_id = (
+                    getattr(part, "tool_use_id", None)
+                    or getattr(part, "id", None)
+                    or (part.get("tool_use_id") if isinstance(part, dict) else None)
+                    or (part.get("id") if isinstance(part, dict) else None)
+                )
+                if block_id and str(block_id) in unpaired_ids:
+                    continue
+            filtered_content.append(part)
+
+        if not filtered_content:
+            logger.debug(
+                "[provider_clients] Dropped assistant message with unpaired tool_use blocks",
+                extra={"unpaired_ids": list(unpaired_ids)},
+            )
+            continue
+
+        sanitized.append({**message, "content": filtered_content})
+        logger.debug(
+            "[provider_clients] Sanitized message to remove unpaired tool_use blocks",
+            extra={"unpaired_ids": list(unpaired_ids)},
+        )
+
+    return sanitized
+
+
+async def call_with_timeout_and_retries(
+    coro_factory: Callable[[], Awaitable[Any]],
+    request_timeout: Optional[float],
+    max_retries: int,
+) -> Any:
+    """Run a coroutine with timeout and limited retries."""
+    attempts = max(0, int(max_retries)) + 1
+    last_error: Optional[Exception] = None
+    for attempt in range(1, attempts + 1):
+        try:
+            if request_timeout and request_timeout > 0:
+                return await asyncio.wait_for(coro_factory(), timeout=request_timeout)
+            return await coro_factory()
+        except asyncio.TimeoutError as exc:
+            last_error = exc
+            logger.warning(
+                "[provider_clients] Request timed out; retrying",
+                extra={"attempt": attempt, "max_retries": attempts - 1},
+            )
+            if attempt == attempts:
+                raise
+        except Exception as exc:
+            last_error = exc
+            if attempt == attempts:
+                raise
+            logger.warning(
+                "[provider_clients] Request failed; retrying",
+                extra={"attempt": attempt, "max_retries": attempts - 1, "error": str(exc)},
+            )
+    if last_error:
+        raise last_error
+    raise RuntimeError("Unexpected error executing request with retries")