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

ripperdoc/utils/json_utils.py

@@ -0,0 +1,27 @@
+"""JSON helper utilities for Ripperdoc."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+from ripperdoc.utils.log import get_logger
+
+
+logger = get_logger()
+
+
+def safe_parse_json(json_text: Optional[str], log_error: bool = True) -> Optional[Any]:
+    """Best-effort JSON.parse wrapper that returns None on failure."""
+    if not json_text:
+        return None
+    try:
+        return json.loads(json_text)
+    except Exception as exc:
+        if log_error:
+            logger.debug(
+                "[json_utils] Failed to parse JSON",
+                extra={"error": str(exc), "length": len(json_text)},
+                exc_info=True,
+            )
+        return None

ripperdoc/utils/log.py

@@ -1,11 +1,64 @@
 """Logging utilities for Ripperdoc."""
 
+import json
 import logging
 import sys
 import os
-from pathlib import Path
-from typing import Optional
 from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+from ripperdoc.utils.path_utils import sanitize_project_path
+
+
+_LOG_RECORD_FIELDS = {
+    "name",
+    "msg",
+    "args",
+    "levelname",
+    "levelno",
+    "pathname",
+    "filename",
+    "module",
+    "exc_info",
+    "exc_text",
+    "stack_info",
+    "lineno",
+    "funcName",
+    "created",
+    "msecs",
+    "relativeCreated",
+    "thread",
+    "threadName",
+    "processName",
+    "process",
+    "message",
+    "asctime",
+    "stacklevel",
+}
+
+
+class StructuredFormatter(logging.Formatter):
+    """Formatter with ISO timestamps and context."""
+
+    def formatTime(self, record: logging.LogRecord, datefmt: Optional[str] = None) -> str:
+        timestamp = datetime.utcfromtimestamp(record.created)
+        return timestamp.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = super().format(record)
+        extras = {
+            key: value
+            for key, value in record.__dict__.items()
+            if key not in _LOG_RECORD_FIELDS and not key.startswith("_")
+        }
+        if extras:
+            try:
+                serialized = json.dumps(extras, sort_keys=True, ensure_ascii=True, default=str)
+            except Exception:
+                serialized = str(extras)
+            return f"{message} | {serialized}"
+        return message
 
 
 class RipperdocLogger:
@@ -15,46 +68,72 @@ class RipperdocLogger:
         self.logger = logging.getLogger(name)
         level_name = os.getenv("RIPPERDOC_LOG_LEVEL", "WARNING").upper()
         level = getattr(logging, level_name, logging.WARNING)
-        self.logger.setLevel(level)
+        # Allow file handlers to capture debug logs while console respects the configured level.
+        self.logger.setLevel(logging.DEBUG)
+        self.logger.propagate = False
+
+        # Avoid adding duplicate handlers if an existing logger is reused.
+        if not self.logger.handlers:
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(level)
+            console_formatter = logging.Formatter("%(levelname)s: %(message)s")
+            console_handler.setFormatter(console_formatter)
+            self.logger.addHandler(console_handler)
 
-        # Console handler
-        console_handler = logging.StreamHandler(sys.stderr)
-        console_handler.setLevel(level)
-        console_formatter = logging.Formatter("%(levelname)s: %(message)s")
-        console_handler.setFormatter(console_formatter)
-        self.logger.addHandler(console_handler)
+        self._file_handler: Optional[logging.Handler] = None
+        self._file_handler_path: Optional[Path] = None
 
-        # File handler (optional)
         if log_dir:
-            log_dir.mkdir(exist_ok=True)
+            log_dir.mkdir(parents=True, exist_ok=True)
             log_file = log_dir / f"ripperdoc_{datetime.now().strftime('%Y%m%d')}.log"
-            file_handler = logging.FileHandler(log_file)
-            file_handler.setLevel(logging.DEBUG)
-            file_formatter = logging.Formatter(
-                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-            )
-            file_handler.setFormatter(file_formatter)
-            self.logger.addHandler(file_handler)
-
-    def debug(self, message: str) -> None:
+            self.attach_file_handler(log_file)
+
+    def attach_file_handler(self, log_file: Path) -> Path:
+        """Attach or replace a file handler for logging to disk."""
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        if self._file_handler and self._file_handler_path == log_file:
+            return log_file
+
+        if self._file_handler:
+            try:
+                self.logger.removeHandler(self._file_handler)
+            except Exception:
+                # Swallow errors while rotating handlers; console logging should continue.
+                self.logger.exception("[logging] Failed to remove existing file handler")
+
+        # Use UTF-8 to avoid Windows code page encoding errors when logs contain non-ASCII text.
+        file_handler = logging.FileHandler(log_file, encoding="utf-8")
+        file_handler.setLevel(logging.DEBUG)
+        file_formatter = StructuredFormatter("%(asctime)s [%(levelname)s] %(message)s")
+        file_handler.setFormatter(file_formatter)
+        self.logger.addHandler(file_handler)
+        self._file_handler = file_handler
+        self._file_handler_path = log_file
+        return log_file
+
+    def debug(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log debug message."""
-        self.logger.debug(message)
+        self.logger.debug(message, *args, **kwargs)
 
-    def info(self, message: str) -> None:
+    def info(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log info message."""
-        self.logger.info(message)
+        self.logger.info(message, *args, **kwargs)
 
-    def warning(self, message: str) -> None:
+    def warning(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log warning message."""
-        self.logger.warning(message)
+        self.logger.warning(message, *args, **kwargs)
 
-    def error(self, message: str) -> None:
+    def error(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log error message."""
-        self.logger.error(message)
+        self.logger.error(message, *args, **kwargs)
 
-    def critical(self, message: str) -> None:
+    def critical(self, message: str, *args: Any, **kwargs: Any) -> None:
         """Log critical message."""
-        self.logger.critical(message)
+        self.logger.critical(message, *args, **kwargs)
+
+    def exception(self, message: str, *args: Any, **kwargs: Any) -> None:
+        """Log an exception with traceback."""
+        self.logger.exception(message, *args, **kwargs)
 
 
 # Global logger instance
@@ -69,8 +148,29 @@ def get_logger() -> RipperdocLogger:
     return _logger
 
 
+def _normalize_path_for_logs(project_path: Path) -> Path:
+    """Return the directory for log files for a given project."""
+    safe_name = sanitize_project_path(project_path)
+    return Path.home() / ".ripperdoc" / "logs" / safe_name
+
+
+def session_log_path(project_path: Path, session_id: str, when: Optional[datetime] = None) -> Path:
+    """Build the log file path for a project session."""
+    timestamp = (when or datetime.now()).strftime("%Y%m%d-%H%M%S")
+    return _normalize_path_for_logs(project_path) / f"{timestamp}-{session_id}.log"
+
+
 def init_logger(log_dir: Optional[Path] = None) -> RipperdocLogger:
     """Initialize the global logger."""
     global _logger
     _logger = RipperdocLogger(log_dir=log_dir)
     return _logger
+
+
+def enable_session_file_logging(project_path: Path, session_id: str) -> Path:
+    """Ensure the global logger writes to the session-specific log file."""
+    logger = get_logger()
+    log_file = session_log_path(project_path, session_id)
+    logger.attach_file_handler(log_file)
+    logger.debug(f"[logging] File logging enabled at {log_file}")
+    return log_file

ripperdoc/utils/mcp.py

@@ -14,6 +14,8 @@ from ripperdoc import __version__
 from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.message_compaction import estimate_tokens_from_text
 
+logger = get_logger()
+
 try:
     import mcp.types as mcp_types
     from mcp.client.session import ClientSession
@@ -26,9 +28,7 @@ except Exception:  # pragma: no cover - handled gracefully at runtime
     MCP_AVAILABLE = False
     ClientSession = object  # type: ignore
     mcp_types = None  # type: ignore
-
-
-logger = get_logger()
+    logger.exception("[mcp] MCP SDK not available at import time")
 
 
 @dataclass
@@ -76,8 +76,8 @@ def _load_json_file(path: Path) -> Dict[str, Any]:
         if isinstance(data, dict):
             return data
         return {}
-    except (OSError, json.JSONDecodeError) as exc:
-        logger.error(f"Failed to load JSON from {path}: {exc}")
+    except (OSError, json.JSONDecodeError):
+        logger.exception("Failed to load JSON", extra={"path": str(path)})
         return {}
 
 
@@ -89,6 +89,10 @@ def _ensure_str_dict(raw: object) -> Dict[str, str]:
         try:
             result[str(key)] = str(value)
         except Exception:
+            logger.exception(
+                "[mcp] Failed to coerce env/header value to string",
+                extra={"key": key, "value": value},
+            )
             continue
     return result
 
@@ -154,6 +158,14 @@ def _load_server_configs(project_path: Optional[Path]) -> Dict[str, McpServerInf
     for path in candidates:
         data = _load_json_file(path)
         merged.update(_parse_servers(data))
+    logger.debug(
+        "[mcp] Loaded MCP server configs",
+        extra={
+            "project_path": str(project_path),
+            "server_count": len(merged),
+            "candidates": [str(path) for path in candidates],
+        },
+    )
     return merged
 
 
@@ -168,6 +180,14 @@ class McpRuntime:
         self._closed = False
 
     async def connect(self, configs: Dict[str, McpServerInfo]) -> List[McpServerInfo]:
+        logger.info(
+            "[mcp] Connecting to MCP servers",
+            extra={
+                "project_path": str(self.project_path),
+                "server_count": len(configs),
+                "servers": list(configs.keys()),
+            },
+        )
         await self._exit_stack.__aenter__()
         if not MCP_AVAILABLE:
             for config in configs.values():
@@ -182,6 +202,14 @@ class McpRuntime:
 
         for config in configs.values():
             self.servers.append(await self._connect_server(config))
+        logger.debug(
+            "[mcp] MCP connection summary",
+            extra={
+                "connected": [s.name for s in self.servers if s.status == "connected"],
+                "failed": [s.name for s in self.servers if s.status == "failed"],
+                "unavailable": [s.name for s in self.servers if s.status == "unavailable"],
+            },
+        )
         return self.servers
 
     async def _list_roots_callback(self, *_: Any, **__: Any) -> Optional[Any]:
@@ -201,6 +229,15 @@ class McpRuntime:
         try:
             read_stream = None
             write_stream = None
+            logger.debug(
+                "[mcp] Connecting server",
+                extra={
+                    "server": config.name,
+                    "type": config.type,
+                    "command": config.command,
+                    "url": config.url,
+                },
+            )
 
             if config.type in ("sse", "sse-ide"):
                 if not config.url:
@@ -280,8 +317,21 @@ class McpRuntime:
                     for resource in resources_result.resources
                 ]
 
+            logger.info(
+                "[mcp] Connected to MCP server",
+                extra={
+                    "server": config.name,
+                    "status": info.status,
+                    "tools": len(info.tools),
+                    "resources": len(info.resources),
+                    "capabilities": list(info.capabilities.keys()),
+                },
+            )
         except Exception as exc:  # pragma: no cover - network/process errors
-            logger.error(f"Failed to connect to MCP server '{config.name}': {exc}")
+            logger.exception(
+                "Failed to connect to MCP server",
+                extra={"server": config.name, "error": str(exc)},
+            )
             info.status = "failed"
             info.error = str(exc)
 
@@ -291,6 +341,10 @@ class McpRuntime:
         if self._closed:
             return
         self._closed = True
+        logger.debug(
+            "[mcp] Shutting down MCP runtime",
+            extra={"project_path": str(self.project_path), "session_count": len(self.sessions)},
+        )
         try:
             await self._exit_stack.aclose()
         finally:
@@ -316,12 +370,23 @@ async def ensure_mcp_runtime(project_path: Optional[Path] = None) -> McpRuntime:
     runtime = _get_runtime()
     project_path = project_path or Path.cwd()
     if runtime and not runtime._closed and runtime.project_path == project_path:
+        logger.debug(
+            "[mcp] Reusing existing MCP runtime",
+            extra={
+                "project_path": str(project_path),
+                "server_count": len(runtime.servers),
+            },
+        )
         return runtime
 
     if runtime:
         await runtime.aclose()
 
     runtime = McpRuntime(project_path)
+    logger.debug(
+        "[mcp] Creating MCP runtime",
+        extra={"project_path": str(project_path)},
+    )
     configs = _load_server_configs(project_path)
     await runtime.connect(configs)
     _runtime_var.set(runtime)

ripperdoc/utils/memory.py

@@ -6,6 +6,9 @@ import re
 from dataclasses import dataclass
 from pathlib import Path
 from typing import List, Optional, Set
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 MEMORY_FILE_NAME = "AGENTS.md"
 LOCAL_MEMORY_FILE_NAME = "AGENTS.local.md"
@@ -43,6 +46,10 @@ def _is_path_under_directory(path: Path, directory: Path) -> bool:
         path.resolve().relative_to(directory.resolve())
         return True
     except Exception:
+        logger.exception(
+            "[memory] Failed to compare path containment",
+            extra={"path": str(path), "directory": str(directory)},
+        )
         return False
 
 
@@ -65,8 +72,10 @@ def _read_file_with_type(file_path: Path, file_type: str) -> Optional[MemoryFile
         content = file_path.read_text(encoding="utf-8", errors="ignore")
         return MemoryFile(path=str(file_path), type=file_type, content=content)
     except PermissionError:
+        logger.exception("[memory] Permission error reading file", extra={"path": str(file_path)})
         return None
     except OSError:
+        logger.exception("[memory] OS error reading file", extra={"path": str(file_path)})
         return None
 
 
@@ -114,7 +123,9 @@ def _collect_files(
     try:
         resolved_path = resolved_path.resolve()
     except Exception:
-        pass
+        logger.exception(
+            "[memory] Failed to resolve memory file path", extra={"path": str(resolved_path)}
+        )
 
     resolved_key = str(resolved_path)
     if resolved_key in visited:

ripperdoc/utils/message_compaction.py

@@ -22,7 +22,7 @@ logger = get_logger()
 
 ConversationMessage = Union[UserMessage, AssistantMessage, ProgressMessage]
 
-# Compaction thresholds mirror the claude-code compact implementation.
+# Compaction thresholds.
 MAX_TOKENS_SOFT = 20_000
 MAX_TOKENS_HARD = 40_000
 MAX_TOOL_USES_TO_PRESERVE = 3
@@ -172,6 +172,9 @@ def _stringify_content(content: Union[str, List[MessageContent], None]) -> str:
                 try:
                     parts.append(json.dumps(part.get("input"), ensure_ascii=False))
                 except Exception:
+                    logger.exception(
+                        "[message_compaction] Failed to serialize tool_use input for token estimate"
+                    )
                     parts.append(str(part.get("input")))
 
             # OpenAI-style arguments blocks
@@ -225,7 +228,10 @@ def _estimate_tool_schema_tokens(tools: Sequence[Any]) -> int:
             schema_text = json.dumps(schema, sort_keys=True)
             total += estimate_tokens_from_text(schema_text)
         except Exception as exc:
-            logger.error(f"Failed to estimate tokens for tool schema: {exc}")
+            logger.exception(
+                "Failed to estimate tokens for tool schema",
+                extra={"tool": getattr(tool, "name", None), "error": str(exc)},
+            )
             continue
     return total
 
@@ -303,7 +309,7 @@ def get_context_usage_status(
     max_context_tokens: Optional[int],
     auto_compact_enabled: bool,
 ) -> ContextUsageStatus:
-    """Compute context usage thresholds following claude-code semantics."""
+    """Compute context usage thresholds using the compaction heuristics."""
     context_limit = max(max_context_tokens or DEFAULT_CONTEXT_TOKENS, MIN_CONTEXT_TOKENS)
     effective_limit = (
         max(MIN_CONTEXT_TOKENS, context_limit - AUTO_COMPACT_BUFFER)
@@ -396,6 +402,7 @@ def find_latest_assistant_usage_tokens(
             if tokens > 0:
                 return tokens
         except Exception:
+            logger.debug("[message_compaction] Failed to parse usage tokens", exc_info=True)
             continue
     return 0
 
@@ -432,7 +439,7 @@ def _run_cleanup_callbacks() -> None:
         try:
             callback()
         except Exception as exc:
-            logger.debug(f"[message_compaction] Cleanup callback failed: {exc}")
+            logger.debug(f"[message_compaction] Cleanup callback failed: {exc}", exc_info=True)
 
 
 def _normalize_tool_use_id(block: Any) -> str:
@@ -641,16 +648,26 @@ def compact_messages(
         _processed_tool_use_ids.add(id_to_remove)
 
     tokens_after = estimate_conversation_tokens(compacted_messages, protocol=protocol)
+    tokens_saved = max(0, tokens_before - tokens_after)
 
     if ids_to_remove:
         _is_compacting = True
         _run_cleanup_callbacks()
+        logger.debug(
+            "[message_compaction] Compacted conversation",
+            extra={
+                "tokens_before": tokens_before,
+                "tokens_after": tokens_after,
+                "tokens_saved": tokens_saved,
+                "cleared_tool_ids": list(ids_to_remove),
+            },
+        )
 
     return CompactionResult(
         messages=compacted_messages,
         tokens_before=tokens_before,
         tokens_after=tokens_after,
-        tokens_saved=max(0, tokens_before - tokens_after),
+        tokens_saved=tokens_saved,
         cleared_tool_ids=ids_to_remove,
         was_compacted=bool(ids_to_remove),
     )

ripperdoc/utils/messages.py

@@ -4,6 +4,7 @@ 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
 from uuid import uuid4
@@ -30,7 +31,7 @@ class MessageContent(BaseModel):
     id: Optional[str] = None
     tool_use_id: Optional[str] = None
     name: Optional[str] = None
-    input: Optional[Dict[str, Any]] = None
+    input: Optional[Dict[str, object]] = None
     is_error: Optional[bool] = None
 
 
@@ -75,6 +76,7 @@ def _content_block_to_openai(block: MessageContent) -> Dict[str, Any]:
         try:
             args_str = json.dumps(args)
         except Exception:
+            logger.exception("[_content_block_to_openai] Failed to serialize tool arguments")
             args_str = "{}"
         tool_call_id = (
             getattr(block, "id", None) or getattr(block, "tool_use_id", "") or str(uuid4())
@@ -118,7 +120,7 @@ class Message(BaseModel):
     content: Union[str, List[MessageContent]]
     uuid: str = ""
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
@@ -130,9 +132,9 @@ class UserMessage(BaseModel):
     type: str = "user"
     message: Message
     uuid: str = ""
-    tool_use_result: Optional[Any] = None
+    tool_use_result: Optional[object] = None
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
@@ -148,7 +150,7 @@ class AssistantMessage(BaseModel):
     duration_ms: float = 0.0
     is_api_error_message: bool = False
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
@@ -165,14 +167,14 @@ class ProgressMessage(BaseModel):
     sibling_tool_use_ids: set[str] = set()
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def __init__(self, **data: Any) -> None:
+    def __init__(self, **data: object) -> None:
         if "uuid" not in data or not data["uuid"]:
             data["uuid"] = str(uuid4())
         super().__init__(**data)
 
 
 def create_user_message(
-    content: Union[str, List[Dict[str, Any]]], tool_use_result: Optional[Any] = None
+    content: Union[str, List[Dict[str, Any]]], tool_use_result: Optional[object] = None
 ) -> UserMessage:
     """Create a user message."""
     if isinstance(content, str):
@@ -187,7 +189,7 @@ def create_user_message(
                 tool_use_result = tool_use_result.model_dump()
         except Exception:
             # Fallback: keep as-is if conversion fails
-            pass
+            logger.exception("[create_user_message] Failed to normalize tool_use_result")
 
     message = Message(role=MessageRole.USER, content=message_content)
 
@@ -237,6 +239,7 @@ def create_progress_message(
 def normalize_messages_for_api(
     messages: List[Union[UserMessage, AssistantMessage, ProgressMessage]],
     protocol: str = "anthropic",
+    tool_mode: str = "native",
 ) -> List[Dict[str, Any]]:
     """Normalize messages for API submission.
 
@@ -261,6 +264,62 @@ def normalize_messages_for_api(
                 return msg.get("content")
         return None
 
+    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 Exception:
+                        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"
+
     normalized: List[Dict[str, Any]] = []
     tool_results_seen = 0
     tool_uses_seen = 0
@@ -312,9 +371,7 @@ def normalize_messages_for_api(
                     api_blocks.append(_content_block_to_api(block))
                 normalized.append({"role": "user", "content": api_blocks})
             else:
-                normalized.append(
-                    {"role": "user", "content": user_content}  # type: ignore
-                )
+                normalized.append({"role": "user", "content": user_content})  # type: ignore
         elif msg_type == "assistant":
             asst_content = _msg_content(msg)
             if isinstance(asst_content, list):
@@ -369,14 +426,12 @@ def normalize_messages_for_api(
                     api_blocks.append(_content_block_to_api(block))
                 normalized.append({"role": "assistant", "content": api_blocks})
             else:
-                normalized.append(
-                    {"role": "assistant", "content": asst_content}  # type: ignore
-                )
+                normalized.append({"role": "assistant", "content": asst_content})  # type: ignore
 
     logger.debug(
-        f"[normalize_messages_for_api] protocol={protocol} input_msgs={len(messages)} "
-        f"normalized={len(normalized)} tool_results_seen={tool_results_seen} "
-        f"tool_uses_seen={tool_uses_seen} "
+        f"[normalize_messages_for_api] protocol={protocol} tool_mode={effective_tool_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)} "
         f"skipped_tool_uses_no_result={skipped_tool_uses_no_result} "
         f"skipped_tool_uses_no_id={skipped_tool_uses_no_id}"