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

mcp_agent/app.py

@@ -1,175 +0,0 @@
-import asyncio
-from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Dict, Optional, Type, TypeVar
-
-from mcp_agent.config import Settings
-from mcp_agent.context import Context, cleanup_context, initialize_context
-from mcp_agent.event_progress import ProgressAction
-from mcp_agent.executor.workflow_signal import SignalWaitCallback
-from mcp_agent.human_input.handler import console_input_callback
-from mcp_agent.human_input.types import HumanInputCallback
-from mcp_agent.logging.logger import get_logger
-
-if TYPE_CHECKING:
-    from mcp import ServerSession
-
-R = TypeVar("R")
-
-
-class MCPApp:
-    """
-    Main application class that manages global state and can host workflows.
-
-    Example usage:
-        app = MCPApp()
-
-        @app.workflow
-        class MyWorkflow(Workflow[str]):
-            @app.task
-            async def my_task(self):
-                pass
-
-            async def run(self):
-                await self.my_task()
-
-        async with app.run() as running_app:
-            workflow = MyWorkflow()
-            result = await workflow.execute()
-    """
-
-    def __init__(
-        self,
-        name: str = "mcp_application",
-        settings: Optional[Settings] | str = None,
-        human_input_callback: Optional[HumanInputCallback] = console_input_callback,
-        signal_notification: Optional[SignalWaitCallback] = None,
-        upstream_session: Optional["ServerSession"] = None,
-    ) -> None:
-        """
-        Initialize the application with a name and optional settings.
-        Args:
-            name: Name of the application
-            settings: Application configuration - If unspecified, the settings are loaded from mcp_agent.config.yaml.
-                If this is a string, it is treated as the path to the config file to load.
-            human_input_callback: Callback for handling human input
-            signal_notification: Callback for getting notified on workflow signals/events.
-            upstream_session: Optional upstream session if the MCPApp is running as a server to an MCP client.
-        """
-        self.name = name
-
-        # We use these to initialize the context in initialize()
-        self._config_or_path = settings
-        self._human_input_callback = human_input_callback
-        self._signal_notification = signal_notification
-        self._upstream_session = upstream_session
-
-        self._workflows: Dict[str, Type] = {}  # id to workflow class
-        self._logger = None
-        self._context: Optional[Context] = None
-        self._initialized = False
-
-    @property
-    def context(self) -> Context:
-        if self._context is None:
-            raise RuntimeError(
-                "MCPApp not initialized, please call initialize() first, or use async with app.run()."
-            )
-        return self._context
-
-    @property
-    def config(self):
-        return self._context.config
-
-    @property
-    def server_registry(self):
-        return self._context.server_registry
-
-    @property
-    def executor(self):
-        return self._context.executor
-
-    @property
-    def engine(self):
-        return self.executor.execution_engine
-
-    @property
-    def upstream_session(self):
-        return self._context.upstream_session
-
-    @upstream_session.setter
-    def upstream_session(self, value) -> None:
-        self._context.upstream_session = value
-
-    @property
-    def workflows(self):
-        return self._workflows
-
-    @property
-    def tasks(self):
-        return self.context.task_registry.list_activities()
-
-    @property
-    def logger(self):
-        if self._logger is None:
-            self._logger = get_logger(f"mcp_agent.{self.name}")
-        return self._logger
-
-    async def initialize(self) -> None:
-        """Initialize the application."""
-        if self._initialized:
-            return
-
-        self._context = await initialize_context(self._config_or_path, store_globally=True)
-
-        # Set the properties that were passed in the constructor
-        self._context.human_input_handler = self._human_input_callback
-        self._context.signal_notification = self._signal_notification
-        self._context.upstream_session = self._upstream_session
-
-        self._initialized = True
-        self.logger.info(
-            "MCPAgent initialized",
-            data={
-                "progress_action": "Running",
-                "target": self.name or "mcp_application",
-                "agent_name": self.name or "fastagent loop",
-            },
-        )
-
-    async def cleanup(self) -> None:
-        """Cleanup application resources."""
-        if not self._initialized:
-            return
-
-        # Updatre progress display before logging is shut down
-        self.logger.info(
-            "MCPAgent cleanup",
-            data={
-                "progress_action": ProgressAction.FINISHED,
-                "target": self.name or "mcp_application",
-                "agent_name": self.name or "fastagent loop",
-            },
-        )
-        try:
-            await cleanup_context()
-        except asyncio.CancelledError:
-            self.logger.debug("Cleanup cancelled error during shutdown")
-
-        self._context = None
-        self._initialized = False
-
-    @asynccontextmanager
-    async def run(self):
-        """
-        Run the application. Use as context manager.
-
-        Example:
-            async with app.run() as running_app:
-                # App is initialized here
-                pass
-        """
-        await self.initialize()
-        try:
-            yield self
-        finally:
-            await self.cleanup()

mcp_agent/core/__init__.py

@@ -1,26 +0,0 @@
-"""
-Core components and utilities for MCP Agent.
-"""
-
-from .mcp_content import (
-    Assistant,
-    MCPContentType,
-    MCPFile,
-    MCPImage,
-    MCPPrompt,
-    MCPText,
-    User,
-    create_message,
-)
-
-__all__ = [
-    # MCP content creation functions
-    "MCPText",
-    "MCPImage",
-    "MCPFile",
-    "MCPPrompt",
-    "User",
-    "Assistant",
-    "create_message",
-    "MCPContentType",
-]

mcp_agent/core/prompt.py

@@ -1,191 +0,0 @@
-"""
-Prompt class for easily creating and working with MCP prompt content.
-"""
-
-from pathlib import Path
-from typing import List, Literal, Union
-
-from mcp.types import PromptMessage
-
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-
-# Import our content helper functions
-from .mcp_content import Assistant, MCPContentType, MCPPrompt, User
-
-
-class Prompt:
-    """
-    A helper class for working with MCP prompt content.
-
-    This class provides static methods to create:
-    - PromptMessage instances
-    - PromptMessageMultipart instances
-    - Lists of messages for conversations
-
-    All methods intelligently handle various content types:
-    - Strings become TextContent
-    - Image file paths become ImageContent
-    - Other file paths become EmbeddedResource
-    - TextContent objects are used directly
-    - ImageContent objects are used directly
-    - EmbeddedResource objects are used directly 
-    - Pre-formatted messages pass through unchanged
-    """
-
-    @classmethod
-    def user(cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart]) -> PromptMessageMultipart:
-        """
-        Create a user PromptMessageMultipart with various content items.
-
-        Args:
-            *content_items: Content items in various formats:
-                - Strings: Converted to TextContent
-                - Path objects: Converted based on file type (image/text/binary)
-                - Bytes: Treated as image data
-                - Dicts with role/content: Content extracted
-                - TextContent: Used directly
-                - ImageContent: Used directly
-                - EmbeddedResource: Used directly
-                - PromptMessage: Content extracted
-                - PromptMessageMultipart: Content extracted with role changed to user
-
-        Returns:
-            A PromptMessageMultipart with user role and the specified content
-        """
-        # Handle PromptMessage and PromptMessageMultipart directly
-        if len(content_items) == 1:
-            item = content_items[0]
-            if isinstance(item, PromptMessage):
-                return PromptMessageMultipart(role="user", content=[item.content])
-            elif isinstance(item, PromptMessageMultipart):
-                # Keep the content but change role to user
-                return PromptMessageMultipart(role="user", content=item.content)
-                
-        # Use the original implementation for other types
-        messages = User(*content_items)
-        return PromptMessageMultipart(role="user", content=[msg["content"] for msg in messages])
-
-    @classmethod
-    def assistant(cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart]) -> PromptMessageMultipart:
-        """
-        Create an assistant PromptMessageMultipart with various content items.
-
-        Args:
-            *content_items: Content items in various formats:
-                - Strings: Converted to TextContent
-                - Path objects: Converted based on file type (image/text/binary)
-                - Bytes: Treated as image data
-                - Dicts with role/content: Content extracted
-                - TextContent: Used directly
-                - ImageContent: Used directly
-                - EmbeddedResource: Used directly
-                - PromptMessage: Content extracted
-                - PromptMessageMultipart: Content extracted with role changed to assistant
-
-        Returns:
-            A PromptMessageMultipart with assistant role and the specified content
-        """
-        # Handle PromptMessage and PromptMessageMultipart directly
-        if len(content_items) == 1:
-            item = content_items[0]
-            if isinstance(item, PromptMessage):
-                return PromptMessageMultipart(role="assistant", content=[item.content])
-            elif isinstance(item, PromptMessageMultipart):
-                # Keep the content but change role to assistant
-                return PromptMessageMultipart(role="assistant", content=item.content)
-                
-        # Use the original implementation for other types
-        messages = Assistant(*content_items)
-        return PromptMessageMultipart(
-            role="assistant", content=[msg["content"] for msg in messages]
-        )
-
-    @classmethod
-    def message(
-        cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart], 
-        role: Literal["user", "assistant"] = "user"
-    ) -> PromptMessageMultipart:
-        """
-        Create a PromptMessageMultipart with the specified role and content items.
-
-        Args:
-            *content_items: Content items in various formats:
-                - Strings: Converted to TextContent
-                - Path objects: Converted based on file type (image/text/binary)
-                - Bytes: Treated as image data
-                - Dicts with role/content: Content extracted
-                - TextContent: Used directly
-                - ImageContent: Used directly
-                - EmbeddedResource: Used directly
-                - PromptMessage: Content extracted
-                - PromptMessageMultipart: Content extracted with role changed as specified
-            role: Role for the message (user or assistant)
-
-        Returns:
-            A PromptMessageMultipart with the specified role and content
-        """
-        # Handle PromptMessage and PromptMessageMultipart directly
-        if len(content_items) == 1:
-            item = content_items[0]
-            if isinstance(item, PromptMessage):
-                return PromptMessageMultipart(role=role, content=[item.content])
-            elif isinstance(item, PromptMessageMultipart):
-                # Keep the content but change role as specified
-                return PromptMessageMultipart(role=role, content=item.content)
-                
-        # Use the original implementation for other types
-        messages = MCPPrompt(*content_items, role=role)
-        return PromptMessageMultipart(
-            role=messages[0]["role"] if messages else role,
-            content=[msg["content"] for msg in messages],
-        )
-
-    @classmethod
-    def conversation(cls, *messages) -> List[PromptMessage]:
-        """
-        Create a list of PromptMessages from various inputs.
-
-        This method accepts:
-        - PromptMessageMultipart instances
-        - Dictionaries with role and content
-        - Lists of dictionaries with role and content
-
-        Args:
-            *messages: Messages to include in the conversation
-
-        Returns:
-            A list of PromptMessage objects for the conversation
-        """
-        result = []
-
-        for item in messages:
-            if isinstance(item, PromptMessageMultipart):
-                # Convert PromptMessageMultipart to a list of PromptMessages
-                result.extend(item.from_multipart())
-            elif isinstance(item, dict) and "role" in item and "content" in item:
-                # Convert a single message dict to PromptMessage
-                result.append(PromptMessage(**item))
-            elif isinstance(item, list):
-                # Process each item in the list
-                for msg in item:
-                    if isinstance(msg, dict) and "role" in msg and "content" in msg:
-                        result.append(PromptMessage(**msg))
-            # Ignore other types
-
-        return result
-
-    @classmethod
-    def from_multipart(cls, multipart: List[PromptMessageMultipart]) -> List[PromptMessage]:
-        """
-        Convert a list of PromptMessageMultipart objects to PromptMessages.
-
-        Args:
-            multipart: List of PromptMessageMultipart objects
-
-        Returns:
-            A flat list of PromptMessage objects
-        """
-        result = []
-        for mp in multipart:
-            result.extend(mp.from_multipart())
-        return result

mcp_agent/event_progress.py

@@ -1,134 +0,0 @@
-"""Module for converting log events to progress events."""
-
-from enum import Enum
-from typing import Optional
-
-from pydantic import BaseModel
-
-from mcp_agent.logging.events import Event
-
-
-class ProgressAction(str, Enum):
-    """Progress actions available in the system."""
-
-    STARTING = "Starting"
-    LOADED = "Loaded"
-    INITIALIZED = "Initialized"
-    CHATTING = "Chatting"
-    STREAMING = "Streaming"  # Special action for real-time streaming updates
-    ROUTING = "Routing"
-    PLANNING = "Planning"
-    READY = "Ready"
-    CALLING_TOOL = "Calling Tool"
-    TOOL_PROGRESS = "Tool Progress"
-    UPDATED = "Updated"
-    FINISHED = "Finished"
-    SHUTDOWN = "Shutdown"
-    AGGREGATOR_INITIALIZED = "Running"
-    SERVER_OFFLINE = "Offline"
-    SERVER_RECONNECTING = "Reconnecting"
-    SERVER_ONLINE = "Online"
-    FATAL_ERROR = "Error"
-
-
-class ProgressEvent(BaseModel):
-    """Represents a progress event converted from a log event."""
-
-    action: ProgressAction
-    target: str
-    details: Optional[str] = None
-    agent_name: Optional[str] = None
-    streaming_tokens: Optional[str] = None  # Special field for streaming token count
-    progress: Optional[float] = None  # Current progress value
-    total: Optional[float] = None  # Total value for progress calculation
-
-    def __str__(self) -> str:
-        """Format the progress event for display."""
-        # 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
-
-
-def convert_log_event(event: Event) -> Optional[ProgressEvent]:
-    """Convert a log event to a progress event if applicable."""
-
-    # Check to see if there is any additional data
-    if not event.data:
-        return None
-
-    event_data = event.data.get("data")
-    if not isinstance(event_data, dict):
-        return None
-
-    progress_action = event_data.get("progress_action")
-    if not progress_action:
-        return None
-
-    # Build target string based on the event type.
-    # Progress display is currently [time] [event] --- [target] [details]
-    namespace = event.namespace
-    agent_name = event_data.get("agent_name")
-    target = agent_name
-    details = ""
-    if progress_action == ProgressAction.FATAL_ERROR:
-        details = event_data.get("error_message", "An error occurred")
-    elif "mcp_aggregator" in namespace:
-        server_name = event_data.get("server_name", "")
-        tool_name = event_data.get("tool_name")
-        if tool_name:
-            # fetch(fetch)
-            details = f"{server_name} ({tool_name})"
-        else:
-            details = f"{server_name}"
-        
-        # For TOOL_PROGRESS, use progress message if available, otherwise keep default
-        if progress_action == ProgressAction.TOOL_PROGRESS:
-            progress_message = event_data.get("details", "")
-            if progress_message:  # Only override if message is non-empty
-                details = progress_message
-
-    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:
-            details = f"{model} turn {chat_turn}"
-    else:
-        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", "")
-    
-    # Extract progress data for TOOL_PROGRESS actions
-    progress = None
-    total = None
-    if progress_action == ProgressAction.TOOL_PROGRESS:
-        progress = event_data.get("progress")
-        total = event_data.get("total")
-    
-    return ProgressEvent(
-        action=ProgressAction(progress_action),
-        target=target or "unknown",
-        details=details,
-        agent_name=event_data.get("agent_name"),
-        streaming_tokens=streaming_tokens,
-        progress=progress,
-        total=total,
-    )

mcp_agent/human_input/handler.py

@@ -1,81 +0,0 @@
-import asyncio
-
-from rich.panel import Panel
-
-from mcp_agent.console import console
-from mcp_agent.core.enhanced_prompt import get_enhanced_input, handle_special_commands
-from mcp_agent.human_input.types import (
-    HumanInputRequest,
-    HumanInputResponse,
-)
-from mcp_agent.progress_display import progress_display
-
-
-async def console_input_callback(request: HumanInputRequest) -> HumanInputResponse:
-    """Request input from a human user via console using prompt_toolkit."""
-
-    # Prepare the prompt text
-    prompt_text = request.prompt
-    if request.description:
-        prompt_text = f"[bold]{request.description}[/bold]\n\n{request.prompt}"
-
-    # Create a panel with the prompt
-    panel = Panel(
-        prompt_text,
-        title="[HUMAN INPUT REQUESTED]",
-        title_align="left",
-        style="green",
-        border_style="bold white",
-        padding=(1, 2),
-    )
-
-    # Extract agent name from metadata dictionary
-    agent_name = (
-        request.metadata.get("agent_name", "Unknown Agent") if request.metadata else "Unknown Agent"
-    )
-
-    # Use the context manager to pause the progress display while getting input
-    with progress_display.paused():
-        console.print(panel)
-
-        try:
-            if request.timeout_seconds:
-                try:
-                    # Use get_enhanced_input with empty agent list to disable agent switching
-                    response = await asyncio.wait_for(
-                        get_enhanced_input(
-                            agent_name=agent_name,
-                            available_agent_names=[],  # No agents for selection
-                            show_stop_hint=False,
-                            is_human_input=True,
-                            toolbar_color="ansimagenta",
-                        ),
-                        request.timeout_seconds,
-                    )
-                except asyncio.TimeoutError:
-                    console.print("\n[red]Timeout waiting for input[/red]")
-                    raise TimeoutError("No response received within timeout period")
-            else:
-                response = await get_enhanced_input(
-                    agent_name=agent_name,
-                    available_agent_names=[],  # No agents for selection
-                    show_stop_hint=False,
-                    is_human_input=True,
-                    toolbar_color="ansimagenta",
-                )
-
-            # Handle special commands but ignore dictionary results as they require app context
-            command_result = await handle_special_commands(response)
-            if isinstance(command_result, dict) and "list_prompts" in command_result:
-                from rich import print as rich_print
-
-                rich_print("[yellow]Prompt listing not available in human input context[/yellow]")
-
-        except KeyboardInterrupt:
-            console.print("\n[yellow]Input interrupted[/yellow]")
-            response = ""
-        except EOFError:
-            console.print("\n[yellow]Input terminated[/yellow]")
-            response = ""
-
-    return HumanInputResponse(request_id=request.request_id, response=response.strip())

mcp_agent/llm/__init__.py

@@ -1,2 +0,0 @@
-# LLM module
-# Contains code for working with large language models