fast-agent-mcp 0.2.40__py3-none-any.whl → 0.2.42__py3-none-any.whl

mcp_agent/core/usage_display.py

@@ -36,6 +36,7 @@ def display_usage_report(
     total_input = 0
     total_output = 0
     total_tokens = 0
+    total_tool_calls = 0
 
     for agent_name, agent in agents.items():
         if agent.usage_accumulator:
@@ -45,6 +46,7 @@ def display_usage_report(
                 output_tokens = summary["cumulative_output_tokens"]
                 billing_tokens = summary["cumulative_billing_tokens"]
                 turns = summary["turn_count"]
+                tool_calls = summary["cumulative_tool_calls"]
 
                 # Get context percentage for this agent
                 context_percentage = agent.usage_accumulator.context_usage_percentage
@@ -72,6 +74,7 @@ def display_usage_report(
                         "output": output_tokens,
                         "total": billing_tokens,
                         "turns": turns,
+                        "tool_calls": tool_calls,
                         "context": context_percentage,
                     }
                 )
@@ -79,6 +82,7 @@ def display_usage_report(
                 total_input += input_tokens
                 total_output += output_tokens
                 total_tokens += billing_tokens
+                total_tool_calls += tool_calls
 
     if not usage_data:
         return
@@ -94,7 +98,7 @@ def display_usage_report(
 
     # 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]"
+        f"[dim]{'Agent':<{agent_width}} {'Input':>9} {'Output':>9} {'Total':>9} {'Turns':>6} {'Tools':>6} {'Context%':>9}  {'Model':<25}[/dim]"
     )
 
     # Print agent rows - use styling based on subdued_colors flag
@@ -103,6 +107,7 @@ def display_usage_report(
         output_str = f"{data['output']:,}"
         total_str = f"{data['total']:,}"
         turns_str = str(data["turns"])
+        tools_str = str(data["tool_calls"])
         context_str = f"{data['context']:.1f}%" if data["context"] is not None else "-"
 
         # Truncate agent name if needed
@@ -118,6 +123,7 @@ def display_usage_report(
                 f"{output_str:>9} "
                 f"[bold]{total_str:>9}[/bold] "
                 f"{turns_str:>6} "
+                f"{tools_str:>6} "
                 f"{context_str:>9}  "
                 f"{data['model']:<25}[/dim]"
             )
@@ -129,6 +135,7 @@ def display_usage_report(
                 f"{output_str:>9} "
                 f"[bold]{total_str:>9}[/bold] "
                 f"{turns_str:>6} "
+                f"{tools_str:>6} "
                 f"{context_str:>9}  "
                 f"[dim]{data['model']:<25}[/dim]"
             )
@@ -139,6 +146,7 @@ def display_usage_report(
         total_input_str = f"{total_input:,}"
         total_output_str = f"{total_output:,}"
         total_tokens_str = f"{total_tokens:,}"
+        total_tools_str = str(total_tool_calls)
 
         if subdued_colors:
             # Original fastagent.py style with dim wrapper on bold
@@ -148,6 +156,7 @@ def display_usage_report(
                 f"{total_output_str:>9} "
                 f"[bold]{total_tokens_str:>9}[/bold] "
                 f"{'':<6} "
+                f"{total_tools_str:>6} "
                 f"{'':<9}  "
                 f"{'':<25}[/bold dim]"
             )
@@ -159,6 +168,7 @@ def display_usage_report(
                 f"[bold]{total_output_str:>9}[/bold] "
                 f"[bold]{total_tokens_str:>9}[/bold] "
                 f"{'':<6} "
+                f"[bold]{total_tools_str:>6}[/bold] "
                 f"{'':<9}  "
                 f"{'':<25}"
             )

mcp_agent/core/validation.py

@@ -52,7 +52,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
 
     for name, agent_data in agents.items():
         agent_type = agent_data["type"]  # This is a string from config
-        
+
         # Note: Compare string values from config with the Enum's string value
         if agent_type == AgentType.PARALLEL.value:
             # Check fan_in exists
@@ -226,7 +226,7 @@ def get_dependencies_groups(
     # Build the dependency graph
     for name, agent_data in agents_dict.items():
         agent_type = agent_data["type"]  # This is a string from config
-        
+
         # Note: Compare string values from config with the Enum's string value
         if agent_type == AgentType.PARALLEL.value:
             # Parallel agents depend on their fan-out and fan-in agents
@@ -305,3 +305,22 @@ def get_dependencies_groups(
         remaining -= current_level
 
     return result
+
+
+def validate_provider_keys_post_creation(active_agents: Dict[str, Any]) -> None:
+    """
+    Validate that API keys are available for all created agents with LLMs.
+
+    This runs after agent creation when we have actual agent instances.
+
+    Args:
+        active_agents: Dictionary of created agent instances
+
+    Raises:
+        ProviderKeyError: If any required API key is missing
+    """
+    for agent_name, agent in active_agents.items():
+        llm = getattr(agent, "_llm", None)
+        if llm:
+            # This throws a ProviderKeyError if the key is not present
+            llm._api_key()

mcp_agent/human_input/elicitation_form.py

@@ -16,7 +16,6 @@ from prompt_toolkit.validation import ValidationError, Validator
 from prompt_toolkit.widgets import (
     Button,
     Checkbox,
-    Dialog,
     Frame,
     Label,
     RadioList,
@@ -187,13 +186,31 @@ class ElicitationForm:
             height=len(self.message.split("\n")),
         )
 
-        # Create form fields - removed useless horizontal divider
-        form_fields = [
-            fastagent_header,  # Fast-agent info
-            Window(height=1),  # Spacing
-            mcp_header,  # MCP server message
-            Window(height=1),  # Spacing
-        ]
+        # Create sticky headers (outside scrollable area)
+        sticky_headers = HSplit(
+            [
+                Window(height=1),  # Top padding
+                VSplit(
+                    [
+                        Window(width=2),  # Left padding
+                        fastagent_header,  # Fast-agent info
+                        Window(width=2),  # Right padding
+                    ]
+                ),
+                Window(height=1),  # Spacing
+                VSplit(
+                    [
+                        Window(width=2),  # Left padding
+                        mcp_header,  # MCP server message
+                        Window(width=2),  # Right padding
+                    ]
+                ),
+                Window(height=1),  # Spacing
+            ]
+        )
+
+        # Create scrollable form fields (without headers)
+        form_fields = []
 
         for field_name, field_def in self.properties.items():
             field_widget = self._create_field(field_name, field_def)
@@ -228,18 +245,17 @@ class ElicitationForm:
             ]
         )
 
-        # Main layout
+        # Main scrollable content (form fields and buttons only)
         form_fields.extend([self.status_line, buttons])
-        content = HSplit(form_fields)
+        scrollable_form_content = HSplit(form_fields)
 
-        # Add padding around content using HSplit and VSplit with empty windows
-        padded_content = HSplit(
+        # Add padding around scrollable content
+        padded_scrollable_content = HSplit(
             [
-                Window(height=1),  # Top padding
                 VSplit(
                     [
                         Window(width=2),  # Left padding
-                        content,
+                        scrollable_form_content,
                         Window(width=2),  # Right padding
                     ]
                 ),
@@ -247,20 +263,36 @@ class ElicitationForm:
             ]
         )
 
-        # Wrap content in ScrollablePane to handle oversized forms
+        # Wrap only form fields in ScrollablePane (headers stay fixed)
         scrollable_content = ScrollablePane(
-            content=padded_content,
+            content=padded_scrollable_content,
             show_scrollbar=False,  # Only show when content exceeds available space
             display_arrows=False,  # Only show when content exceeds available space
             keep_cursor_visible=True,
             keep_focused_window_visible=True,
         )
 
-        # Dialog - formatted title with better styling and text
-        dialog = Dialog(
-            title=FormattedText([("class:title", "Elicitation Request")]),
-            body=scrollable_content,
-            with_background=True,  # Re-enable background for proper layout
+        # Create title bar manually
+        title_bar = Window(
+            FormattedTextControl(FormattedText([("class:title", "Elicitation Request")])),
+            height=1,
+            style="class:dialog.title",
+        )
+
+        # Combine title, sticky headers, and scrollable content
+        full_content = HSplit(
+            [
+                title_bar,
+                Window(height=1),  # Spacing after title
+                sticky_headers,  # Headers stay fixed at top
+                scrollable_content,  # Form fields can scroll
+            ]
+        )
+
+        # Create dialog frame manually to avoid Dialog's internal scrolling
+        dialog = Frame(
+            body=full_content,
+            style="class:dialog",
         )
 
         # Key bindings

mcp_agent/llm/augmented_llm.py

@@ -36,7 +36,7 @@ from mcp_agent.llm.sampling_format_converter import (
     BasicFormatConverter,
     ProviderFormatConverter,
 )
-from mcp_agent.llm.usage_tracking import UsageAccumulator
+from mcp_agent.llm.usage_tracking import TurnUsage, 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 (
@@ -123,6 +123,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         ] = BasicFormatConverter,
         context: Optional["Context"] = None,
         model: Optional[str] = None,
+        api_key: Optional[str] = None,
         **kwargs: dict[str, Any],
     ) -> None:
         """
@@ -158,6 +159,9 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # Initialize the display component
         self.display = ConsoleDisplay(config=self.context.config)
 
+        # Tool call counter for current turn
+        self._current_turn_tool_calls = 0
+
         # Initialize default parameters, passing model info
         model_kwargs = kwargs.copy()
         if model:
@@ -173,6 +177,8 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         self.type_converter = type_converter
         self.verb = kwargs.get("verb")
 
+        self._init_api_key = api_key
+
         # Initialize usage tracking
         self.usage_accumulator = UsageAccumulator()
 
@@ -440,15 +446,25 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
     def show_tool_result(self, result: CallToolResult) -> None:
         """Display a tool result in a formatted panel."""
-        self.display.show_tool_result(result)
+        self.display.show_tool_result(result, name=self.name)
 
     def show_oai_tool_result(self, result: str) -> None:
         """Display a tool result in a formatted panel."""
-        self.display.show_oai_tool_result(result)
+        self.display.show_oai_tool_result(result, name=self.name)
 
     def show_tool_call(self, available_tools, tool_name, tool_args) -> None:
         """Display a tool call in a formatted panel."""
-        self.display.show_tool_call(available_tools, tool_name, tool_args)
+        self._current_turn_tool_calls += 1
+        self.display.show_tool_call(available_tools, tool_name, tool_args, name=self.name)
+
+    def _reset_turn_tool_calls(self) -> None:
+        """Reset tool call counter for new turn."""
+        self._current_turn_tool_calls = 0
+
+    def _finalize_turn_usage(self, turn_usage: "TurnUsage") -> None:
+        """Set tool call count on TurnUsage and add to accumulator."""
+        turn_usage.set_tool_calls(self._current_turn_tool_calls)
+        self.usage_accumulator.add_turn(turn_usage)
 
     async def show_assistant_message(
         self,
@@ -556,12 +572,12 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
     def _update_streaming_progress(self, content: str, model: str, estimated_tokens: int) -> int:
         """Update streaming progress with token estimation and formatting.
-        
+
         Args:
             content: The text content from the streaming event
             model: The model name
             estimated_tokens: Current token count to update
-            
+
         Returns:
             Updated estimated token count
         """
@@ -569,10 +585,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         text_length = len(content)
         additional_tokens = max(1, text_length // 4)
         new_total = estimated_tokens + additional_tokens
-        
+
         # Format token count for display
         token_str = str(new_total).rjust(5)
-        
+
         # Emit progress event
         data = {
             "progress_action": ProgressAction.STREAMING,
@@ -582,7 +598,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             "details": token_str.strip(),  # Token count goes in details for STREAMING action
         }
         self.logger.info("Streaming progress", data=data)
-        
+
         return new_total
 
     def _log_chat_finished(self, model: Optional[str] = None) -> None:
@@ -692,6 +708,9 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         return self._message_history
 
     def _api_key(self):
+        if self._init_api_key:
+            return self._init_api_key
+
         from mcp_agent.llm.provider_key_manager import ProviderKeyManager
 
         assert self.provider

mcp_agent/llm/augmented_llm_silent.py

@@ -0,0 +1,48 @@
+"""Silent LLM implementation that suppresses display output while maintaining functionality."""
+
+from typing import Any
+
+from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.llm.provider_types import Provider
+from mcp_agent.llm.usage_tracking import TurnUsage, UsageAccumulator
+
+
+class ZeroUsageAccumulator(UsageAccumulator):
+    """Usage accumulator that always reports zero usage."""
+    
+    def add_turn(self, turn: TurnUsage) -> None:
+        """Override to do nothing - no usage accumulation."""
+        pass
+
+
+class SilentLLM(PassthroughLLM):
+    """
+    A specialized LLM that processes messages like PassthroughLLM but suppresses all display output.
+    
+    This is particularly useful for parallel agent workflows where the fan-in agent
+    should aggregate results without polluting the console with intermediate output.
+    Token counting is disabled - the model always reports zero usage.
+    """
+    
+    def __init__(
+        self, provider=Provider.FAST_AGENT, name: str = "Silent", **kwargs: dict[str, Any]
+    ) -> None:
+        super().__init__(name=name, provider=provider, **kwargs)
+        # Override with zero usage accumulator - silent model reports no usage
+        self.usage_accumulator = ZeroUsageAccumulator()
+    
+    def show_user_message(self, message: Any, **kwargs) -> None:
+        """Override to suppress user message display."""
+        pass
+    
+    async def show_assistant_message(self, message: Any, **kwargs) -> None:
+        """Override to suppress assistant message display."""
+        pass
+    
+    def show_tool_calls(self, tool_calls: Any, **kwargs) -> None:
+        """Override to suppress tool call display."""
+        pass
+    
+    def show_tool_results(self, tool_results: Any, **kwargs) -> None:
+        """Override to suppress tool result display."""
+        pass

mcp_agent/llm/model_database.py

@@ -47,6 +47,7 @@ class ModelDatabase:
         "video/mp4",
     ]
     QWEN_MULTIMODAL = ["text/plain", "image/jpeg", "image/png", "image/webp"]
+    XAI_VISION = ["text/plain", "image/jpeg", "image/png", "image/webp"]
     TEXT_ONLY = ["text/plain"]
 
     # Common parameter configurations
@@ -128,10 +129,22 @@ class ModelDatabase:
         context_window=2097152, max_output_tokens=8192, tokenizes=GOOGLE_MULTIMODAL
     )
 
+    # FIXME: xAI has not documented the max output tokens for Grok 4. Using Grok 3 as a placeholder. Will need to update when available (if ever)
+    GROK_4 = ModelParameters(
+        context_window=256000, max_output_tokens=16385, tokenizes=XAI_VISION
+    )
+
+    # Source for Grok 3 max output: https://www.reddit.com/r/grok/comments/1j7209p/exploring_grok_3_beta_output_capacity_a_simple/
+    # xAI does not document Grok 3 max output tokens, using the above source as a reference.
+    GROK_3 = ModelParameters(
+        context_window=131072, max_output_tokens=16385, tokenizes=TEXT_ONLY
+    )
+
     # Model configuration database
     MODELS: Dict[str, ModelParameters] = {
         # internal models
         "passthrough": FAST_AGENT_STANDARD,
+        "silent": FAST_AGENT_STANDARD,
         "playback": FAST_AGENT_STANDARD,
         "slow": FAST_AGENT_STANDARD,
         # aliyun models
@@ -194,6 +207,13 @@ class ModelDatabase:
         "gemini-2.5-pro-preview": GEMINI_2_5_PRO,
         "gemini-2.5-flash-preview-05-20": GEMINI_FLASH,
         "gemini-2.5-pro-preview-05-06": GEMINI_PRO,
+        # xAI Grok Models
+        "grok-4": GROK_4,
+        "grok-4-0709": GROK_4,
+        "grok-3": GROK_3,
+        "grok-3-mini": GROK_3,
+        "grok-3-fast": GROK_3,
+        "grok-3-mini-fast": GROK_3,
     }
 
     @classmethod

mcp_agent/llm/model_factory.py

@@ -8,11 +8,13 @@ from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
 from mcp_agent.llm.augmented_llm_playback import PlaybackLLM
+from mcp_agent.llm.augmented_llm_silent import SilentLLM
 from mcp_agent.llm.augmented_llm_slow import SlowLLM
 from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_aliyun import AliyunAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_azure import AzureOpenAIAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_bedrock import BedrockAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_google_native import GoogleNativeAugmentedLLM
@@ -20,6 +22,7 @@ from mcp_agent.llm.providers.augmented_llm_google_oai import GoogleOaiAugmentedL
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_tensorzero import TensorZeroAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_xai import XAIAugmentedLLM
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
 
 # from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
@@ -31,6 +34,7 @@ LLMClass = Union[
     Type[OpenAIAugmentedLLM],
     Type[PassthroughLLM],
     Type[PlaybackLLM],
+    Type[SilentLLM],
     Type[SlowLLM],
     Type[DeepSeekAugmentedLLM],
     Type[OpenRouterAugmentedLLM],
@@ -38,6 +42,7 @@ LLMClass = Union[
     Type[GoogleNativeAugmentedLLM],
     Type[GenericAugmentedLLM],
     Type[AzureOpenAIAugmentedLLM],
+    Type[BedrockAugmentedLLM],
 ]
 
 
@@ -75,6 +80,7 @@ class ModelFactory:
     """
     DEFAULT_PROVIDERS = {
         "passthrough": Provider.FAST_AGENT,
+        "silent": Provider.FAST_AGENT,
         "playback": Provider.FAST_AGENT,
         "slow": Provider.FAST_AGENT,
         "gpt-4o": Provider.OPENAI,
@@ -106,10 +112,17 @@ class ModelFactory:
         "gemini-2.0-flash": Provider.GOOGLE,
         "gemini-2.5-flash-preview-05-20": Provider.GOOGLE,
         "gemini-2.5-pro-preview-05-06": Provider.GOOGLE,
+        "grok-4": Provider.XAI,
+        "grok-4-0709": Provider.XAI,
+        "grok-3": Provider.XAI,
+        "grok-3-mini": Provider.XAI,
+        "grok-3-fast": Provider.XAI,
+        "grok-3-mini-fast": Provider.XAI,
         "qwen-turbo": Provider.ALIYUN,
         "qwen-plus": Provider.ALIYUN,
         "qwen-max": Provider.ALIYUN,
         "qwen-long": Provider.ALIYUN,
+
     }
 
     MODEL_ALIASES = {
@@ -140,16 +153,19 @@ class ModelFactory:
         Provider.GENERIC: GenericAugmentedLLM,
         Provider.GOOGLE_OAI: GoogleOaiAugmentedLLM,
         Provider.GOOGLE: GoogleNativeAugmentedLLM,
+        Provider.XAI: XAIAugmentedLLM,
         Provider.OPENROUTER: OpenRouterAugmentedLLM,
         Provider.TENSORZERO: TensorZeroAugmentedLLM,
         Provider.AZURE: AzureOpenAIAugmentedLLM,
         Provider.ALIYUN: AliyunAugmentedLLM,
+        Provider.BEDROCK: BedrockAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes
     # This overrides the provider-based class selection
     MODEL_SPECIFIC_CLASSES: Dict[str, LLMClass] = {
         "playback": PlaybackLLM,
+        "silent": SilentLLM,
         "slow": SlowLLM,
     }
 
@@ -197,6 +213,11 @@ class ModelFactory:
         # If provider still None, try to get from DEFAULT_PROVIDERS using the model_name_str
         if provider is None:
             provider = cls.DEFAULT_PROVIDERS.get(model_name_str)
+            
+            # If still None, try pattern matching for Bedrock models
+            if provider is None and BedrockAugmentedLLM.matches_model_pattern(model_name_str):
+                provider = Provider.BEDROCK
+            
             if provider is None:
                 raise ModelConfigError(
                     f"Unknown model or provider for: {model_string}. Model name parsed as '{model_name_str}'"

mcp_agent/llm/provider_key_manager.py

@@ -11,12 +11,8 @@ from pydantic import BaseModel
 from mcp_agent.core.exceptions import ProviderKeyError
 
 PROVIDER_ENVIRONMENT_MAP: Dict[str, str] = {
-    "anthropic": "ANTHROPIC_API_KEY",
-    "openai": "OPENAI_API_KEY",
-    "deepseek": "DEEPSEEK_API_KEY",
-    "google": "GOOGLE_API_KEY",
-    "openrouter": "OPENROUTER_API_KEY",
-    "generic": "GENERIC_API_KEY",
+    # default behaviour in _get_env_key_name is to capitalize the
+    # provider name and suffix "_API_KEY" - so no specific mapping needed unless overriding
     "huggingface": "HF_TOKEN",
 }
 API_KEY_HINT_TEXT = "<your-api-key-here>"
@@ -66,7 +62,14 @@ class ProviderKeyManager:
             ProviderKeyError: If the API key is not found or is invalid
         """
 
+        from mcp_agent.llm.provider_types import Provider
+
         provider_name = provider_name.lower()
+
+        # Fast-agent provider doesn't need external API keys
+        if provider_name == "fast-agent":
+            return ""
+
         api_key = ProviderKeyManager.get_config_file_key(provider_name, config)
         if not api_key:
             api_key = ProviderKeyManager.get_env_var(provider_name)
@@ -75,9 +78,20 @@ class ProviderKeyManager:
             api_key = "ollama"  # Default for generic provider
 
         if not api_key:
+            # Get proper display name for error message
+            try:
+                provider_enum = Provider(provider_name)
+                display_name = provider_enum.display_name
+            except ValueError:
+                # Invalid provider name
+                raise ProviderKeyError(
+                    f"Invalid provider: {provider_name}",
+                    f"'{provider_name}' is not a valid provider name.",
+                )
+
             raise ProviderKeyError(
-                f"{provider_name.title()} API key not configured",
-                f"The {provider_name.title()} API key is required but not set.\n"
+                f"{display_name} API key not configured",
+                f"The {display_name} API key is required but not set.\n"
                 f"Add it to your configuration file under {provider_name}.api_key "
                 f"or set the {ProviderKeyManager.get_env_key_name(provider_name)} environment variable.",
             )

mcp_agent/llm/provider_types.py

@@ -8,15 +8,23 @@ from enum import Enum
 class Provider(Enum):
     """Supported LLM providers"""
 
-    ANTHROPIC = "anthropic"
-    DEEPSEEK = "deepseek"
-    FAST_AGENT = "fast-agent"
-    GENERIC = "generic"
-    GOOGLE_OAI = "googleoai"  # For Google through OpenAI libraries
-    GOOGLE = "google"  # For Google GenAI native library
-    OPENAI = "openai"
-    OPENROUTER = "openrouter"
-    TENSORZERO = "tensorzero"  # For TensorZero Gateway
-    AZURE = "azure"  # Azure OpenAI Service
-    ALIYUN = "aliyun"  # Aliyun Bailian OpenAI Service
-    HUGGINGFACE = "huggingface"  # For HuggingFace MCP connections
+    def __new__(cls, config_name, display_name=None):
+        obj = object.__new__(cls)
+        obj._value_ = config_name
+        obj.display_name = display_name or config_name.title()
+        return obj
+
+    ANTHROPIC = ("anthropic", "Anthropic")
+    DEEPSEEK = ("deepseek", "Deepseek")
+    FAST_AGENT = ("fast-agent", "FastAgent")
+    GENERIC = ("generic", "Generic")
+    GOOGLE_OAI = ("googleoai", "GoogleOAI")  # For Google through OpenAI libraries
+    GOOGLE = ("google", "Google")  # For Google GenAI native library
+    OPENAI = ("openai", "OpenAI")
+    OPENROUTER = ("openrouter", "OpenRouter")
+    TENSORZERO = ("tensorzero", "TensorZero")  # For TensorZero Gateway
+    AZURE = ("azure", "Azure")  # Azure OpenAI Service
+    ALIYUN = ("aliyun", "Aliyun")  # Aliyun Bailian OpenAI Service
+    HUGGINGFACE = ("huggingface", "HuggingFace")  # For HuggingFace MCP connections
+    XAI = ("xai", "XAI")  # For xAI Grok models
+    BEDROCK = ("bedrock", "Bedrock")

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -112,7 +112,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 and event.delta.type == "text_delta"
             ):
                 # Use base class method for token estimation and progress emission
-                estimated_tokens = self._update_streaming_progress(event.delta.text, model, estimated_tokens)
+                estimated_tokens = self._update_streaming_progress(
+                    event.delta.text, model, estimated_tokens
+                )
 
             # Also check for final message_delta events with actual usage info
             elif (
@@ -285,7 +287,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                     turn_usage = TurnUsage.from_anthropic(
                         response.usage, model or DEFAULT_ANTHROPIC_MODEL
                     )
-                    self.usage_accumulator.add_turn(turn_usage)
+                    self._finalize_turn_usage(turn_usage)
                 #                    self._show_usage(response.usage, turn_usage)
                 except Exception as e:
                     self.logger.warning(f"Failed to track usage: {e}")
@@ -435,6 +437,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         Override this method to use a different LLM.
 
         """
+        # Reset tool call counter for new turn
+        self._reset_turn_tool_calls()
+
         res = await self._anthropic_completion(
             message_param=message_param,
             request_params=request_params,