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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.34
+Version: 0.2.35
 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.34 → fast_agent_mcp-0.2.35}/pyproject.toml

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

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

@@ -115,6 +115,14 @@ class AnthropicSettings(BaseModel):
 
     base_url: str | None = None
 
+    cache_mode: Literal["off", "prompt", "auto"] = "auto"
+    """
+    Controls how caching is applied for Anthropic models when prompt_caching is enabled globally.
+    - "off": No caching, even if global prompt_caching is true.
+    - "prompt": Caches tools+system prompt (1 block) and template content. Useful for large, static prompts.
+    - "auto": Currently same as "prompt" - caches tools+system prompt (1 block) and template content.
+    """
+
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 

{fast_agent_mcp-0.2.34 → fast_agent_mcp-0.2.35}/src/mcp_agent/context.py

@@ -25,7 +25,7 @@ from pydantic import BaseModel, ConfigDict
 from mcp_agent.config import Settings, get_settings
 from mcp_agent.executor.executor import AsyncioExecutor, Executor
 from mcp_agent.executor.task_registry import ActivityRegistry
-from mcp_agent.logging.events import EventFilter
+from mcp_agent.logging.events import EventFilter, StreamingExclusionFilter
 from mcp_agent.logging.logger import LoggingConfig, get_logger
 from mcp_agent.logging.transport import create_transport
 from mcp_agent.mcp_server_registry import ServerRegistry
@@ -124,7 +124,8 @@ async def configure_logger(config: "Settings") -> None:
     """
     Configure logging and tracing based on the application config.
     """
-    event_filter: EventFilter = EventFilter(min_level=config.logger.level)
+    # Use StreamingExclusionFilter to prevent streaming events from flooding logs
+    event_filter: EventFilter = StreamingExclusionFilter(min_level=config.logger.level)
     logger.info(f"Configuring logger with level: {config.logger.level}")
     transport = create_transport(settings=config.logger, event_filter=event_filter)
     await LoggingConfig.configure(

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

@@ -302,7 +302,7 @@ class AgentApp:
             return
             
         last_turn = turns[-1]
-        input_tokens = last_turn.input_tokens
+        input_tokens = last_turn.display_input_tokens
         output_tokens = last_turn.output_tokens
         
         # Build cache indicators with bright colors

{fast_agent_mcp-0.2.34 → fast_agent_mcp-0.2.35}/src/mcp_agent/event_progress.py

@@ -15,6 +15,7 @@ class ProgressAction(str, Enum):
     LOADED = "Loaded"
     INITIALIZED = "Initialized"
     CHATTING = "Chatting"
+    STREAMING = "Streaming"  # Special action for real-time streaming updates
     ROUTING = "Routing"
     PLANNING = "Planning"
     READY = "Ready"
@@ -33,12 +34,22 @@ class ProgressEvent(BaseModel):
     target: str
     details: Optional[str] = None
     agent_name: Optional[str] = None
+    streaming_tokens: Optional[str] = None  # Special field for streaming token count
 
     def __str__(self) -> str:
         """Format the progress event for display."""
-        base = f"{self.action.ljust(11)}. {self.target}"
-        if self.details:
-            base += f" - {self.details}"
+        # Special handling for streaming - show token count in action position
+        if self.action == ProgressAction.STREAMING and self.streaming_tokens:
+            # For streaming, show just the token count instead of "Streaming"
+            action_display = self.streaming_tokens.ljust(11)
+            base = f"{action_display}. {self.target}"
+            if self.details:
+                base += f" - {self.details}"
+        else:
+            base = f"{self.action.ljust(11)}. {self.target}"
+            if self.details:
+                base += f" - {self.details}"
+        
         if self.agent_name:
             base = f"[{self.agent_name}] {base}"
         return base
@@ -78,7 +89,8 @@ def convert_log_event(event: Event) -> Optional[ProgressEvent]:
 
     elif "augmented_llm" in namespace:
         model = event_data.get("model", "")
-
+        
+        # For all augmented_llm events, put model info in details column
         details = f"{model}"
         chat_turn = event_data.get("chat_turn")
         if chat_turn is not None:
@@ -87,9 +99,15 @@ def convert_log_event(event: Event) -> Optional[ProgressEvent]:
         if not target:
             target = event_data.get("target", "unknown")
 
+    # Extract streaming token count for STREAMING actions
+    streaming_tokens = None
+    if progress_action == ProgressAction.STREAMING:
+        streaming_tokens = event_data.get("details", "")
+    
     return ProgressEvent(
         action=ProgressAction(progress_action),
         target=target or "unknown",
         details=details,
         agent_name=event_data.get("agent_name"),
+        streaming_tokens=streaming_tokens,
     )

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

@@ -97,6 +97,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
     PARAM_USE_HISTORY = "use_history"
     PARAM_MAX_ITERATIONS = "max_iterations"
     PARAM_TEMPLATE_VARS = "template_vars"
+
     # Base set of fields that should always be excluded
     BASE_EXCLUDE_FIELDS = {PARAM_METADATA}
 
@@ -371,16 +372,28 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # Start with base arguments
         arguments = base_args.copy()
 
-        # Use provided exclude_fields or fall back to base exclusions
-        exclude_fields = exclude_fields or self.BASE_EXCLUDE_FIELDS.copy()
+        # Combine base exclusions with provider-specific exclusions
+        final_exclude_fields = self.BASE_EXCLUDE_FIELDS.copy()
+        if exclude_fields:
+            final_exclude_fields.update(exclude_fields)
 
         # Add all fields from params that aren't explicitly excluded
-        params_dict = request_params.model_dump(exclude=exclude_fields)
+        # Ensure model_dump only includes set fields if that's the desired behavior,
+        # or adjust exclude_unset=True/False as needed.
+        # Default Pydantic v2 model_dump is exclude_unset=False
+        params_dict = request_params.model_dump(exclude=final_exclude_fields)
+
         for key, value in params_dict.items():
+            # Only add if not None and not already in base_args (base_args take precedence)
+            # or if None is a valid value for the provider, this logic might need adjustment.
             if value is not None and key not in arguments:
                 arguments[key] = value
+            elif value is not None and key in arguments and arguments[key] is None:
+                # Allow overriding a None in base_args with a set value from params
+                arguments[key] = value
 
         # Finally, add any metadata fields as a last layer of overrides
+        # This ensures metadata can override anything previously set if keys conflict.
         if request_params.metadata:
             arguments.update(request_params.metadata)
 

fast_agent_mcp-0.2.35/src/mcp_agent/llm/memory.py

@@ -0,0 +1,223 @@
+from typing import Generic, List, Protocol, TypeVar
+
+# Define our own type variable for implementation use
+MessageParamT = TypeVar("MessageParamT")
+
+
+class Memory(Protocol, Generic[MessageParamT]):
+    """
+    Simple memory management for storing past interactions in-memory.
+    """
+
+    # TODO: saqadri - add checkpointing and other advanced memory capabilities
+
+    def __init__(self) -> None: ...
+
+    def extend(self, messages: List[MessageParamT], is_prompt: bool = False) -> None: ...
+
+    def set(self, messages: List[MessageParamT], is_prompt: bool = False) -> None: ...
+
+    def append(self, message: MessageParamT, is_prompt: bool = False) -> None: ...
+
+    def get(self, include_completion_history: bool = True) -> List[MessageParamT]: ...
+
+    def clear(self, clear_prompts: bool = False) -> None: ...
+
+
+class SimpleMemory(Memory, Generic[MessageParamT]):
+    """
+    Simple memory management for storing past interactions in-memory.
+
+    Maintains both prompt messages (which are always included) and
+    generated conversation history (which is included based on use_history setting).
+    """
+
+    def __init__(self) -> None:
+        self.history: List[MessageParamT] = []
+        self.prompt_messages: List[MessageParamT] = []  # Always included
+        self.conversation_cache_positions: List[int] = []  # Track active conversation cache positions
+        self.cache_walk_distance: int = 6  # Messages between cache blocks
+        self.max_conversation_cache_blocks: int = 2  # Maximum conversation cache blocks
+
+    def extend(self, messages: List[MessageParamT], is_prompt: bool = False) -> None:
+        """
+        Add multiple messages to history.
+
+        Args:
+            messages: Messages to add
+            is_prompt: If True, add to prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages.extend(messages)
+        else:
+            self.history.extend(messages)
+
+    def set(self, messages: List[MessageParamT], is_prompt: bool = False) -> None:
+        """
+        Replace messages in history.
+
+        Args:
+            messages: Messages to set
+            is_prompt: If True, replace prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages = messages.copy()
+        else:
+            self.history = messages.copy()
+
+    def append(self, message: MessageParamT, is_prompt: bool = False) -> None:
+        """
+        Add a single message to history.
+
+        Args:
+            message: Message to add
+            is_prompt: If True, add to prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages.append(message)
+        else:
+            self.history.append(message)
+
+    def get(self, include_completion_history: bool = True) -> List[MessageParamT]:
+        """
+        Get all messages in memory.
+
+        Args:
+            include_history: If True, include regular history messages
+                             If False, only return prompt messages
+
+        Returns:
+            Combined list of prompt messages and optionally history messages
+        """
+        if include_completion_history:
+            return self.prompt_messages + self.history
+        else:
+            return self.prompt_messages.copy()
+
+    def clear(self, clear_prompts: bool = False) -> None:
+        """
+        Clear history and optionally prompt messages.
+
+        Args:
+            clear_prompts: If True, also clear prompt messages
+        """
+        self.history = []
+        self.conversation_cache_positions = []  # Reset cache positions
+        if clear_prompts:
+            self.prompt_messages = []
+
+    def should_apply_conversation_cache(self) -> bool:
+        """
+        Determine if conversation caching should be applied based on walking algorithm.
+        
+        Returns:
+            True if we should add or update cache blocks
+        """
+        total_messages = len(self.history)
+        
+        # Need at least cache_walk_distance messages to start caching
+        if total_messages < self.cache_walk_distance:
+            return False
+            
+        # Check if we need to add a new cache block
+        return len(self._calculate_cache_positions(total_messages)) != len(self.conversation_cache_positions)
+    
+    def _calculate_cache_positions(self, total_conversation_messages: int) -> List[int]:
+        """
+        Calculate where cache blocks should be placed using walking algorithm.
+        
+        Args:
+            total_conversation_messages: Number of conversation messages (not including prompts)
+            
+        Returns:
+            List of positions (relative to conversation start) where cache should be placed
+        """
+        positions = []
+        
+        # Place cache blocks every cache_walk_distance messages
+        for i in range(self.cache_walk_distance - 1, total_conversation_messages, self.cache_walk_distance):
+            positions.append(i)
+            if len(positions) >= self.max_conversation_cache_blocks:
+                break
+        
+        # Keep only the most recent cache blocks (walking behavior)
+        if len(positions) > self.max_conversation_cache_blocks:
+            positions = positions[-self.max_conversation_cache_blocks:]
+            
+        return positions
+    
+    def get_conversation_cache_updates(self) -> dict:
+        """
+        Get cache position updates needed for the walking algorithm.
+        
+        Returns:
+            Dict with 'add', 'remove', and 'active' position lists (relative to full message array)
+        """
+        total_conversation_messages = len(self.history)
+        new_positions = self._calculate_cache_positions(total_conversation_messages)
+        
+        # Convert to absolute positions (including prompt messages)
+        prompt_offset = len(self.prompt_messages)
+        new_absolute_positions = [pos + prompt_offset for pos in new_positions]
+        
+        old_positions_set = set(self.conversation_cache_positions)
+        new_positions_set = set(new_absolute_positions)
+        
+        return {
+            'add': sorted(new_positions_set - old_positions_set),
+            'remove': sorted(old_positions_set - new_positions_set), 
+            'active': sorted(new_absolute_positions)
+        }
+    
+    def apply_conversation_cache_updates(self, updates: dict) -> None:
+        """
+        Apply cache position updates.
+        
+        Args:
+            updates: Dict from get_conversation_cache_updates()
+        """
+        self.conversation_cache_positions = updates['active'].copy()
+
+    def remove_cache_control_from_messages(self, messages: List[MessageParamT], positions: List[int]) -> None:
+        """
+        Remove cache control from specified message positions.
+        
+        Args:
+            messages: The message array to modify
+            positions: List of positions to remove cache control from
+        """
+        for pos in positions:
+            if pos < len(messages):
+                message = messages[pos]
+                if isinstance(message, dict) and "content" in message:
+                    content_list = message["content"]
+                    if isinstance(content_list, list):
+                        for content_block in content_list:
+                            if isinstance(content_block, dict) and "cache_control" in content_block:
+                                del content_block["cache_control"]
+
+    def add_cache_control_to_messages(self, messages: List[MessageParamT], positions: List[int]) -> int:
+        """
+        Add cache control to specified message positions.
+        
+        Args:
+            messages: The message array to modify  
+            positions: List of positions to add cache control to
+            
+        Returns:
+            Number of cache blocks successfully applied
+        """
+        applied_count = 0
+        for pos in positions:
+            if pos < len(messages):
+                message = messages[pos]
+                if isinstance(message, dict) and "content" in message:
+                    content_list = message["content"]
+                    if isinstance(content_list, list) and content_list:
+                        # Apply cache control to the last content block
+                        for content_block in reversed(content_list):
+                            if isinstance(content_block, dict):
+                                content_block["cache_control"] = {"type": "ephemeral"}
+                                applied_count += 1
+                                break
+        return applied_count

{fast_agent_mcp-0.2.34 → fast_agent_mcp-0.2.35}/src/mcp_agent/llm/model_database.py

@@ -109,11 +109,11 @@ class ModelDatabase:
 
     # TODO update to 32000
     ANTHROPIC_OPUS_4_VERSIONED = ModelParameters(
-        context_window=200000, max_output_tokens=16384, tokenizes=ANTHROPIC_MULTIMODAL
+        context_window=200000, max_output_tokens=32000, tokenizes=ANTHROPIC_MULTIMODAL
     )
     # TODO update to 64000
     ANTHROPIC_SONNET_4_VERSIONED = ModelParameters(
-        context_window=200000, max_output_tokens=16384, tokenizes=ANTHROPIC_MULTIMODAL
+        context_window=200000, max_output_tokens=64000, tokenizes=ANTHROPIC_MULTIMODAL
     )
 
     DEEPSEEK_CHAT_STANDARD = ModelParameters(