janito 0.10.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

janito/config.py

@@ -1,63 +1,338 @@
-"""
-Configuration module for Janito.
-Provides a singleton Config class to access configuration values.
-"""
-import os
-from pathlib import Path
-from typing import Optional
-import typer
-
-class Config:
-    """Singleton configuration class for Janito."""
-    _instance = None
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(Config, cls).__new__(cls)
-            cls._instance._workspace_dir = os.getcwd()
-            cls._instance._debug_mode = False
-        return cls._instance
-    
-    @property
-    def workspace_dir(self) -> str:
-        """Get the current workspace directory."""
-        return self._workspace_dir
-    
-    @workspace_dir.setter
-    def workspace_dir(self, path: str) -> None:
-        """Set the workspace directory."""
-        # Convert to absolute path if not already
-        if not os.path.isabs(path):
-            path = os.path.normpath(os.path.abspath(path))
-        else:
-            # Ensure Windows paths are properly formatted
-            path = os.path.normpath(path)
-        
-        # Check if the directory exists
-        if not os.path.isdir(path):
-            create_dir = typer.confirm(f"Workspace directory does not exist: {path}\nDo you want to create it?")
-            if create_dir:
-                try:
-                    os.makedirs(path, exist_ok=True)
-                    print(f"Created workspace directory: {path}")
-                except Exception as e:
-                    raise ValueError(f"Failed to create workspace directory: {str(e)}")
-            else:
-                raise ValueError(f"Workspace directory does not exist: {path}")
-        
-        self._workspace_dir = path
-    
-    @property
-    def debug_mode(self) -> bool:
-        """Get the debug mode status."""
-        return self._debug_mode
-    
-    @debug_mode.setter
-    def debug_mode(self, value: bool) -> None:
-        """Set the debug mode status."""
-        self._debug_mode = value
-
-# Convenience function to get the config instance
-def get_config() -> Config:
-    """Get the singleton Config instance."""
-    return Config()
+"""
+Configuration module for Janito.
+Provides a singleton Config class to access configuration values.
+"""
+import os
+import json
+from pathlib import Path
+import typer
+from typing import Dict, Any, Optional
+
+# Predefined parameter profiles
+PROFILES = {
+    "precise": {
+        "temperature": 0.2,
+        "top_p": 0.85,
+        "top_k": 20,
+        "description": "Factual answers, documentation, structured data, avoiding hallucinations"
+    },
+    "balanced": {
+        "temperature": 0.5,
+        "top_p": 0.9,
+        "top_k": 40,
+        "description": "Professional writing, summarization, everyday tasks with moderate creativity"
+    },
+    "conversational": {
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "top_k": 45,
+        "description": "Natural dialogue, educational content, support conversations"
+    },
+    "creative": {
+        "temperature": 0.9,
+        "top_p": 0.95,
+        "top_k": 70,
+        "description": "Storytelling, brainstorming, marketing copy, poetry"
+    },
+    "technical": {
+        "temperature": 0.3,
+        "top_p": 0.95,
+        "top_k": 15,
+        "description": "Code generation, debugging, decision analysis, technical problem-solving"
+    }
+}
+
+class Config:
+    """Singleton configuration class for Janito."""
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(Config, cls).__new__(cls)
+            cls._instance._workspace_dir = os.getcwd()
+            cls._instance._verbose = False
+            # Chat history context feature has been removed
+            cls._instance._ask_mode = False
+            # Set technical profile as default
+            profile_data = PROFILES["technical"]
+            cls._instance._temperature = profile_data["temperature"]
+            cls._instance._profile = "technical"
+            cls._instance._role = "software engineer"
+            cls._instance._gitbash_path = None  # Default to None for auto-detection
+            cls._instance._load_config()
+        return cls._instance
+        
+    def _load_config(self) -> None:
+        """Load configuration from file."""
+        config_path = Path(self._workspace_dir) / ".janito" / "config.json"
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+                    # Chat history context feature has been removed
+                    if "debug_mode" in config_data:
+                        self._verbose = config_data["debug_mode"]
+                    if "ask_mode" in config_data:
+                        self._ask_mode = config_data["ask_mode"]
+                    if "temperature" in config_data:
+                        self._temperature = config_data["temperature"]
+                    if "profile" in config_data:
+                        self._profile = config_data["profile"]
+                    if "role" in config_data:
+                        self._role = config_data["role"]
+                    if "gitbash_path" in config_data:
+                        self._gitbash_path = config_data["gitbash_path"]
+            except Exception as e:
+                print(f"Warning: Failed to load configuration: {str(e)}")
+                
+    def _save_config(self) -> None:
+        """Save configuration to file."""
+        config_dir = Path(self._workspace_dir) / ".janito"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        config_path = config_dir / "config.json"
+        
+        config_data = {
+            # Chat history context feature has been removed
+            "verbose": self._verbose,
+            "ask_mode": self._ask_mode,
+            "temperature": self._temperature,
+            "role": self._role
+        }
+        
+        # Save profile name if one is set
+        if self._profile:
+            config_data["profile"] = self._profile
+            
+        # Save GitBash path if one is set
+        if self._gitbash_path:
+            config_data["gitbash_path"] = self._gitbash_path
+        
+        try:
+            with open(config_path, "w", encoding="utf-8") as f:
+                json.dump(config_data, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Failed to save configuration: {str(e)}")
+            
+    def set_profile(self, profile_name: str) -> None:
+        """Set parameter values based on a predefined profile.
+        
+        Args:
+            profile_name: Name of the profile to use (precise, balanced, conversational, creative, technical)
+            
+        Raises:
+            ValueError: If the profile name is not recognized
+        """
+        profile_name = profile_name.lower()
+        if profile_name not in PROFILES:
+            valid_profiles = ", ".join(PROFILES.keys())
+            raise ValueError(f"Unknown profile: {profile_name}. Valid profiles are: {valid_profiles}")
+            
+        profile = PROFILES[profile_name]
+        self._temperature = profile["temperature"]
+        self._profile = profile_name
+        self._save_config()
+        
+    @property
+    def profile(self) -> Optional[str]:
+        """Get the current profile name."""
+        return self._profile
+        
+    @staticmethod
+    def get_available_profiles() -> Dict[str, Dict[str, Any]]:
+        """Get all available predefined profiles."""
+        return PROFILES
+        
+    @staticmethod
+    def set_api_key(api_key: str) -> None:
+        """Set the API key in the global configuration file.
+        
+        Args:
+            api_key: The Anthropic API key to store
+            
+        Returns:
+            None
+        """
+        # Create .janito directory in user's home directory if it doesn't exist
+        home_dir = Path.home()
+        config_dir = home_dir / ".janito"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create or update the config.json file
+        config_path = config_dir / "config.json"
+        
+        # Load existing config if it exists
+        config_data = {}
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+            except Exception as e:
+                print(f"Warning: Failed to load global configuration: {str(e)}")
+        
+        # Update the API key
+        config_data["api_key"] = api_key
+        
+        # Save the updated config
+        try:
+            with open(config_path, "w", encoding="utf-8") as f:
+                json.dump(config_data, f, indent=2)
+            print(f"API key saved to {config_path}")
+        except Exception as e:
+            raise ValueError(f"Failed to save API key: {str(e)}")
+            
+    @staticmethod
+    def get_api_key() -> Optional[str]:
+        """Get the API key from the global configuration file.
+        
+        Returns:
+            The API key if found, None otherwise
+        """
+        # Look for config.json in user's home directory
+        home_dir = Path.home()
+        config_path = home_dir / ".janito" / "config.json"
+        
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+                    return config_data.get("api_key")
+            except Exception:
+                # Silently fail and return None
+                pass
+                
+        return None
+    
+    @property
+    def workspace_dir(self) -> str:
+        """Get the current workspace directory."""
+        return self._workspace_dir
+    
+    @workspace_dir.setter
+    def workspace_dir(self, path: str) -> None:
+        """Set the workspace directory."""
+        # Convert to absolute path if not already
+        if not os.path.isabs(path):
+            path = os.path.normpath(os.path.abspath(path))
+        else:
+            # Ensure Windows paths are properly formatted
+            path = os.path.normpath(path)
+        
+        # Check if the directory exists
+        if not os.path.isdir(path):
+            create_dir = typer.confirm(f"Workspace directory does not exist: {path}\nDo you want to create it?")
+            if create_dir:
+                try:
+                    os.makedirs(path, exist_ok=True)
+                    print(f"Created workspace directory: {path}")
+                except Exception as e:
+                    raise ValueError(f"Failed to create workspace directory: {str(e)}") from e
+            else:
+                raise ValueError(f"Workspace directory does not exist: {path}")
+        
+        self._workspace_dir = path
+    
+    @property
+    def verbose(self) -> bool:
+        """Get the verbose mode status."""
+        return self._verbose
+    
+    @verbose.setter
+    def verbose(self, value: bool) -> None:
+        """Set the verbose mode status."""
+        self._verbose = value
+    
+    # For backward compatibility
+    @property
+    def debug_mode(self) -> bool:
+        """Get the debug mode status (alias for verbose)."""
+        return self._verbose
+    
+    @debug_mode.setter
+    def debug_mode(self, value: bool) -> None:
+        """Set the debug mode status (alias for verbose)."""
+        self._verbose = value
+
+    # Chat history context feature has been removed
+        
+    @property
+    def ask_mode(self) -> bool:
+        """Get the ask mode status."""
+        return self._ask_mode
+        
+    @ask_mode.setter
+    def ask_mode(self, value: bool) -> None:
+        """Set the ask mode status."""
+        self._ask_mode = value
+        self._save_config()
+        
+    @property
+    def temperature(self) -> float:
+        """Get the temperature value for model generation."""
+        return self._temperature
+        
+    @temperature.setter
+    def temperature(self, value: float) -> None:
+        """Set the temperature value for model generation."""
+        if value < 0.0 or value > 1.0:
+            raise ValueError("Temperature must be between 0.0 and 1.0")
+        self._temperature = value
+        self._save_config()
+        
+    # top_k and top_p are now only accessible through profiles
+        
+    @property
+    def role(self) -> str:
+        """Get the role for the assistant."""
+        return self._role
+        
+    @role.setter
+    def role(self, value: str) -> None:
+        """Set the role for the assistant."""
+        self._role = value
+        self._save_config()
+        
+    @property
+    def gitbash_path(self) -> Optional[str]:
+        """Get the path to the GitBash executable."""
+        return self._gitbash_path
+        
+    @gitbash_path.setter
+    def gitbash_path(self, value: Optional[str]) -> None:
+        """Set the path to the GitBash executable.
+        
+        Args:
+            value: Path to the GitBash executable, or None to use auto-detection
+        """
+        # If a path is provided, verify it exists
+        if value is not None and not os.path.exists(value):
+            raise ValueError(f"GitBash executable not found at: {value}")
+        
+        self._gitbash_path = value
+        self._save_config()
+        
+    def reset_config(self) -> bool:
+        """Reset configuration by removing the config file.
+        
+        Returns:
+            bool: True if the config file was removed, False if it didn't exist
+        """
+        config_path = Path(self._workspace_dir) / ".janito" / "config.json"
+        if config_path.exists():
+            config_path.unlink()
+            # Reset instance variables to defaults
+            self._verbose = False
+            # Chat history context feature has been removed
+            self._ask_mode = False
+            # Set technical profile as default
+            profile_data = PROFILES["technical"]
+            self._temperature = profile_data["temperature"]
+            self._profile = "technical"
+            self._role = "software engineer"
+            self._gitbash_path = None  # Reset to auto-detection
+            return True
+        return False
+
+# Convenience function to get the config instance
+def get_config() -> Config:
+    """Get the singleton Config instance."""
+    return Config()

janito/data/instructions_template.txt

@@ -0,0 +1,27 @@
+You are a {{ role }}, using the name Janito .
+You will be assisting an user using a computer system on a {{ platform }} platform.
+You can find more about the current project using the tools in the workspace directory.
+If the question is related to the project, use the tools using the relative path  "." .
+
+If creating or editing files with a large number of lines, organize them into smaller files.
+If creating or editing files in an existing directory check surrounding files for the used patterns.
+
+# Structure Discovery (.janito/docs/STRUCTURE.md)
+Always start exploring the project by viewing for the file .janito/docs/STRUCTURE.md.
+Do not track files or directories wich are in .gitignore in the structure.
+At the end of responding to the user, update the structure file based on the files and directories you have interacted with,
+be precise focusing on the most important files and directories, avoid adding extra information like architecture or design patterns.
+
+
+# Tools
+The bash tool does not support commands which will require user input.
+Prefer the str_replace_editor tool to view directories and file contents.
+
+</IMPORTANT>
+Call the tool user_prompt when:
+- There are multiple options to apply a certain change
+- The next operation risk is moderated or high
+- The implementation plan is complex, requiring a review
+Proceed according to the user answer.
+<IMPORTANT/>
+

janito/token_report.py

@@ -3,71 +3,152 @@ Module for generating token usage reports.
 """
 
 from rich.console import Console
-from claudine.token_tracking import MODEL_PRICING, DEFAULT_MODEL
 
-def generate_token_report(agent, verbose=False):
+def generate_token_report(agent, verbose=False, interrupted=False):
     """
     Generate a token usage report.
     
     Args:
         agent: The Claude agent instance
         verbose: Whether to show detailed token usage information
+        interrupted: Whether the request was interrupted
         
     Returns:
         None - prints the report to the console
     """
     console = Console()
-    usage = agent.get_token_usage()
+    usage = agent.get_tokens()
+    cost = agent.get_token_cost()
+    
     text_usage = usage.text_usage
     tools_usage = usage.tools_usage
     
     if verbose:
         total_usage = usage.total_usage
         
-        # Get the pricing model
-        pricing = MODEL_PRICING.get(DEFAULT_MODEL)
+        # Get costs from the cost object
+        text_input_cost = cost.input_cost
+        text_output_cost = cost.output_cost
+        text_cache_creation_cost = cost.cache_creation_cost
+        text_cache_read_cost = cost.cache_read_cost
         
-        # Calculate costs manually
-        text_input_cost = pricing.input_tokens.calculate_cost(text_usage.input_tokens)
-        text_output_cost = pricing.output_tokens.calculate_cost(text_usage.output_tokens)
-        tools_input_cost = pricing.input_tokens.calculate_cost(tools_usage.input_tokens)
-        tools_output_cost = pricing.output_tokens.calculate_cost(tools_usage.output_tokens)
+        tools_input_cost = cost.input_cost
+        tools_output_cost = cost.output_cost
+        tools_cache_creation_cost = cost.cache_creation_cost
+        tools_cache_read_cost = cost.cache_read_cost
         
         # Format costs
-        format_cost = lambda cost: f"{cost * 100:.2f}¢" if cost < 1.0 else f"${cost:.6f}"
+        def format_cost(cost):
+            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
         
-        console.print("\n[bold blue]Detailed Token Usage:[/bold blue]")
-        console.print(f"Text Input tokens: {text_usage.input_tokens}")
-        console.print(f"Text Output tokens: {text_usage.output_tokens}")
-        console.print(f"Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens}")
-        console.print(f"Tool Input tokens: {tools_usage.input_tokens}")
-        console.print(f"Tool Output tokens: {tools_usage.output_tokens}")
-        console.print(f"Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens}")
-        console.print(f"Total tokens: {total_usage.input_tokens + total_usage.output_tokens}")
+        console.print("\n[bold blue]📊 Detailed Token Usage:[/bold blue]")
+        console.print(f"📝 Text Input tokens: {text_usage.input_tokens}")
+        console.print(f"📤 Text Output tokens: {text_usage.output_tokens}")
+        console.print(f"💾 Text Cache Creation tokens: {text_usage.cache_creation_input_tokens}")
+        console.print(f"📖 Text Cache Read tokens: {text_usage.cache_read_input_tokens}")
+        console.print(f"📋 Text Total tokens: {text_usage.input_tokens + text_usage.output_tokens + text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens}")
         
-        console.print("\n[bold blue]Pricing Information:[/bold blue]")
-        console.print(f"Input pricing: ${pricing.input_tokens.cost_per_million_tokens}/million tokens")
-        console.print(f"Output pricing: ${pricing.output_tokens.cost_per_million_tokens}/million tokens")
-        console.print(f"Text Input cost: {format_cost(text_input_cost)}")
-        console.print(f"Text Output cost: {format_cost(text_output_cost)}")
-        console.print(f"Text Total cost: {format_cost(text_input_cost + text_output_cost)}")
-        console.print(f"Tool Input cost: {format_cost(tools_input_cost)}")
-        console.print(f"Tool Output cost: {format_cost(tools_output_cost)}")
-        console.print(f"Tool Total cost: {format_cost(tools_input_cost + tools_output_cost)}")
-        console.print(f"Total cost: {format_cost(text_input_cost + text_output_cost + tools_input_cost + tools_output_cost)}")
-
-        # Display per-tool breakdown if available
+        console.print(f"🔧 Tool Input tokens: {tools_usage.input_tokens}")
+        console.print(f"🔨 Tool Output tokens: {tools_usage.output_tokens}")
+        console.print(f"💾 Tool Cache Creation tokens: {tools_usage.cache_creation_input_tokens}")
+        console.print(f"📖 Tool Cache Read tokens: {tools_usage.cache_read_input_tokens}")
+        console.print(f"🧰 Tool Total tokens: {tools_usage.input_tokens + tools_usage.output_tokens + tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens}")
+        
+        console.print(f"🔢 Total tokens: {total_usage.input_tokens + total_usage.output_tokens + total_usage.cache_creation_input_tokens + total_usage.cache_read_input_tokens}")
+        
+        console.print("\n[bold blue]💰 Pricing Information:[/bold blue]")
+        console.print(f"📝 Text Input cost: {format_cost(text_input_cost)}")
+        console.print(f"📤 Text Output cost: {format_cost(text_output_cost)}")
+        console.print(f"💾 Text Cache Creation cost: {format_cost(text_cache_creation_cost)}")
+        console.print(f"📖 Text Cache Read cost: {format_cost(text_cache_read_cost)}")
+        console.print(f"📋 Text Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost)}")
+        
+        console.print(f"🔧 Tool Input cost: {format_cost(tools_input_cost)}")
+        console.print(f"🔨 Tool Output cost: {format_cost(tools_output_cost)}")
+        console.print(f"💾 Tool Cache Creation cost: {format_cost(tools_cache_creation_cost)}")
+        console.print(f"📖 Tool Cache Read cost: {format_cost(tools_cache_read_cost)}")
+        console.print(f"🧰 Tool Total cost: {format_cost(tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}")
+        
+        total_cost_text = f"💵 Total cost: {format_cost(text_input_cost + text_output_cost + text_cache_creation_cost + text_cache_read_cost + tools_input_cost + tools_output_cost + tools_cache_creation_cost + tools_cache_read_cost)}"
+        if interrupted:
+            total_cost_text += " (interrupted request not accounted)"
+        console.print(total_cost_text)
+        
+        # Show cache delta if available
+        if hasattr(cost, 'cache_delta') and cost.cache_delta:
+            cache_delta = cost.cache_delta
+            console.print(f"\n[bold green]💰 Cache Savings:[/bold green] {format_cost(cache_delta)}")
+            
+            # Calculate percentage savings
+            total_cost_without_cache = cost.total_cost + cache_delta
+            if total_cost_without_cache > 0:
+                savings_percentage = (cache_delta / total_cost_without_cache) * 100
+                console.print(f"[bold green]📊 Cache Savings Percentage:[/bold green] {savings_percentage:.2f}%")
+                console.print(f"[bold green]💸 Cost without cache:[/bold green] {format_cost(total_cost_without_cache)}")
+                console.print(f"[bold green]💲 Cost with cache:[/bold green] {format_cost(cost.total_cost)}")
+            
+        # Per-tool breakdown
         if usage.by_tool:
-            console.print("\n[bold blue]Per-Tool Breakdown:[/bold blue]")
-            for tool_name, tool_usage in usage.by_tool.items():
-                tool_input_cost = pricing.input_tokens.calculate_cost(tool_usage.input_tokens)
-                tool_output_cost = pricing.output_tokens.calculate_cost(tool_usage.output_tokens)
-                console.print(f"   Tool: {tool_name}")
-                console.print(f"  Input tokens: {tool_usage.input_tokens}")
-                console.print(f"  Output tokens: {tool_usage.output_tokens}")
-                console.print(f"  Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens}")
-                console.print(f"  Total cost: {format_cost(tool_input_cost + tool_output_cost)}")
+            console.print("\n[bold blue]🔧 Per-Tool Breakdown:[/bold blue]")
+            try:
+                if hasattr(cost, 'by_tool') and cost.by_tool:
+                    for tool_name, tool_usage in usage.by_tool.items():
+                        tool_input_cost = cost.by_tool[tool_name].input_cost
+                        tool_output_cost = cost.by_tool[tool_name].output_cost
+                        tool_cache_creation_cost = cost.by_tool[tool_name].cache_creation_cost
+                        tool_cache_read_cost = cost.by_tool[tool_name].cache_read_cost
+                        tool_total_cost = tool_input_cost + tool_output_cost + tool_cache_creation_cost + tool_cache_read_cost
+                        
+                        console.print(f"   🔧 Tool: {tool_name}")
+                        console.print(f"  📥 Input tokens: {tool_usage.input_tokens}")
+                        console.print(f"  📤 Output tokens: {tool_usage.output_tokens}")
+                        console.print(f"  💾 Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
+                        console.print(f"  📖 Cache Read tokens: {tool_usage.cache_read_input_tokens}")
+                        console.print(f"  🔢 Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
+                        console.print(f"  💵 Total cost: {format_cost(tool_total_cost)}")
+                else:
+                    # Calculate costs manually for each tool if cost.by_tool is not available
+                    for tool_name, tool_usage in usage.by_tool.items():
+                        # Estimate costs based on overall pricing
+                        total_tokens = tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens
+                        estimated_cost = (total_tokens / (usage.total_usage.total_tokens + usage.total_usage.total_cache_tokens)) * cost.total_cost if usage.total_usage.total_tokens > 0 else 0
+                        
+                        console.print(f"   🔧 Tool: {tool_name}")
+                        console.print(f"  📥 Input tokens: {tool_usage.input_tokens}")
+                        console.print(f"  📤 Output tokens: {tool_usage.output_tokens}")
+                        console.print(f"  💾 Cache Creation tokens: {tool_usage.cache_creation_input_tokens}")
+                        console.print(f"  📖 Cache Read tokens: {tool_usage.cache_read_input_tokens}")
+                        console.print(f"  🔢 Total tokens: {tool_usage.input_tokens + tool_usage.output_tokens + tool_usage.cache_creation_input_tokens + tool_usage.cache_read_input_tokens}")
+                        console.print(f"  💵 Total cost: {format_cost(estimated_cost)}")
+            except Exception as e:
+                console.print(f"❌ Error: {str(e)}")
     else:
-        total_tokens = text_usage.input_tokens + text_usage.output_tokens + tools_usage.input_tokens + tools_usage.output_tokens
-        cost_info = agent.get_cost()
-        console.rule(f"[bold blue]Total tokens: {total_tokens} | Cost: {cost_info.format_total_cost()}[/bold blue]")
+        total_tokens = (text_usage.input_tokens + text_usage.output_tokens + 
+                       text_usage.cache_creation_input_tokens + text_usage.cache_read_input_tokens +
+                       tools_usage.input_tokens + tools_usage.output_tokens +
+                       tools_usage.cache_creation_input_tokens + tools_usage.cache_read_input_tokens)
+        
+        # Format costs
+        def format_cost(cost):
+            return f"{cost * 100:.2f}¢ USD" if cost < 1.0 else f"${cost:.6f} USD"
+        
+        # Prepare summary message
+        cost_text = f"Cost: {format_cost(cost.total_cost)}"
+        if interrupted:
+            cost_text += " (interrupted request not accounted)"
+            
+        summary = f"Total tokens: {total_tokens} | {cost_text}"
+        
+        # Add cache savings if available
+        if hasattr(cost, 'cache_delta') and cost.cache_delta != 0:
+            cache_delta = cost.cache_delta
+            total_cost_without_cache = cost.total_cost + cache_delta
+            savings_percentage = 0
+            if total_cost_without_cache > 0:
+                savings_percentage = (cache_delta / total_cost_without_cache) * 100
+            
+            summary += f" | Cache savings: {format_cost(cache_delta)} ({savings_percentage:.1f}%)"
+        
+        # Display with a rule
+        console.rule("[blue]Token Usage[/blue]")
+        console.print(f"[blue]{summary}[/blue]", justify="center")