fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

{mcp_agent → fast_agent}/mcp/prompts/prompt_template.py

@@ -16,16 +16,16 @@ from mcp.types import (
 )
 from pydantic import BaseModel, field_validator
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.prompt_serialization import (
+from fast_agent.mcp.prompt_serialization import (
     multipart_messages_to_delimited_format,
 )
-from mcp_agent.mcp.prompts.prompt_constants import (
+from fast_agent.mcp.prompts.prompt_constants import (
     ASSISTANT_DELIMITER,
     DEFAULT_DELIMITER_MAP,
     RESOURCE_DELIMITER,
     USER_DELIMITER,
 )
+from fast_agent.types import PromptMessageExtended
 
 
 class PromptMetadata(BaseModel):
@@ -108,14 +108,14 @@ class PromptTemplate:
     @classmethod
     def from_multipart_messages(
         cls,
-        messages: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         delimiter_map: Optional[Dict[str, str]] = None,
     ) -> "PromptTemplate":
         """
-        Create a PromptTemplate from a list of PromptMessageMultipart objects.
+        Create a PromptTemplate from a list of PromptMessageExtended objects.
 
         Args:
-            messages: List of PromptMessageMultipart objects
+            messages: List of PromptMessageExtended objects
             delimiter_map: Optional map of delimiters to roles
 
         Returns:
@@ -165,17 +165,17 @@ class PromptTemplate:
         # Create a new list with substitutions applied to each section
         return [section.apply_substitutions(context) for section in self._parsed_content]
 
-    def apply_substitutions_to_multipart(
+    def apply_substitutions_to_extended(
         self, context: Dict[str, Any]
-    ) -> List[PromptMessageMultipart]:
+    ) -> List[PromptMessageExtended]:
         """
-        Apply variable substitutions to the template and return PromptMessageMultipart objects.
+        Apply variable substitutions to the template and return PromptMessageExtended objects.
 
         Args:
             context: Dictionary of variable names to values
 
         Returns:
-            List of PromptMessageMultipart objects with substitutions applied
+            List of PromptMessageExtended objects with substitutions applied
         """
         # First create a substituted template
         content_sections = self.apply_substitutions(context)
@@ -201,7 +201,7 @@ class PromptTemplate:
                     )
                 )
 
-            multiparts.append(PromptMessageMultipart(role=section.role, content=content_items))
+            multiparts.append(PromptMessageExtended(role=section.role, content=content_items))
 
         return multiparts
 
@@ -211,12 +211,12 @@ class PromptTemplate:
         matches = re.findall(variable_pattern, text)
         return set(matches)
 
-    def to_multipart_messages(self) -> List[PromptMessageMultipart]:
+    def to_extended_messages(self) -> List[PromptMessageExtended]:
         """
-        Convert this template to a list of PromptMessageMultipart objects.
+        Convert this template to a list of PromptMessageExtended objects.
 
         Returns:
-            List of PromptMessageMultipart objects
+            List of PromptMessageExtended objects
         """
         multiparts = []
 
@@ -239,7 +239,7 @@ class PromptTemplate:
                     )
                 )
 
-            multiparts.append(PromptMessageMultipart(role=section.role, content=content_items))
+            multiparts.append(PromptMessageExtended(role=section.role, content=content_items))
 
         return multiparts
 
@@ -348,12 +348,12 @@ class PromptTemplateLoader:
 
         return PromptTemplate(content, self.delimiter_map, template_file_path=file_path)
 
-    def load_from_multipart(self, messages: List[PromptMessageMultipart]) -> PromptTemplate:
+    def load_from_multipart(self, messages: List[PromptMessageExtended]) -> PromptTemplate:
         """
-        Create a PromptTemplate from a list of PromptMessageMultipart objects.
+        Create a PromptTemplate from a list of PromptMessageExtended objects.
 
         Args:
-            messages: List of PromptMessageMultipart objects
+            messages: List of PromptMessageExtended objects
 
         Returns:
             A PromptTemplate object

{mcp_agent → fast_agent}/mcp/resource_utils.py

@@ -10,7 +10,7 @@ from mcp.types import (
 )
 from pydantic import AnyUrl
 
-import mcp_agent.mcp.mime_utils as mime_utils
+import fast_agent.mcp.mime_utils as mime_utils
 
 HTTP_TIMEOUT = 10  # Default timeout for HTTP requests
 

{mcp_agent → fast_agent}/mcp/sampling.py

@@ -1,5 +1,5 @@
 """
-This simplified implementation directly converts between MCP types and PromptMessageMultipart.
+This simplified implementation directly converts between MCP types and PromptMessageExtended.
 """
 
 from typing import TYPE_CHECKING
@@ -7,21 +7,23 @@ from typing import TYPE_CHECKING
 from mcp import ClientSession
 from mcp.types import CreateMessageRequestParams, CreateMessageResult, TextContent
 
-from mcp_agent.core.agent_types import AgentConfig
-from mcp_agent.llm.sampling_converter import SamplingConverter
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.helpers.server_config_helpers import get_server_config
-from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
+from fast_agent.agents.agent_types import AgentConfig
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.interfaces import FastAgentLLMProtocol
+from fast_agent.llm.sampling_converter import SamplingConverter
+from fast_agent.mcp.helpers.server_config_helpers import get_server_config
+from fast_agent.types.llm_stop_reason import LlmStopReason
 
 if TYPE_CHECKING:
-    from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+    from fast_agent.types import PromptMessageExtended
 
 logger = get_logger(__name__)
 
 
 def create_sampling_llm(
     params: CreateMessageRequestParams, model_string: str, api_key: str | None
-) -> AugmentedLLMProtocol:
+) -> FastAgentLLMProtocol:
     """
     Create an LLM instance for sampling without tools support.
     This utility function creates a minimal LLM instance based on the model string.
@@ -33,21 +35,19 @@ def create_sampling_llm(
     Returns:
         An initialized LLM instance ready to use
     """
-    from mcp_agent.agents.agent import Agent
-    from mcp_agent.llm.model_factory import ModelFactory
+    from fast_agent.llm.model_factory import ModelFactory
 
     app_context = None
     try:
-        from mcp_agent.context import get_current_context
+        from fast_agent.context import get_current_context
 
         app_context = get_current_context()
     except Exception:
         logger.warning("App context not available for sampling call")
 
-    agent = Agent(
+    agent = LlmAgent(
         config=sampling_agent_config(params),
         context=app_context,
-        connection_persistence=False,
     )
 
     # Create the LLM using the factory
@@ -82,30 +82,33 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
     try:
         # Extract model from server config using type-safe helper
         server_config = get_server_config(mcp_ctx)
-        
+
         # First priority: explicitly configured sampling model
         if server_config and hasattr(server_config, "sampling") and server_config.sampling:
             model = server_config.sampling.model
-        
+
         # Second priority: auto_sampling fallback (if enabled at application level)
         if model is None:
             # Check if auto_sampling is enabled
             auto_sampling_enabled = False
             try:
-                from mcp_agent.context import get_current_context
+                from fast_agent.context import get_current_context
+
                 app_context = get_current_context()
                 if app_context and app_context.config:
-                    auto_sampling_enabled = getattr(app_context.config, 'auto_sampling', True)
+                    auto_sampling_enabled = getattr(app_context.config, "auto_sampling", True)
             except Exception as e:
                 logger.debug(f"Could not get application config: {e}")
                 auto_sampling_enabled = True  # Default to enabled
-            
+
             if auto_sampling_enabled:
                 # Import here to avoid circular import
-                from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
-                
+                from fast_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+
                 # Try agent's model first (from the session)
-                if hasattr(mcp_ctx, "session") and isinstance(mcp_ctx.session, MCPAgentClientSession):
+                if hasattr(mcp_ctx, "session") and isinstance(
+                    mcp_ctx.session, MCPAgentClientSession
+                ):
                     if mcp_ctx.session.agent_model:
                         model = mcp_ctx.session.agent_model
                         logger.debug(f"Using agent's model for sampling: {model}")
@@ -123,7 +126,9 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
                         logger.debug(f"Could not get system default model: {e}")
 
         if model is None:
-            raise ValueError("No model configured for sampling (server config, agent model, or system default)")
+            raise ValueError(
+                "No model configured for sampling (server config, agent model, or system default)"
+            )
 
         # Create an LLM instance
         llm = create_sampling_llm(params, model, api_key)
@@ -132,20 +137,20 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
         if not params.messages:
             raise ValueError("No messages provided")
 
-        # Convert all SamplingMessages to PromptMessageMultipart objects
+        # Convert all SamplingMessages to PromptMessageExtended objects
         conversation = SamplingConverter.convert_messages(params.messages)
 
         # Extract request parameters using our converter
         request_params = SamplingConverter.extract_request_params(params)
 
-        llm_response: PromptMessageMultipart = await llm.generate(conversation, request_params)
+        llm_response: PromptMessageExtended = await llm.generate(conversation, request_params)
         logger.info(f"Complete sampling request : {llm_response.first_text()[:50]}...")
 
         return CreateMessageResult(
             role=llm_response.role,
             content=TextContent(type="text", text=llm_response.first_text()),
             model=model,
-            stopReason="endTurn",
+            stopReason=LlmStopReason.END_TURN.value,
         )
     except Exception as e:
         logger.error(f"Error in sampling: {str(e)}")
@@ -171,4 +176,4 @@ def sampling_agent_config(
     if params and params.systemPrompt is not None:
         instruction = params.systemPrompt
 
-    return AgentConfig(name="sampling_agent", instruction=instruction, servers=[])
+    return AgentConfig(name="sampling_agent", instruction=instruction)

{mcp_agent/mcp_server → fast_agent/mcp/server}/__init__.py

@@ -1,4 +1,4 @@
 # Import and re-export AgentMCPServer to avoid circular imports
-from mcp_agent.mcp_server.agent_server import AgentMCPServer
+from fast_agent.mcp.server.agent_server import AgentMCPServer
 
 __all__ = ["AgentMCPServer"]

{mcp_agent/mcp_server → fast_agent/mcp/server}/agent_server.py

@@ -11,11 +11,10 @@ from typing import Set
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
 
-import mcp_agent
-import mcp_agent.core
-import mcp_agent.core.prompt
-from mcp_agent.core.agent_app import AgentApp
-from mcp_agent.logging.logger import get_logger
+import fast_agent.core
+import fast_agent.core.prompt
+from fast_agent.core.agent_app import AgentApp
+from fast_agent.core.logging.logger import get_logger
 
 logger = get_logger(__name__)
 
@@ -96,7 +95,7 @@ class AgentMCPServer:
 
             # Convert the multipart message history to standard PromptMessages
             multipart_history = agent._llm.message_history
-            prompt_messages = mcp_agent.core.prompt.Prompt.from_multipart(multipart_history)
+            prompt_messages = fast_agent.core.prompt.Prompt.from_multipart(multipart_history)
 
             # In FastMCP, we need to return the raw list of messages
             # that matches the structure that FastMCP expects (list of dicts with role/content)

fast_agent/mcp/ui_agent.py

@@ -0,0 +1,48 @@
+"""
+MCP Agent with UI support using mixin pattern.
+
+This module provides a concrete agent class that combines McpAgent
+with UI functionality through the mixin pattern.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from fast_agent.agents.mcp_agent import McpAgent
+from fast_agent.mcp.ui_mixin import McpUIMixin
+
+if TYPE_CHECKING:
+    from fast_agent.context import Context
+
+
+class McpAgentWithUI(McpUIMixin, McpAgent):
+    """
+    MCP Agent with UI resource handling capabilities.
+
+    This class combines the base McpAgent functionality with UI resource
+    processing using the mixin pattern. It's a clean, type-safe way to add
+    UI functionality without the complexity of wrapper classes.
+
+    Usage:
+        agent = McpAgentWithUI(config, context=context, ui_mode="auto")
+    """
+
+    def __init__(
+        self,
+        config,
+        context: "Context | None" = None,
+        ui_mode: str = "auto",
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize the agent with UI capabilities.
+
+        Args:
+            config: Agent configuration
+            context: Application context
+            ui_mode: UI mode - "disabled", "enabled", or "auto"
+            **kwargs: Additional arguments passed to parent classes
+        """
+        # Initialize both parent classes with the ui_mode parameter
+        super().__init__(config=config, context=context, ui_mode=ui_mode, **kwargs)

fast_agent/mcp/ui_mixin.py

@@ -0,0 +1,209 @@
+"""
+MCP UI Mixin - Clean mixin pattern for MCP UI functionality.
+
+This module provides a mixin class that can be combined with McpAgent
+to add UI resource handling without modifying the base agent implementation.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, Tuple
+
+from mcp.types import CallToolResult, ContentBlock, EmbeddedResource
+
+from fast_agent.constants import MCP_UI
+from fast_agent.ui.mcp_ui_utils import open_links_in_browser, ui_links_from_channel
+
+if TYPE_CHECKING:
+    from rich.text import Text
+
+    from fast_agent.types import PromptMessageExtended
+
+
+class McpUIMixin:
+    """
+    Mixin that adds MCP-UI resource handling to any agent.
+
+    This mixin can be combined with any agent class to add UI resource
+    extraction and display functionality. It overrides run_tools to
+    intercept tool results and extract UI resources.
+
+    Usage:
+        class MyAgentWithUI(McpUIMixin, McpAgent):
+            def __init__(self, *args, ui_mode: str = "auto", **kwargs):
+                super().__init__(*args, **kwargs)
+                self._ui_mode = ui_mode
+    """
+
+    def __init__(self, *args, ui_mode: str = "auto", **kwargs):
+        """Initialize the mixin with UI mode configuration."""
+        super().__init__(*args, **kwargs)
+        self._ui_mode: str = ui_mode
+        self._pending_ui_resources: List[ContentBlock] = []
+
+    def set_ui_mode(self, mode: str) -> None:
+        """
+        Set the UI mode for handling MCP-UI resources.
+
+        Args:
+            mode: One of "disabled", "enabled", or "auto"
+        """
+        if mode not in ("disabled", "enabled", "auto"):
+            mode = "auto"
+        self._ui_mode = mode
+
+    async def run_tools(self, request: "PromptMessageExtended") -> "PromptMessageExtended":
+        """
+        Override run_tools to extract and handle UI resources.
+
+        This method intercepts tool results, extracts any UI resources,
+        and adds them to the message channels for later display.
+        """
+        # If UI is disabled, just pass through to parent
+        if self._ui_mode == "disabled":
+            return await super().run_tools(request)  # type: ignore
+
+        # Run the tools normally via parent implementation
+        result = await super().run_tools(request)  # type: ignore
+
+        # Extract UI resources from tool results
+        if result and result.tool_results:
+            processed_results, ui_blocks = self._extract_ui_from_tool_results(result.tool_results)
+
+            # For mode 'auto', only act when we actually extracted something
+            if self._ui_mode == "enabled" or (self._ui_mode == "auto" and ui_blocks):
+                # Update tool_results with UI resources removed
+                result.tool_results = processed_results
+
+                # Add UI resources to channels
+                channels = result.channels or {}
+                current = channels.get(MCP_UI, [])
+                channels[MCP_UI] = current + ui_blocks
+                result.channels = channels
+
+                # Store for display after assistant message
+                self._pending_ui_resources = ui_blocks
+
+        return result
+
+    async def show_assistant_message(
+        self,
+        message: "PromptMessageExtended",
+        bottom_items: List[str] | None = None,
+        highlight_items: str | List[str] | None = None,
+        max_item_length: int | None = None,
+        name: str | None = None,
+        model: str | None = None,
+        additional_message: Optional["Text"] = None,
+    ) -> None:
+        """Override to display UI resources after showing assistant message."""
+        # Show the assistant message normally via parent
+        await super().show_assistant_message(  # type: ignore
+            message,
+            bottom_items,
+            highlight_items,
+            max_item_length,
+            name=name,
+            model=model,
+            additional_message=additional_message,
+        )
+
+        # Handle any pending UI resources from the previous user message
+        if self._ui_mode != "disabled":
+            await self._display_ui_resources_from_history()
+
+    async def _display_ui_resources_from_history(self) -> None:
+        """
+        Check message history for UI resources and display them.
+
+        This looks at the previous user message for any UI resources
+        that should be displayed after the assistant's response.
+        """
+        try:
+            history = self.message_history  # type: ignore
+            if history and len(history) >= 2:
+                prev = history[-2]
+                if prev and prev.role == "user":
+                    channels = prev.channels or {}
+                    ui_resources = channels.get(MCP_UI, []) if isinstance(channels, dict) else []
+                    if ui_resources:
+                        await self._display_ui_resources(ui_resources)
+        except Exception:
+            # Silently handle any errors in UI display
+            pass
+
+    async def _display_ui_resources(self, resources: Sequence[ContentBlock]) -> None:
+        """
+        Display UI resources by creating links and optionally opening in browser.
+
+        Args:
+            resources: List of UI resource content blocks
+        """
+        links = ui_links_from_channel(resources)
+        if links:
+            # Display links in console
+            await self.display.show_mcp_ui_links(links)  # type: ignore
+
+            # Auto-open in browser if in auto mode
+            if self._ui_mode == "auto":
+                open_links_in_browser(links, mcp_ui_mode=self._ui_mode)
+
+    def _extract_ui_from_tool_results(
+        self,
+        tool_results: Dict[str, CallToolResult],
+    ) -> Tuple[Dict[str, CallToolResult], List[ContentBlock]]:
+        """
+        Extract UI resources from tool results.
+
+        Returns a tuple of (cleaned_tool_results, extracted_ui_blocks).
+        """
+        if not tool_results:
+            return tool_results, []
+
+        extracted_ui: List[ContentBlock] = []
+        new_results: Dict[str, CallToolResult] = {}
+
+        for key, result in tool_results.items():
+            try:
+                ui_blocks, other_blocks = self._split_ui_blocks(list(result.content or []))
+                if ui_blocks:
+                    extracted_ui.extend(ui_blocks)
+
+                # Recreate CallToolResult without UI blocks
+                new_results[key] = CallToolResult(content=other_blocks, isError=result.isError)
+            except Exception:
+                # Pass through untouched on any error
+                new_results[key] = result
+
+        return new_results, extracted_ui
+
+    def _split_ui_blocks(
+        self, blocks: List[ContentBlock]
+    ) -> Tuple[List[ContentBlock], List[ContentBlock]]:
+        """
+        Split content blocks into UI and non-UI blocks.
+
+        Returns tuple of (ui_blocks, other_blocks).
+        """
+        ui_blocks: List[ContentBlock] = []
+        other_blocks: List[ContentBlock] = []
+
+        for block in blocks or []:
+            if self._is_ui_embedded_resource(block):
+                ui_blocks.append(block)
+            else:
+                other_blocks.append(block)
+
+        return ui_blocks, other_blocks
+
+    def _is_ui_embedded_resource(self, block: ContentBlock) -> bool:
+        """Check if a content block is a UI embedded resource."""
+        try:
+            if isinstance(block, EmbeddedResource):
+                res = block.resource
+                uri = res.uri if res else None
+                if uri is not None:
+                    return str(uri).startswith("ui://")
+        except Exception:
+            pass
+        return False

fast_agent/mcp_server_registry.py

@@ -0,0 +1,90 @@
+"""
+This module defines a `ServerRegistry` class for managing MCP server configurations
+and initialization logic.
+
+The class loads server configurations from a YAML file,
+supports dynamic registration of initialization hooks, and provides methods for
+server initialization.
+"""
+
+from typing import Dict
+
+from fast_agent.config import (
+    MCPServerSettings,
+    Settings,
+    get_settings,
+)
+from fast_agent.core.logging.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ServerRegistry:
+    """
+    Maps MCP Server configurations to names; can be populated from a YAML file (other formats soon)
+
+    Attributes:
+        config_path (str): Path to the YAML configuration file.
+        registry (Dict[str, MCPServerSettings]): Loaded server configurations.
+    """
+
+    registry: Dict[str, MCPServerSettings] = {}
+
+    def __init__(
+        self,
+        config: Settings | None = None,
+    ) -> None:
+        """
+        Initialize the ServerRegistry with a configuration file.
+
+        Args:
+            config (Settings): The Settings object containing the server configurations.
+            config_path (str): Path to the YAML configuration file.
+        """
+        if config is not None and config.mcp is not None:
+            self.registry = config.mcp.servers or {}
+
+    ## TODO-- leaving this here to support more file formats to add servers
+    def load_registry_from_file(
+        self, config_path: str | None = None
+    ) -> Dict[str, MCPServerSettings]:
+        """
+        Load the YAML configuration file and validate it.
+
+        Returns:
+            Dict[str, MCPServerSettings]: A dictionary of server configurations.
+
+        Raises:
+            ValueError: If the configuration is invalid.
+        """
+        servers = {}
+
+        settings = get_settings(config_path)
+
+        if (
+            settings.mcp is not None
+            and hasattr(settings.mcp, "servers")
+            and settings.mcp.servers is not None
+        ):
+            return settings.mcp.servers
+
+        return servers
+
+    def get_server_config(self, server_name: str) -> MCPServerSettings | None:
+        """
+        Get the configuration for a specific server.
+
+        Args:
+            server_name (str): The name of the server.
+
+        Returns:
+            MCPServerSettings: The server configuration.
+        """
+
+        server_config = self.registry.get(server_name)
+        if server_config is None:
+            logger.warning(f"Server '{server_name}' not found in registry.")
+            return None
+        elif server_config.name is None:
+            server_config.name = server_name
+        return server_config

{mcp_agent → fast_agent}/resources/examples/data-analysis/analysis-campaign.py

@@ -1,7 +1,7 @@
 import asyncio
 
-from mcp_agent.core.fastagent import FastAgent
-from mcp_agent.llm.augmented_llm import RequestParams
+from fast_agent.core.fastagent import FastAgent
+from fast_agent.llm.fastagent_llm import RequestParams
 
 # Create the application
 fast = FastAgent("Data Analysis & Campaign Generator")
@@ -179,8 +179,9 @@ async def main() -> None:
     )
 
     async with fast.run() as agent:
-        await agent.research_campaign_creator.prompt(
-            default_prompt="Analyze the CSV file in the current directory and create a comprehensive multi-lingual social media campaign based on the findings. Save all campaign elements as separate files."
+        await agent.interactive(
+            "research_campaign_creator",
+            default_prompt="Analyze the CSV file in the current directory and create a comprehensive multi-lingual social media campaign based on the findings. Save all campaign elements as separate files.",
         )
 
 

{mcp_agent → fast_agent}/resources/examples/data-analysis/analysis.py

@@ -1,6 +1,6 @@
 import asyncio
 
-from mcp_agent.core.fastagent import FastAgent
+from fast_agent.core.fastagent import FastAgent
 
 # Create the application
 fast = FastAgent("Data Analysis (Roots)")