code-puppy 0.0.317__py3-none-any.whl → 0.0.319__py3-none-any.whl

code_puppy/command_line/mcp/logs_command.py

@@ -1,14 +1,21 @@
 """
-MCP Logs Command - Shows recent events/logs for a server.
+MCP Logs Command - Shows server logs from persistent log files.
 """
 
 import logging
-from datetime import datetime
 from typing import List, Optional
 
-from rich.table import Table
+from rich.panel import Panel
+from rich.syntax import Syntax
 from rich.text import Text
 
+from code_puppy.mcp_.mcp_logs import (
+    clear_logs,
+    get_log_file_path,
+    get_log_stats,
+    list_servers_with_logs,
+    read_logs,
+)
 from code_puppy.messaging import emit_error, emit_info
 
 from .base import MCPCommandBase
@@ -22,105 +29,207 @@ class LogsCommand(MCPCommandBase):
     """
     Command handler for showing MCP server logs.
 
-    Shows recent events/logs for a specific MCP server with configurable limit.
+    Shows logs from persistent log files stored in ~/.code_puppy/mcp_logs/.
     """
 
     def execute(self, args: List[str], group_id: Optional[str] = None) -> None:
         """
-        Show recent events/logs for a server.
+        Show logs for a server.
+
+        Usage:
+            /mcp logs                    - List servers with logs
+            /mcp logs <server_name>      - Show last 50 lines
+            /mcp logs <server_name> 100  - Show last 100 lines
+            /mcp logs <server_name> all  - Show all logs
+            /mcp logs <server_name> --clear - Clear logs for server
 
         Args:
-            args: Command arguments, expects [server_name] and optional [limit]
+            args: Command arguments
             group_id: Optional message group ID for grouping related messages
         """
         if group_id is None:
             group_id = self.generate_group_id()
 
+        # No args - list servers with logs
         if not args:
-            emit_info("Usage: /mcp logs <server_name> [limit]", message_group=group_id)
+            self._list_servers_with_logs(group_id)
             return
 
         server_name = args[0]
-        limit = 10  # Default limit
+
+        # Check for --clear flag
+        if len(args) > 1 and args[1] == "--clear":
+            self._clear_logs(server_name, group_id)
+            return
+
+        # Determine number of lines
+        lines = 50  # Default
+        show_all = False
 
         if len(args) > 1:
-            try:
-                limit = int(args[1])
-                if limit <= 0 or limit > 100:
+            if args[1].lower() == "all":
+                show_all = True
+            else:
+                try:
+                    lines = int(args[1])
+                    if lines <= 0:
+                        emit_info(
+                            "Lines must be positive, using default: 50",
+                            message_group=group_id,
+                        )
+                        lines = 50
+                except ValueError:
                     emit_info(
-                        "Limit must be between 1 and 100, using default: 10",
+                        f"Invalid number '{args[1]}', using default: 50",
                         message_group=group_id,
                     )
-                    limit = 10
-            except ValueError:
-                emit_info(
-                    f"Invalid limit '{args[1]}', using default: 10",
-                    message_group=group_id,
-                )
 
+        self._show_logs(server_name, lines if not show_all else None, group_id)
+
+    def _list_servers_with_logs(self, group_id: str) -> None:
+        """List all servers that have log files."""
+        servers = list_servers_with_logs()
+
+        if not servers:
+            emit_info(
+                "📋 No MCP server logs found.\n"
+                "Logs are created when servers are started.",
+                message_group=group_id,
+            )
+            return
+
+        lines = ["📋 **Servers with logs:**\n"]
+
+        for server in servers:
+            stats = get_log_stats(server)
+            size_kb = stats["total_size_bytes"] / 1024
+            size_str = (
+                f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb / 1024:.1f} MB"
+            )
+            rotated = (
+                f" (+{stats['rotated_count']} rotated)"
+                if stats["rotated_count"]
+                else ""
+            )
+            lines.append(
+                f"  • **{server}** - {stats['line_count']} lines, {size_str}{rotated}"
+            )
+
+        lines.append("\n**Usage:** `/mcp logs <server_name> [lines|all]`")
+
+        emit_info("\n".join(lines), message_group=group_id)
+
+    def _show_logs(self, server_name: str, lines: Optional[int], group_id: str) -> None:
+        """
+        Show logs for a specific server.
+
+        Args:
+            server_name: Name of the server
+            lines: Number of lines to show, or None for all
+            group_id: Message group ID
+        """
         try:
-            # Find server by name
+            # Verify server exists in manager
             server_id = find_server_id_by_name(self.manager, server_name)
             if not server_id:
-                emit_info(f"Server '{server_name}' not found", message_group=group_id)
-                suggest_similar_servers(self.manager, server_name, group_id=group_id)
-                return
+                # Server not configured, but might have logs from before
+                stats = get_log_stats(server_name)
+                if not stats["exists"]:
+                    emit_info(
+                        f"Server '{server_name}' not found and has no logs.",
+                        message_group=group_id,
+                    )
+                    suggest_similar_servers(
+                        self.manager, server_name, group_id=group_id
+                    )
+                    return
 
-            # Get server status which includes recent events
-            status = self.manager.get_server_status(server_id)
+            # Read logs
+            log_lines = read_logs(server_name, lines=lines)
 
-            if not status.get("exists", True):
+            if not log_lines:
                 emit_info(
-                    f"Server '{server_name}' status not available",
+                    f"📋 No logs found for server: **{server_name}**\n"
+                    f"Log file: `{get_log_file_path(server_name)}`",
                     message_group=group_id,
                 )
                 return
 
-            recent_events = status.get("recent_events", [])
-
-            if not recent_events:
-                emit_info(
-                    f"No recent events for server: {server_name}",
-                    message_group=group_id,
+            # Get stats for header
+            stats = get_log_stats(server_name)
+            total_lines = stats["line_count"]
+            showing = len(log_lines)
+
+            # Format header
+            if lines is None:
+                header = f"📋 Logs for {server_name} (all {total_lines} lines)"
+            else:
+                header = (
+                    f"📋 Logs for {server_name} (last {showing} of {total_lines} lines)"
                 )
-                return
 
-            # Show events in a table
-            table = Table(title=f"📋 Recent Events for {server_name} (last {limit})")
-            table.add_column("Time", style="dim", no_wrap=True)
-            table.add_column("Event", style="cyan")
-            table.add_column("Details", style="dim")
+            # Format log content with syntax highlighting
+            log_content = "\n".join(log_lines)
+
+            # Create a panel with the logs
+            syntax = Syntax(
+                log_content,
+                "log",
+                theme="monokai",
+                word_wrap=True,
+                line_numbers=False,
+            )
 
-            # Take only the requested number of events
-            events_to_show = (
-                recent_events[-limit:] if len(recent_events) > limit else recent_events
+            panel = Panel(
+                syntax,
+                title=header,
+                subtitle=f"Log file: {get_log_file_path(server_name)}",
+                border_style="dim",
             )
 
-            for event in reversed(events_to_show):  # Show newest first
-                timestamp = datetime.fromisoformat(event["timestamp"])
-                time_str = timestamp.strftime("%H:%M:%S")
-                event_type = event["event_type"]
-
-                # Format details
-                details = event.get("details", {})
-                details_str = details.get("message", "")
-                if not details_str and "error" in details:
-                    details_str = str(details["error"])
-
-                # Color code event types
-                event_style = "cyan"
-                if "error" in event_type.lower():
-                    event_style = "red"
-                elif event_type in ["started", "enabled", "registered"]:
-                    event_style = "green"
-                elif event_type in ["stopped", "disabled"]:
-                    event_style = "yellow"
-
-                table.add_row(
-                    time_str, Text(event_type, style=event_style), details_str or "-"
+            emit_info(panel, message_group=group_id)
+
+            # Show hint for more options
+            if lines is not None and showing < total_lines:
+                emit_info(
+                    Text.from_markup(
+                        f"[dim]💡 Use `/mcp logs {server_name} all` to see all logs, "
+                        f"or `/mcp logs {server_name} <number>` for specific count[/dim]"
+                    ),
+                    message_group=group_id,
                 )
-            emit_info(table, message_group=group_id)
 
         except Exception as e:
             logger.error(f"Error getting logs for server '{server_name}': {e}")
             emit_error(f"Error getting logs: {e}", message_group=group_id)
+
+    def _clear_logs(self, server_name: str, group_id: str) -> None:
+        """
+        Clear logs for a specific server.
+
+        Args:
+            server_name: Name of the server
+            group_id: Message group ID
+        """
+        try:
+            stats = get_log_stats(server_name)
+
+            if not stats["exists"] and stats["rotated_count"] == 0:
+                emit_info(
+                    f"No logs to clear for server: {server_name}",
+                    message_group=group_id,
+                )
+                return
+
+            # Clear the logs
+            clear_logs(server_name, include_rotated=True)
+
+            cleared_count = 1 + stats["rotated_count"]
+            emit_info(
+                f"🗑️  Cleared {cleared_count} log file(s) for **{server_name}**",
+                message_group=group_id,
+            )
+
+        except Exception as e:
+            logger.error(f"Error clearing logs for server '{server_name}': {e}")
+            emit_error(f"Error clearing logs: {e}", message_group=group_id)

code_puppy/command_line/model_settings_menu.py

@@ -84,6 +84,12 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "default": 10000,
         "format": "{:.0f}",
     },
+    "interleaved_thinking": {
+        "name": "Interleaved Thinking",
+        "description": "Enable thinking between tool calls (Claude 4 only: Opus 4.5, Opus 4.1, Opus 4, Sonnet 4). Adds beta header. WARNING: On Vertex/Bedrock, this FAILS for non-Claude 4 models!",
+        "type": "boolean",
+        "default": False,
+    },
 }
 
 

code_puppy/mcp_/__init__.py

@@ -17,6 +17,15 @@ from .error_isolation import (
 )
 from .managed_server import ManagedMCPServer, ServerConfig, ServerState
 from .manager import MCPManager, ServerInfo, get_mcp_manager
+from .mcp_logs import (
+    clear_logs,
+    get_log_file_path,
+    get_log_stats,
+    get_mcp_logs_dir,
+    list_servers_with_logs,
+    read_logs,
+    write_log,
+)
 from .registry import ServerRegistry
 from .retry_manager import RetryManager, RetryStats, get_retry_manager, retry_mcp_call
 from .status_tracker import Event, ServerStatusTracker
@@ -46,4 +55,12 @@ __all__ = [
     "MCPDashboard",
     "MCPConfigWizard",
     "run_add_wizard",
+    # Log management
+    "get_mcp_logs_dir",
+    "get_log_file_path",
+    "read_logs",
+    "write_log",
+    "clear_logs",
+    "list_servers_with_logs",
+    "get_log_stats",
 ]

code_puppy/mcp_/blocking_startup.py

@@ -2,14 +2,13 @@
 MCP Server with blocking startup capability and stderr capture.
 
 This module provides MCP servers that:
-1. Capture stderr output from stdio servers
+1. Capture stderr output from stdio servers to persistent log files
 2. Block until fully initialized before allowing operations
-3. Emit stderr to users via emit_info with message groups
+3. Optionally emit stderr to users (disabled by default to reduce console noise)
 """
 
 import asyncio
 import os
-import tempfile
 import threading
 import uuid
 from contextlib import asynccontextmanager
@@ -18,56 +17,73 @@ from typing import List, Optional
 from mcp.client.stdio import StdioServerParameters, stdio_client
 from pydantic_ai.mcp import MCPServerStdio
 
+from code_puppy.mcp_.mcp_logs import get_log_file_path, rotate_log_if_needed, write_log
 from code_puppy.messaging import emit_info
 
 
 class StderrFileCapture:
-    """Captures stderr to a file and monitors it in a background thread."""
+    """
+    Captures stderr to a persistent log file and optionally monitors it.
+
+    Logs are written to ~/.code_puppy/mcp_logs/<server_name>.log
+    """
 
     def __init__(
         self,
         server_name: str,
-        emit_to_user: bool = True,
+        emit_to_user: bool = False,  # Disabled by default to reduce console noise
         message_group: Optional[uuid.UUID] = None,
     ):
         self.server_name = server_name
         self.emit_to_user = emit_to_user
         self.message_group = message_group or uuid.uuid4()
-        self.temp_file = None
-        self.temp_path = None
+        self.log_file = None
+        self.log_path = None
         self.monitor_thread = None
         self.stop_monitoring = threading.Event()
         self.captured_lines = []
+        self._last_read_pos = 0
 
     def start(self):
-        """Start capture by creating temp file and monitor thread."""
-        # Create temp file
-        self.temp_file = tempfile.NamedTemporaryFile(
-            mode="w+", delete=False, suffix=".err"
-        )
-        self.temp_path = self.temp_file.name
+        """Start capture by opening persistent log file and monitor thread."""
+        # Rotate log if needed
+        rotate_log_if_needed(self.server_name)
+
+        # Get persistent log path
+        self.log_path = get_log_file_path(self.server_name)
+
+        # Write startup marker
+        write_log(self.server_name, "--- Server starting ---", "INFO")
 
-        # Start monitoring thread
+        # Open log file for appending stderr
+        self.log_file = open(self.log_path, "a", encoding="utf-8")
+
+        # Start monitoring thread only if we need to emit to user or capture lines
         self.stop_monitoring.clear()
         self.monitor_thread = threading.Thread(target=self._monitor_file)
         self.monitor_thread.daemon = True
         self.monitor_thread.start()
 
-        return self.temp_file
+        return self.log_file
 
     def _monitor_file(self):
-        """Monitor the temp file for new content."""
-        if not self.temp_path:
+        """Monitor the log file for new content."""
+        if not self.log_path:
             return
 
-        last_pos = 0
+        # Start reading from current position (end of file before we started)
+        try:
+            self._last_read_pos = os.path.getsize(self.log_path)
+        except OSError:
+            self._last_read_pos = 0
+
         while not self.stop_monitoring.is_set():
             try:
-                with open(self.temp_path, "r") as f:
-                    f.seek(last_pos)
+                with open(self.log_path, "r", encoding="utf-8", errors="replace") as f:
+                    f.seek(self._last_read_pos)
                     new_content = f.read()
                     if new_content:
-                        last_pos = f.tell()
+                        self._last_read_pos = f.tell()
                         # Process new lines
                         for line in new_content.splitlines():
                             if line.strip():
@@ -89,16 +105,21 @@ class StderrFileCapture:
         if self.monitor_thread:
             self.monitor_thread.join(timeout=1)
 
-        if self.temp_file:
+        if self.log_file:
             try:
-                self.temp_file.close()
+                self.log_file.flush()
+                self.log_file.close()
             except Exception:
                 pass
 
-        if self.temp_path and os.path.exists(self.temp_path):
+        # Write shutdown marker
+        write_log(self.server_name, "--- Server stopped ---", "INFO")
+
+        # Read any remaining content for in-memory capture
+        if self.log_path and os.path.exists(self.log_path):
             try:
-                # Read any remaining content
-                with open(self.temp_path, "r") as f:
+                with open(self.log_path, "r", encoding="utf-8", errors="replace") as f:
+                    f.seek(self._last_read_pos)
                     content = f.read()
                     for line in content.splitlines():
                         if line.strip() and line not in self.captured_lines:
@@ -108,13 +129,13 @@ class StderrFileCapture:
                                     f"MCP {self.server_name}: {line}",
                                     message_group=self.message_group,
                                 )
-
-                os.unlink(self.temp_path)
             except Exception:
                 pass
 
+        # Note: We do NOT delete the log file - it's persistent now!
+
     def get_captured_lines(self) -> List[str]:
-        """Get all captured lines."""
+        """Get all captured lines from this session."""
         return self.captured_lines.copy()
 
 

code_puppy/mcp_/managed_server.py

@@ -204,7 +204,7 @@ class ManagedMCPServer:
                     **stdio_kwargs,
                     process_tool_call=process_tool_call,
                     tool_prefix=self.config.name,
-                    emit_stderr=True,  # Always emit stderr for now
+                    emit_stderr=False,  # Logs go to file, not console (use /mcp logs to view)
                     message_group=message_group,
                 )
 

code_puppy/mcp_/mcp_logs.py

@@ -0,0 +1,224 @@
+"""
+MCP Server Log Management.
+
+This module provides persistent log file management for MCP servers.
+Logs are stored in STATE_DIR/mcp_logs/<server_name>.log
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from code_puppy.config import STATE_DIR
+
+# Maximum log file size in bytes (5MB)
+MAX_LOG_SIZE = 5 * 1024 * 1024
+
+# Number of rotated logs to keep
+MAX_ROTATED_LOGS = 3
+
+
+def get_mcp_logs_dir() -> Path:
+    """
+    Get the directory for MCP server logs.
+
+    Creates the directory if it doesn't exist.
+
+    Returns:
+        Path to the MCP logs directory
+    """
+    logs_dir = Path(STATE_DIR) / "mcp_logs"
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    return logs_dir
+
+
+def get_log_file_path(server_name: str) -> Path:
+    """
+    Get the log file path for a specific server.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        Path to the server's log file
+    """
+    # Sanitize server name for filesystem
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+    return get_mcp_logs_dir() / f"{safe_name}.log"
+
+
+def rotate_log_if_needed(server_name: str) -> None:
+    """
+    Rotate log file if it exceeds MAX_LOG_SIZE.
+
+    Args:
+        server_name: Name of the MCP server
+    """
+    log_path = get_log_file_path(server_name)
+
+    if not log_path.exists():
+        return
+
+    # Check if rotation is needed
+    if log_path.stat().st_size < MAX_LOG_SIZE:
+        return
+
+    logs_dir = get_mcp_logs_dir()
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+    # Remove oldest rotated log if we're at the limit
+    oldest = logs_dir / f"{safe_name}.log.{MAX_ROTATED_LOGS}"
+    if oldest.exists():
+        oldest.unlink()
+
+    # Shift existing rotated logs
+    for i in range(MAX_ROTATED_LOGS - 1, 0, -1):
+        old_path = logs_dir / f"{safe_name}.log.{i}"
+        new_path = logs_dir / f"{safe_name}.log.{i + 1}"
+        if old_path.exists():
+            old_path.rename(new_path)
+
+    # Rotate current log
+    rotated_path = logs_dir / f"{safe_name}.log.1"
+    log_path.rename(rotated_path)
+
+
+def write_log(server_name: str, message: str, level: str = "INFO") -> None:
+    """
+    Write a log message for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        message: Log message to write
+        level: Log level (INFO, ERROR, WARN, DEBUG)
+    """
+    rotate_log_if_needed(server_name)
+
+    log_path = get_log_file_path(server_name)
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(f"[{timestamp}] [{level}] {message}\n")
+
+
+def read_logs(
+    server_name: str, lines: Optional[int] = None, include_rotated: bool = False
+) -> List[str]:
+    """
+    Read log lines for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        lines: Number of lines to return (from end). None means all lines.
+        include_rotated: Whether to include rotated log files
+
+    Returns:
+        List of log lines (most recent last)
+    """
+    all_lines = []
+
+    # Read rotated logs first (oldest to newest)
+    if include_rotated:
+        logs_dir = get_mcp_logs_dir()
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+        for i in range(MAX_ROTATED_LOGS, 0, -1):
+            rotated_path = logs_dir / f"{safe_name}.log.{i}"
+            if rotated_path.exists():
+                with open(rotated_path, "r", encoding="utf-8", errors="replace") as f:
+                    all_lines.extend(f.read().splitlines())
+
+    # Read current log
+    log_path = get_log_file_path(server_name)
+    if log_path.exists():
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            all_lines.extend(f.read().splitlines())
+
+    # Return requested number of lines
+    if lines is not None and lines > 0:
+        return all_lines[-lines:]
+
+    return all_lines
+
+
+def clear_logs(server_name: str, include_rotated: bool = True) -> None:
+    """
+    Clear logs for a server.
+
+    Args:
+        server_name: Name of the MCP server
+        include_rotated: Whether to also clear rotated log files
+    """
+    log_path = get_log_file_path(server_name)
+
+    if log_path.exists():
+        log_path.unlink()
+
+    if include_rotated:
+        logs_dir = get_mcp_logs_dir()
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+        for i in range(1, MAX_ROTATED_LOGS + 1):
+            rotated_path = logs_dir / f"{safe_name}.log.{i}"
+            if rotated_path.exists():
+                rotated_path.unlink()
+
+
+def list_servers_with_logs() -> List[str]:
+    """
+    List all servers that have log files.
+
+    Returns:
+        List of server names with log files
+    """
+    logs_dir = get_mcp_logs_dir()
+    servers = set()
+
+    for path in logs_dir.glob("*.log*"):
+        # Extract server name from filename
+        name = path.stem
+        # Remove .log suffix and rotation numbers
+        name = name.replace(".log", "").rstrip(".0123456789")
+        if name:
+            servers.add(name)
+
+    return sorted(servers)
+
+
+def get_log_stats(server_name: str) -> dict:
+    """
+    Get statistics about a server's logs.
+
+    Args:
+        server_name: Name of the MCP server
+
+    Returns:
+        Dictionary with log statistics
+    """
+    log_path = get_log_file_path(server_name)
+
+    stats = {
+        "exists": log_path.exists(),
+        "size_bytes": 0,
+        "line_count": 0,
+        "rotated_count": 0,
+        "total_size_bytes": 0,
+    }
+
+    if log_path.exists():
+        stats["size_bytes"] = log_path.stat().st_size
+        stats["total_size_bytes"] = stats["size_bytes"]
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
+            stats["line_count"] = sum(1 for _ in f)
+
+    # Count rotated logs
+    logs_dir = get_mcp_logs_dir()
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in server_name)
+
+    for i in range(1, MAX_ROTATED_LOGS + 1):
+        rotated_path = logs_dir / f"{safe_name}.log.{i}"
+        if rotated_path.exists():
+            stats["rotated_count"] += 1
+            stats["total_size_bytes"] += rotated_path.stat().st_size
+
+    return stats

code_puppy/model_factory.py

@@ -319,9 +319,21 @@ class ModelFactory:
                 http2=http2_enabled,
             )
 
+            # Check if interleaved thinking is enabled for this model
+            # Only applies to Claude 4 models (Opus 4.5, Opus 4.1, Opus 4, Sonnet 4)
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", False)
+
+            default_headers = {}
+            if interleaved_thinking:
+                default_headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             anthropic_client = AsyncAnthropic(
                 api_key=api_key,
                 http_client=client,
+                default_headers=default_headers if default_headers else None,
             )
 
             # Ensure cache_control is injected at the Anthropic SDK layer
@@ -351,10 +363,21 @@ class ModelFactory:
                 http2=http2_enabled,
             )
 
+            # Check if interleaved thinking is enabled for this model
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", False)
+
+            default_headers = {}
+            if interleaved_thinking:
+                default_headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             anthropic_client = AsyncAnthropic(
                 base_url=url,
                 http_client=client,
                 api_key=api_key,
+                default_headers=default_headers if default_headers else None,
             )
 
             # Ensure cache_control is injected at the Anthropic SDK layer
@@ -370,6 +393,31 @@ class ModelFactory:
                 )
                 return None
 
+            # Check if interleaved thinking is enabled (defaults to True for OAuth models)
+            from code_puppy.config import get_effective_model_settings
+
+            effective_settings = get_effective_model_settings(model_name)
+            interleaved_thinking = effective_settings.get("interleaved_thinking", True)
+
+            # Handle anthropic-beta header based on interleaved_thinking setting
+            if "anthropic-beta" in headers:
+                beta_parts = [p.strip() for p in headers["anthropic-beta"].split(",")]
+                if interleaved_thinking:
+                    # Ensure interleaved-thinking is in the header
+                    if "interleaved-thinking-2025-05-14" not in beta_parts:
+                        beta_parts.append("interleaved-thinking-2025-05-14")
+                else:
+                    # Remove interleaved-thinking from the header
+                    beta_parts = [
+                        p for p in beta_parts if "interleaved-thinking" not in p
+                    ]
+                headers["anthropic-beta"] = ",".join(beta_parts) if beta_parts else None
+                if headers.get("anthropic-beta") is None:
+                    del headers["anthropic-beta"]
+            elif interleaved_thinking:
+                # No existing beta header, add one for interleaved thinking
+                headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
+
             # Use a dedicated client wrapper that injects cache_control on /v1/messages
             if verify is None:
                 verify = get_cert_bundle_path()

code_puppy/models.json

@@ -81,7 +81,7 @@
     "type": "anthropic",
     "name": "claude-opus-4-5",
     "context_length": 200000,
-    "supported_settings": ["temperature", "extended_thinking", "budget_tokens"]
+    "supported_settings": ["temperature", "extended_thinking", "budget_tokens", "interleaved_thinking"]
   },
   "zai-glm-4.6-coding": {
     "type": "zai_coding",

code_puppy/plugins/claude_code_oauth/utils.py

@@ -368,6 +368,7 @@ def add_models_to_extra_config(models: List[str]) -> bool:
                     "temperature",
                     "extended_thinking",
                     "budget_tokens",
+                    "interleaved_thinking",
                 ],
             }
             added += 1

{code_puppy-0.0.317.data → code_puppy-0.0.319.data}/data/code_puppy/models.json

@@ -81,7 +81,7 @@
     "type": "anthropic",
     "name": "claude-opus-4-5",
     "context_length": 200000,
-    "supported_settings": ["temperature", "extended_thinking", "budget_tokens"]
+    "supported_settings": ["temperature", "extended_thinking", "budget_tokens", "interleaved_thinking"]
   },
   "zai-glm-4.6-coding": {
     "type": "zai_coding",

{code_puppy-0.0.317.dist-info → code_puppy-0.0.319.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.317
+Version: 0.0.319
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.317.dist-info → code_puppy-0.0.319.dist-info}/RECORD

@@ -10,9 +10,9 @@ code_puppy/gemini_code_assist.py,sha256=KGS7sO5OLc83nDF3xxS-QiU6vxW9vcm6hmzilu79
 code_puppy/http_utils.py,sha256=w5mWYIGIWJZJvgvMahXs9BmdidoJvGn4CASDRY88a8o,13414
 code_puppy/keymap.py,sha256=Uzvq7HB-6inTjKox-90JWzuijztRdWqhJpfTDZVy5no,3235
 code_puppy/main.py,sha256=82r3vZy_XcyEsenLn82BnUusaoyL3Bpm_Th_jKgqecE,273
-code_puppy/model_factory.py,sha256=2jXTpi3BuFO8RtbhKKRvb5EN02w_OKzQSdsTdSy78X0,31608
+code_puppy/model_factory.py,sha256=H_a5nX462Q-dhX3g3ZY7dmBCIAUOd1aOSZa4HMxF1o4,34191
 code_puppy/model_utils.py,sha256=NU8W8NW5F7QS_PXHaLeh55Air1koUV7IVYFP7Rz3XpY,3615
-code_puppy/models.json,sha256=nbMCW9SJxWptVEOeMrn_gfyDp-lsbM7Chczjl944GKA,3077
+code_puppy/models.json,sha256=mTpmJH0UJlmX8M2KVPbxMWb99de3IxKXCWO-B23b6xo,3101
 code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
 code_puppy/models_dev_parser.py,sha256=8ndmWrsSyKbXXpRZPXc0w6TfWMuCcgaHiMifmlaBaPc,20611
 code_puppy/pydantic_patches.py,sha256=YecAEeCOjSIwIBu2O5vEw72atMSL37cXGrbEuukI07o,4582
@@ -56,7 +56,7 @@ code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwo
 code_puppy/command_line/load_context_completion.py,sha256=a3JvLDeLLSYxVgTjAdqWzS4spjv6ccCrK2LKZgVJ1IM,2202
 code_puppy/command_line/mcp_completion.py,sha256=eKzW2O7gun7HoHekOW0XVXhNS5J2xCtK7aaWyA8bkZk,6952
 code_puppy/command_line/model_picker_completion.py,sha256=nDnlf0qFCG2zAm_mWW2eMYwVC7eROVQrFe92hZqOKa8,6810
-code_puppy/command_line/model_settings_menu.py,sha256=-GDJyvkFeEIs-fYTvkBPxyVjmMo9CJRrwUq_IuiEbqY,31935
+code_puppy/command_line/model_settings_menu.py,sha256=O5nPp_OyShFcXzpSmsCeYsnnVNrSwcTBFY9bzcayvj0,32263
 code_puppy/command_line/motd.py,sha256=OoNxwewsckexSgJ5H5y40IawP-TzqlqY-rqFUdRbIhs,2186
 code_puppy/command_line/pin_command_completion.py,sha256=juSvdqRpk7AdfkPy1DJx5NzfEUU5KYGlChvP0hisM18,11667
 code_puppy/command_line/prompt_toolkit_completion.py,sha256=x4Of32g8oH9ckhx-P6BigV7HUUhhjL8xkvK03uq9HRw,27308
@@ -74,7 +74,7 @@ code_puppy/command_line/mcp/help_command.py,sha256=dU3ekOjjNKxRS-RjUXJZ7PBwmJeIe
 code_puppy/command_line/mcp/install_command.py,sha256=lmUyMUWtkGuy1SOQRHjQgt8mD3t1agVMQfEL5_TOzTM,8364
 code_puppy/command_line/mcp/install_menu.py,sha256=lUg7x43aK4NRIS3XrPhvhmcQwjyNb-rzrL-2GL6oYiw,24558
 code_puppy/command_line/mcp/list_command.py,sha256=UKQFPlhT9qGMCyG5VKjvnSMzDDtfAhIaKU_eErgZJDg,3181
-code_puppy/command_line/mcp/logs_command.py,sha256=NcY3S-fMWNQdsdbc07-mvEAFdfWZKavFrjPBzxUCCf0,4455
+code_puppy/command_line/mcp/logs_command.py,sha256=IZzOadnI2ch6j4AcdjuHwJYJWKw1_K1rrCh9_aVK94k,7759
 code_puppy/command_line/mcp/remove_command.py,sha256=hyU_tKJWfyLnmufrFVLwlF0qFEbghXBVMOvSgWvaEgA,2755
 code_puppy/command_line/mcp/restart_command.py,sha256=w5EcDac09iCvPBAR0u2M5KSIhASqTu5uZwsjCJ4JLhk,3588
 code_puppy/command_line/mcp/search_command.py,sha256=mDkSz_KjPbvlO9U7oYUKJlqqY4QM90gWKO2xsH2i3SA,4244
@@ -86,17 +86,18 @@ code_puppy/command_line/mcp/stop_command.py,sha256=iMzk9h6NuUDg0hhI5eDLem5VS8IwB
 code_puppy/command_line/mcp/test_command.py,sha256=eV8u5KKClRK1M2_os1zA78b9TDuYUG_uEk7AfMfD2HY,3691
 code_puppy/command_line/mcp/utils.py,sha256=0Wt4ttYgSlVvtusYmBLKXSkjAjcsDiUxcZQAoFLUNnE,3625
 code_puppy/command_line/mcp/wizard_utils.py,sha256=M5X8RchkQujKYKORsXJnUq2kJHzmNfutIUrsHmfzi7k,11126
-code_puppy/mcp_/__init__.py,sha256=UZ6ZYEIN8At3Jq88ZTkrVQHswNMxHyIBz4hbOn71osk,1444
+code_puppy/mcp_/__init__.py,sha256=P9bmVX5UDmzQDqHMylOxuo5Hi82E30pPSMOYw8lEx7Q,1781
 code_puppy/mcp_/async_lifecycle.py,sha256=pTQrwQCVgjad8EJeRTSHtIeSQRgT_8r5BeLv-1SgKog,7772
-code_puppy/mcp_/blocking_startup.py,sha256=5HMI0fweo5f62kPelC3GaVikbmbm51_TBZg557fmOlc,13715
+code_puppy/mcp_/blocking_startup.py,sha256=27R2wwLVDu5i19IP90KmCn_zHrvVcHVNU8d9c8EcTeI,14780
 code_puppy/mcp_/captured_stdio_server.py,sha256=t_mnCjtiopRsyi4Aa97rFzDVxEQmb-u94sWJsj2FP8k,8925
 code_puppy/mcp_/circuit_breaker.py,sha256=a83YwXux9h4R6zBWBUrCIqtp2ffyl7JZEoK2tErG_0I,8601
 code_puppy/mcp_/config_wizard.py,sha256=JNNpgnSD6PFSyS3pTdEdD164oXd2VKp4VHLSz3ToH1w,16511
 code_puppy/mcp_/dashboard.py,sha256=VtaFxLtPnbM_HL2TXRDAg6IqcM-EcFkoghGgkfhMrKI,9417
 code_puppy/mcp_/error_isolation.py,sha256=mpPBiH17zTXPsOEAn9WmkbwQwnt4gmgiaWv87JBJbUo,12426
 code_puppy/mcp_/health_monitor.py,sha256=n5R6EeYOYbUucUFe74qGWCU3g6Mep5UEQbLF0wbT0dU,19688
-code_puppy/mcp_/managed_server.py,sha256=X165SqI2CTOm9FWumz2LnWvyj2mYUXONGAwelyump4c,14277
+code_puppy/mcp_/managed_server.py,sha256=KmrFQAQBS-XHuvkuWUltFJk2jiR0pt55gdQlI0gA2QE,14304
 code_puppy/mcp_/manager.py,sha256=pJ4cALicTxfwG2JIjJraLLf0Mzes-cEVAKIcUwfOoKA,29172
+code_puppy/mcp_/mcp_logs.py,sha256=o4pSHwELWIjEjqhfaMMEGrBvb159-VIgUp21E707BPo,6264
 code_puppy/mcp_/registry.py,sha256=U_t12WQ-En-KGyZoiTYdqlhp9NkDTWafu8g5InvF2NM,15774
 code_puppy/mcp_/retry_manager.py,sha256=evVxbtrsHNyo8UoI7zpO-NVDegibn82RLlgN8VKewA8,10665
 code_puppy/mcp_/server_registry_catalog.py,sha256=fr_wsr99BphnaDiPLcN60t4Mp62lbt8rYNOpghKnqEA,39429
@@ -129,7 +130,7 @@ code_puppy/plugins/claude_code_oauth/__init__.py,sha256=mCcOU-wM7LNCDjr-w-WLPzom
 code_puppy/plugins/claude_code_oauth/config.py,sha256=DjGySCkvjSGZds6DYErLMAi3TItt8iSLGvyJN98nSEM,2013
 code_puppy/plugins/claude_code_oauth/register_callbacks.py,sha256=0NeX1hhkYIlVfPmjZ1xmcf1yueDAJh_FMUmvJlxSO-E,10057
 code_puppy/plugins/claude_code_oauth/test_plugin.py,sha256=yQy4EeZl4bjrcog1d8BjknoDTRK75mRXXvkSQJYSSEM,9286
-code_puppy/plugins/claude_code_oauth/utils.py,sha256=uxNRrvtmyG_zZxcvCyZIU1fib8wV5KeorHgVv0RWS9s,13394
+code_puppy/plugins/claude_code_oauth/utils.py,sha256=wDaOU21zB3y6PWkuMXwE4mFjQuffyDae-vXysPTS-w8,13438
 code_puppy/plugins/customizable_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 code_puppy/plugins/customizable_commands/register_callbacks.py,sha256=zVMfIzr--hVn0IOXxIicbmgj2s-HZUgtrOc0NCDOnDw,5183
 code_puppy/plugins/example_custom_command/README.md,sha256=5c5Zkm7CW6BDSfe3WoLU7GW6t5mjjYAbu9-_pu-b3p4,8244
@@ -158,10 +159,10 @@ code_puppy/tools/browser/browser_scripts.py,sha256=sNb8eLEyzhasy5hV4B9OjM8yIVMLV
 code_puppy/tools/browser/browser_workflows.py,sha256=nitW42vCf0ieTX1gLabozTugNQ8phtoFzZbiAhw1V90,6491
 code_puppy/tools/browser/camoufox_manager.py,sha256=RZjGOEftE5sI_tsercUyXFSZI2wpStXf-q0PdYh2G3I,8680
 code_puppy/tools/browser/vqa_agent.py,sha256=DBn9HKloILqJSTSdNZzH_PYWT0B2h9VwmY6akFQI_uU,2913
-code_puppy-0.0.317.data/data/code_puppy/models.json,sha256=nbMCW9SJxWptVEOeMrn_gfyDp-lsbM7Chczjl944GKA,3077
-code_puppy-0.0.317.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
-code_puppy-0.0.317.dist-info/METADATA,sha256=vScnDFiP9UR0Z-U7rx0TAmFL-LBm4b9a13XEdqYh0Y8,28030
-code_puppy-0.0.317.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-code_puppy-0.0.317.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
-code_puppy-0.0.317.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.317.dist-info/RECORD,,
+code_puppy-0.0.319.data/data/code_puppy/models.json,sha256=mTpmJH0UJlmX8M2KVPbxMWb99de3IxKXCWO-B23b6xo,3101
+code_puppy-0.0.319.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
+code_puppy-0.0.319.dist-info/METADATA,sha256=XgkIpN2_glvNl1BcGksFRRikU_PCKdR-eQkDAIkr1ms,28030
+code_puppy-0.0.319.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+code_puppy-0.0.319.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
+code_puppy-0.0.319.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.319.dist-info/RECORD,,