fast-agent-mcp 0.2.32__tar.gz → 0.2.34__tar.gz

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.32
+Version: 0.2.34
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.32"
+version = "0.2.34"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/agents/base_agent.py

@@ -58,6 +58,7 @@ LLM = TypeVar("LLM", bound=AugmentedLLMProtocol)
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
 if TYPE_CHECKING:
     from mcp_agent.context import Context
+    from mcp_agent.llm.usage_tracking import UsageAccumulator
 
 
 DEFAULT_CAPABILITIES = AgentCapabilities(
@@ -698,3 +699,15 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         if self._llm:
             return self._llm.message_history
         return []
+
+    @property
+    def usage_accumulator(self) -> Optional["UsageAccumulator"]:
+        """
+        Return the usage accumulator for tracking token usage across turns.
+        
+        Returns:
+            UsageAccumulator object if LLM is attached, None otherwise
+        """
+        if self._llm:
+            return self._llm.usage_accumulator
+        return None

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/config.py

@@ -3,8 +3,10 @@ Reading settings from environment variables and providing a settings object
 for the application configuration.
 """
 
+import os
+import re
 from pathlib import Path
-from typing import Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -365,6 +367,36 @@ _settings: Settings | None = None
 def get_settings(config_path: str | None = None) -> Settings:
     """Get settings instance, automatically loading from config file if available."""
 
+    def resolve_env_vars(config_item: Any) -> Any:
+        """Recursively resolve environment variables in config data."""
+        if isinstance(config_item, dict):
+            return {k: resolve_env_vars(v) for k, v in config_item.items()}
+        elif isinstance(config_item, list):
+            return [resolve_env_vars(i) for i in config_item]
+        elif isinstance(config_item, str):
+            # Regex to find ${ENV_VAR} or ${ENV_VAR:default_value}
+            pattern = re.compile(r"\$\{([^}]+)\}")
+
+            def replace_match(match: re.Match) -> str:
+                var_name_with_default = match.group(1)
+                if ":" in var_name_with_default:
+                    var_name, default_value = var_name_with_default.split(":", 1)
+                    return os.getenv(var_name, default_value)
+                else:
+                    var_name = var_name_with_default
+                    env_value = os.getenv(var_name)
+                    if env_value is None:
+                        # Optionally, raise an error or return the placeholder if the env var is not set
+                        # For now, returning the placeholder to avoid breaking if not set and no default
+                        # print(f"Warning: Environment variable {var_name} not set and no default provided.")
+                        return match.group(0)
+                    return env_value
+
+            # Replace all occurrences
+            resolved_value = pattern.sub(replace_match, config_item)
+            return resolved_value
+        return config_item
+
     def deep_merge(base: dict, update: dict) -> dict:
         """Recursively merge two dictionaries, preserving nested structures."""
         merged = base.copy()
@@ -409,12 +441,14 @@ def get_settings(config_path: str | None = None) -> Settings:
             # Load main config
             with open(config_file, "r", encoding="utf-8") as f:
                 yaml_settings = yaml.safe_load(f) or {}
-                merged_settings = yaml_settings
+                # Resolve environment variables in the loaded YAML settings
+                resolved_yaml_settings = resolve_env_vars(yaml_settings)
+                merged_settings = resolved_yaml_settings
             # Look for secrets files recursively up the directory tree
             # but stop after finding the first one
             current_dir = config_file.parent
             found_secrets = False
-            # Start with the absolute path of the config file's directory
+            # Start with the absolute path of the config file\'s directory
             current_dir = config_file.parent.resolve()
 
             while current_dir != current_dir.parent and not found_secrets:
@@ -425,7 +459,9 @@ def get_settings(config_path: str | None = None) -> Settings:
                     if secrets_file.exists():
                         with open(secrets_file, "r", encoding="utf-8") as f:
                             yaml_secrets = yaml.safe_load(f) or {}
-                            merged_settings = deep_merge(merged_settings, yaml_secrets)
+                            # Resolve environment variables in the loaded secrets YAML
+                            resolved_secrets_yaml = resolve_env_vars(yaml_secrets)
+                            merged_settings = deep_merge(merged_settings, resolved_secrets_yaml)
                             found_secrets = True
                             break
                 if not found_secrets:

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/core/agent_app.py

@@ -6,10 +6,12 @@ from typing import Dict, List, Optional, Union
 
 from deprecated import deprecated
 from mcp.types import PromptMessage
+from rich import print as rich_print
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.core.interactive_prompt import InteractivePrompt
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.progress_display import progress_display
 
 
 class AgentApp:
@@ -272,7 +274,12 @@ class AgentApp:
 
         # Define the wrapper for send function
         async def send_wrapper(message, agent_name):
-            return await self.send(message, agent_name)
+            result = await self.send(message, agent_name)
+            
+            # Show usage info after each turn if progress display is enabled
+            self._show_turn_usage(agent_name)
+            
+            return result
 
         # Start the prompt loop with the agent name (not the agent object)
         return await prompt.prompt_loop(
@@ -282,3 +289,36 @@ class AgentApp:
             prompt_provider=self,  # Pass self as the prompt provider
             default=default_prompt,
         )
+
+    def _show_turn_usage(self, agent_name: str) -> None:
+        """Show subtle usage information after each turn."""
+        agent = self._agents.get(agent_name)
+        if not agent or not agent.usage_accumulator:
+            return
+            
+        # Get the last turn's usage (if any)
+        turns = agent.usage_accumulator.turns
+        if not turns:
+            return
+            
+        last_turn = turns[-1]
+        input_tokens = last_turn.input_tokens
+        output_tokens = last_turn.output_tokens
+        
+        # Build cache indicators with bright colors
+        cache_indicators = ""
+        if last_turn.cache_usage.cache_write_tokens > 0:
+            cache_indicators += "[bright_yellow]^[/bright_yellow]"
+        if last_turn.cache_usage.cache_read_tokens > 0 or last_turn.cache_usage.cache_hit_tokens > 0:
+            cache_indicators += "[bright_green]*[/bright_green]"
+            
+        # Build context percentage - get from accumulator, not individual turn
+        context_info = ""
+        context_percentage = agent.usage_accumulator.context_usage_percentage
+        if context_percentage is not None:
+            context_info = f" ({context_percentage:.1f}%)"
+            
+        # Show subtle usage line - pause progress display to ensure visibility
+        with progress_display.paused():
+            cache_suffix = f" {cache_indicators}" if cache_indicators else ""
+            rich_print(f"[dim]Last turn: {input_tokens:,} Input, {output_tokens:,} Output{context_info}[/dim]{cache_suffix}")

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/core/enhanced_prompt.py

@@ -58,6 +58,7 @@ class AgentCompleter(Completer):
             "prompts": "List and select MCP prompts",  # Changed description
             "prompt": "Apply a specific prompt by name (/prompt <name>)",  # New command
             "agents": "List available agents",
+            "usage": "Show current usage statistics",
             "clear": "Clear the screen",
             "STOP": "Stop this prompting session and move to next workflow step",
             "EXIT": "Exit fast-agent, terminating any running workflows",
@@ -67,6 +68,7 @@ class AgentCompleter(Completer):
             self.commands.pop("agents")
             self.commands.pop("prompts")  # Remove prompts command in human input mode
             self.commands.pop("prompt", None)  # Remove prompt command in human input mode
+            self.commands.pop("usage", None)  # Remove usage command in human input mode
         self.agent_types = agent_types or {}
 
     def get_completions(self, document, complete_event):
@@ -390,6 +392,8 @@ async def get_enhanced_input(
                 return "CLEAR"
             elif cmd == "agents":
                 return "LIST_AGENTS"
+            elif cmd == "usage":
+                return "SHOW_USAGE"
             elif cmd == "prompts":
                 # Return a dictionary with select_prompt action instead of a string
                 # This way it will match what the command handler expects
@@ -566,6 +570,7 @@ async def handle_special_commands(command, agent_app=None):
         rich_print("  /agents        - List available agents")
         rich_print("  /prompts       - List and select MCP prompts")
         rich_print("  /prompt <name> - Apply a specific prompt by name")
+        rich_print("  /usage         - Show current usage statistics")
         rich_print("  @agent_name    - Switch to agent")
         rich_print("  STOP           - Return control back to the workflow")
         rich_print("  EXIT           - Exit fast-agent, terminating any running workflows")
@@ -594,6 +599,10 @@ async def handle_special_commands(command, agent_app=None):
             rich_print("[yellow]No agents available[/yellow]")
         return True
 
+    elif command == "SHOW_USAGE":
+        # Return a dictionary to signal that usage should be shown
+        return {"show_usage": True}
+
     elif command == "SELECT_PROMPT" or (
         isinstance(command, str) and command.startswith("SELECT_PROMPT:")
     ):

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/core/fastagent.py

@@ -54,6 +54,7 @@ from mcp_agent.core.exceptions import (
     ServerConfigError,
     ServerInitializationError,
 )
+from mcp_agent.core.usage_display import display_usage_report
 from mcp_agent.core.validation import (
     validate_server_references,
     validate_workflow_references,
@@ -392,6 +393,10 @@ class FastAgent:
 
                     yield wrapper
 
+            except PromptExitError as e:
+                # User requested exit - not an error, show usage report
+                self._handle_error(e)
+                raise SystemExit(0)
             except (
                 ServerConfigError,
                 ProviderKeyError,
@@ -399,15 +404,18 @@ class FastAgent:
                 ServerInitializationError,
                 ModelConfigError,
                 CircularDependencyError,
-                PromptExitError,
             ) as e:
                 had_error = True
                 self._handle_error(e)
                 raise SystemExit(1)
 
             finally:
-                # Clean up any active agents
+                # Print usage report before cleanup (show for user exits too)
                 if active_agents and not had_error:
+                    self._print_usage_report(active_agents)
+
+                # Clean up any active agents (always cleanup, even on errors)
+                if active_agents:
                     for agent in active_agents.values():
                         try:
                             await agent.shutdown()
@@ -472,6 +480,10 @@ class FastAgent:
         else:
             handle_error(e, error_type or "Error", "An unexpected error occurred.")
 
+    def _print_usage_report(self, active_agents: dict) -> None:
+        """Print a formatted table of token usage for all agents."""
+        display_usage_report(active_agents, show_if_progress_disabled=False, subdued_colors=True)
+
     async def start_server(
         self,
         transport: str = "sse",

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/core/interactive_prompt.py

@@ -28,6 +28,7 @@ from mcp_agent.core.enhanced_prompt import (
     get_selection_input,
     handle_special_commands,
 )
+from mcp_agent.core.usage_display import collect_agents_from_provider, display_usage_report
 from mcp_agent.mcp.mcp_aggregator import SEP  # Import SEP once at the top
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
@@ -35,15 +36,26 @@ from mcp_agent.progress_display import progress_display
 # Type alias for the send function
 SendFunc = Callable[[Union[str, PromptMessage, PromptMessageMultipart], str], Awaitable[str]]
 
+# Type alias for the agent getter function
+AgentGetter = Callable[[str], Optional[object]]
+
 
 class PromptProvider(Protocol):
     """Protocol for objects that can provide prompt functionality."""
-    
-    async def list_prompts(self, server_name: Optional[str] = None, agent_name: Optional[str] = None) -> Mapping[str, List[Prompt]]:
+
+    async def list_prompts(
+        self, server_name: Optional[str] = None, agent_name: Optional[str] = None
+    ) -> Mapping[str, List[Prompt]]:
         """List available prompts."""
         ...
-    
-    async def apply_prompt(self, prompt_name: str, arguments: Optional[Dict[str, str]] = None, agent_name: Optional[str] = None, **kwargs) -> str:
+
+    async def apply_prompt(
+        self,
+        prompt_name: str,
+        arguments: Optional[Dict[str, str]] = None,
+        agent_name: Optional[str] = None,
+        **kwargs,
+    ) -> str:
         """Apply a prompt."""
         ...
 
@@ -160,9 +172,11 @@ class InteractivePrompt:
                                 await self._list_prompts(prompt_provider, agent)
                         else:
                             # Use the name-based selection
-                            await self._select_prompt(
-                                prompt_provider, agent, prompt_name
-                            )
+                            await self._select_prompt(prompt_provider, agent, prompt_name)
+                        continue
+                    elif "show_usage" in command_result:
+                        # Handle usage display
+                        await self._show_usage(prompt_provider, agent)
                         continue
 
                 # Skip further processing if:
@@ -170,7 +184,11 @@ class InteractivePrompt:
                 # 2. The original input was a dictionary (special command like /prompt)
                 # 3. The command result itself is a dictionary (special command handling result)
                 # This fixes the issue where /prompt without arguments gets sent to the LLM
-                if command_result or isinstance(user_input, dict) or isinstance(command_result, dict):
+                if (
+                    command_result
+                    or isinstance(user_input, dict)
+                    or isinstance(command_result, dict)
+                ):
                     continue
 
                 if user_input.upper() == "STOP":
@@ -183,7 +201,9 @@ class InteractivePrompt:
 
         return result
 
-    async def _get_all_prompts(self, prompt_provider: PromptProvider, agent_name: Optional[str] = None):
+    async def _get_all_prompts(
+        self, prompt_provider: PromptProvider, agent_name: Optional[str] = None
+    ):
         """
         Get a list of all available prompts.
 
@@ -196,8 +216,10 @@ class InteractivePrompt:
         """
         try:
             # Call list_prompts on the provider
-            prompt_servers = await prompt_provider.list_prompts(server_name=None, agent_name=agent_name)
-            
+            prompt_servers = await prompt_provider.list_prompts(
+                server_name=None, agent_name=agent_name
+            )
+
             all_prompts = []
 
             # Process the returned prompt servers
@@ -326,9 +348,11 @@ class InteractivePrompt:
         try:
             # Get all available prompts directly from the prompt provider
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            
+
             # Call list_prompts on the provider
-            prompt_servers = await prompt_provider.list_prompts(server_name=None, agent_name=agent_name)
+            prompt_servers = await prompt_provider.list_prompts(
+                server_name=None, agent_name=agent_name
+            )
 
             if not prompt_servers:
                 rich_print("[yellow]No prompts available for this agent[/yellow]")
@@ -557,3 +581,25 @@ class InteractivePrompt:
 
             rich_print(f"[red]Error selecting or applying prompt: {e}[/red]")
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+
+    async def _show_usage(self, prompt_provider: PromptProvider, agent_name: str) -> None:
+        """
+        Show usage statistics for the current agent(s) in a colorful table format.
+
+        Args:
+            prompt_provider: Provider that has access to agents
+            agent_name: Name of the current agent
+        """
+        try:
+            # Collect all agents from the prompt provider
+            agents_to_show = collect_agents_from_provider(prompt_provider, agent_name)
+            
+            if not agents_to_show:
+                rich_print("[yellow]No usage data available[/yellow]")
+                return
+                
+            # Use the shared display utility
+            display_usage_report(agents_to_show, show_if_progress_disabled=True)
+            
+        except Exception as e:
+            rich_print(f"[red]Error showing usage: {e}[/red]")

fast_agent_mcp-0.2.34/src/mcp_agent/core/usage_display.py

@@ -0,0 +1,193 @@
+"""
+Utility module for displaying usage statistics in a consistent format.
+Consolidates the usage display logic that was duplicated between fastagent.py and interactive_prompt.py.
+"""
+
+from typing import Any, Dict, Optional
+
+from rich.console import Console
+
+
+def display_usage_report(
+    agents: Dict[str, Any], show_if_progress_disabled: bool = False, subdued_colors: bool = False
+) -> None:
+    """
+    Display a formatted table of token usage for all agents.
+
+    Args:
+        agents: Dictionary of agent name -> agent object
+        show_if_progress_disabled: If True, show even when progress display is disabled
+        subdued_colors: If True, use dim styling for a more subdued appearance
+    """
+    # Check if progress display is enabled (only relevant for fastagent context)
+    if not show_if_progress_disabled:
+        try:
+            from mcp_agent import config
+
+            settings = config.get_settings()
+            if not settings.logger.progress_display:
+                return
+        except (ImportError, AttributeError):
+            # If we can't check settings, assume we should display
+            pass
+
+    # Collect usage data from all agents
+    usage_data = []
+    total_input = 0
+    total_output = 0
+    total_tokens = 0
+
+    for agent_name, agent in agents.items():
+        if agent.usage_accumulator:
+            summary = agent.usage_accumulator.get_summary()
+            if summary["turn_count"] > 0:
+                input_tokens = summary["cumulative_input_tokens"]
+                output_tokens = summary["cumulative_output_tokens"]
+                billing_tokens = summary["cumulative_billing_tokens"]
+                turns = summary["turn_count"]
+
+                # Get context percentage for this agent
+                context_percentage = agent.usage_accumulator.context_usage_percentage
+
+                # Get model name from LLM's default_request_params
+                model = "unknown"
+                if hasattr(agent, "_llm") and agent._llm:
+                    llm = agent._llm
+                    if (
+                        hasattr(llm, "default_request_params")
+                        and llm.default_request_params
+                        and hasattr(llm.default_request_params, "model")
+                    ):
+                        model = llm.default_request_params.model or "unknown"
+
+                # Standardize model name truncation - use consistent 25 char width with 22+... truncation
+                if len(model) > 25:
+                    model = model[:22] + "..."
+
+                usage_data.append(
+                    {
+                        "name": agent_name,
+                        "model": model,
+                        "input": input_tokens,
+                        "output": output_tokens,
+                        "total": billing_tokens,
+                        "turns": turns,
+                        "context": context_percentage,
+                    }
+                )
+
+                total_input += input_tokens
+                total_output += output_tokens
+                total_tokens += billing_tokens
+
+    if not usage_data:
+        return
+
+    # Calculate dynamic agent column width (max 15)
+    max_agent_width = min(15, max(len(data["name"]) for data in usage_data) if usage_data else 8)
+    agent_width = max(max_agent_width, 5)  # Minimum of 5 for "Agent" header
+
+    # Display the table
+    console = Console()
+    console.print()
+    console.print("[dim]Usage Summary (Cumulative)[/dim]")
+
+    # Print header with proper spacing
+    console.print(
+        f"[dim]{'Agent':<{agent_width}} {'Input':>9} {'Output':>9} {'Total':>9} {'Turns':>6} {'Context%':>9}  {'Model':<25}[/dim]"
+    )
+
+    # Print agent rows - use styling based on subdued_colors flag
+    for data in usage_data:
+        input_str = f"{data['input']:,}"
+        output_str = f"{data['output']:,}"
+        total_str = f"{data['total']:,}"
+        turns_str = str(data["turns"])
+        context_str = f"{data['context']:.1f}%" if data["context"] is not None else "-"
+
+        # Truncate agent name if needed
+        agent_name = data["name"]
+        if len(agent_name) > agent_width:
+            agent_name = agent_name[: agent_width - 3] + "..."
+
+        if subdued_colors:
+            # Original fastagent.py style with dim wrapper
+            console.print(
+                f"[dim]{agent_name:<{agent_width}} "
+                f"{input_str:>9} "
+                f"{output_str:>9} "
+                f"[bold]{total_str:>9}[/bold] "
+                f"{turns_str:>6} "
+                f"{context_str:>9}  "
+                f"{data['model']:<25}[/dim]"
+            )
+        else:
+            # Original interactive_prompt.py style
+            console.print(
+                f"{agent_name:<{agent_width}} "
+                f"{input_str:>9} "
+                f"{output_str:>9} "
+                f"[bold]{total_str:>9}[/bold] "
+                f"{turns_str:>6} "
+                f"{context_str:>9}  "
+                f"[dim]{data['model']:<25}[/dim]"
+            )
+
+    # Add total row if multiple agents
+    if len(usage_data) > 1:
+        console.print()
+        total_input_str = f"{total_input:,}"
+        total_output_str = f"{total_output:,}"
+        total_tokens_str = f"{total_tokens:,}"
+
+        if subdued_colors:
+            # Original fastagent.py style with dim wrapper on bold
+            console.print(
+                f"[bold dim]{'TOTAL':<{agent_width}} "
+                f"{total_input_str:>9} "
+                f"{total_output_str:>9} "
+                f"[bold]{total_tokens_str:>9}[/bold] "
+                f"{'':<6} "
+                f"{'':<9}  "
+                f"{'':<25}[/bold dim]"
+            )
+        else:
+            # Original interactive_prompt.py style
+            console.print(
+                f"[bold]{'TOTAL':<{agent_width}}[/bold] "
+                f"[bold]{total_input_str:>9}[/bold] "
+                f"[bold]{total_output_str:>9}[/bold] "
+                f"[bold]{total_tokens_str:>9}[/bold] "
+                f"{'':<6} "
+                f"{'':<9}  "
+                f"{'':<25}"
+            )
+
+    console.print()
+
+
+def collect_agents_from_provider(
+    prompt_provider: Any, agent_name: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Collect agents from a prompt provider for usage display.
+
+    Args:
+        prompt_provider: Provider that has access to agents
+        agent_name: Name of the current agent (for context)
+
+    Returns:
+        Dictionary of agent name -> agent object
+    """
+    agents_to_show = {}
+
+    if hasattr(prompt_provider, "_agents"):
+        # Multi-agent app - show all agents
+        agents_to_show = prompt_provider._agents
+    elif hasattr(prompt_provider, "agent"):
+        # Single agent
+        agent = prompt_provider.agent
+        if hasattr(agent, "name"):
+            agents_to_show = {agent.name: agent}
+
+    return agents_to_show

{fast_agent_mcp-0.2.32 → fast_agent_mcp-0.2.34}/src/mcp_agent/llm/augmented_llm.py

@@ -30,11 +30,13 @@ from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.llm.memory import Memory, SimpleMemory
+from mcp_agent.llm.model_database import ModelDatabase
 from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.sampling_format_converter import (
     BasicFormatConverter,
     ProviderFormatConverter,
 )
+from mcp_agent.llm.usage_tracking import UsageAccumulator
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.helpers.content_helpers import get_text
 from mcp_agent.mcp.interfaces import (
@@ -155,12 +157,11 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # Initialize the display component
         self.display = ConsoleDisplay(config=self.context.config)
 
-        # Initialize default parameters
-        self.default_request_params = self._initialize_default_params(kwargs)
-
-        # Apply model override if provided
+        # Initialize default parameters, passing model info
+        model_kwargs = kwargs.copy()
         if model:
-            self.default_request_params.model = model
+            model_kwargs["model"] = model
+        self.default_request_params = self._initialize_default_params(model_kwargs)
 
         # Merge with provided params if any
         if self._init_request_params:
@@ -171,13 +172,22 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         self.type_converter = type_converter
         self.verb = kwargs.get("verb")
 
+        # Initialize usage tracking
+        self.usage_accumulator = UsageAccumulator()
+
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters for the LLM.
         Should be overridden by provider implementations to set provider-specific defaults."""
+        # Get model-aware default max tokens
+        model = kwargs.get("model")
+        max_tokens = ModelDatabase.get_default_max_tokens(model)
+
         return RequestParams(
+            model=model,
+            maxTokens=max_tokens,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 
@@ -642,3 +652,13 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
         assert self.provider
         return ProviderKeyManager.get_api_key(self.provider.value, self.context.config)
+
+    def get_usage_summary(self) -> dict:
+        """
+        Get a summary of usage statistics for this LLM instance.
+
+        Returns:
+            Dictionary containing usage statistics including tokens, cache metrics,
+            and context window utilization.
+        """
+        return self.usage_accumulator.get_summary()