fast-agent-mcp 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

mcp_agent/core/prompt.py

@@ -0,0 +1,132 @@
+"""
+Prompt class for easily creating and working with MCP prompt content.
+"""
+
+from typing import List, Literal
+
+from mcp.types import PromptMessage
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+# Import our content helper functions
+from .mcp_content import User, Assistant, MCPPrompt
+
+
+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
+    - Pre-formatted messages pass through unchanged
+    """
+
+    @classmethod
+    def user(cls, *content_items) -> PromptMessageMultipart:
+        """
+        Create a user PromptMessageMultipart with various content items.
+
+        Args:
+            *content_items: Content items (strings, file paths, etc.)
+
+        Returns:
+            A PromptMessageMultipart with user role and the specified content
+        """
+        messages = User(*content_items)
+        return PromptMessageMultipart(
+            role="user", content=[msg["content"] for msg in messages]
+        )
+
+    @classmethod
+    def assistant(cls, *content_items) -> PromptMessageMultipart:
+        """
+        Create an assistant PromptMessageMultipart with various content items.
+
+        Args:
+            *content_items: Content items (strings, file paths, etc.)
+
+        Returns:
+            A PromptMessageMultipart with assistant role and the specified content
+        """
+        messages = Assistant(*content_items)
+        return PromptMessageMultipart(
+            role="assistant", content=[msg["content"] for msg in messages]
+        )
+
+    @classmethod
+    def message(
+        cls, *content_items, role: Literal["user", "assistant"] = "user"
+    ) -> PromptMessageMultipart:
+        """
+        Create a PromptMessageMultipart with the specified role and content items.
+
+        Args:
+            *content_items: Content items (strings, file paths, etc.)
+            role: Role for the message (user or assistant)
+
+        Returns:
+            A PromptMessageMultipart with the specified role and content
+        """
+        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.to_prompt_messages())
+            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.to_prompt_messages())
+        return result

mcp_agent/core/proxies.py

@@ -3,10 +3,11 @@ Proxy classes for agent interactions.
 These proxies provide a consistent interface for interacting with different types of agents.
 """
 
-from typing import List, Optional, Dict, TYPE_CHECKING
+from typing import List, Optional, Dict, Union, TYPE_CHECKING
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.app import MCPApp
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 # Handle circular imports
 if TYPE_CHECKING:
@@ -34,27 +35,43 @@ class BaseAgentProxy:
             return await self.prompt()
         return await self.send(message)
 
-    async def send(self, message: Optional[str] = None) -> str:
-        """Allow: agent.researcher.send('message')"""
+    async def send(
+        self, message: Optional[Union[str, PromptMessageMultipart]] = None
+    ) -> str:
+        """
+        Allow: agent.researcher.send('message') or agent.researcher.send(Prompt.user('message'))
+
+        Args:
+            message: Either a string message or a PromptMessageMultipart object
+
+        Returns:
+            The agent's response as a string
+        """
         if message is None:
             # For consistency with agent(), use prompt() to open the interactive interface
             return await self.prompt()
+
+        # If a PromptMessageMultipart is passed, use send_prompt
+        if isinstance(message, PromptMessageMultipart):
+            return await self.send_prompt(message)
+
+        # For string messages, use generate_str (traditional behavior)
         return await self.generate_str(message)
 
     async def prompt(self, default_prompt: str = "") -> str:
         """Allow: agent.researcher.prompt()"""
         from mcp_agent.core.agent_app import AgentApp
-        
+
         # First check if _app is directly an AgentApp
         if isinstance(self._app, AgentApp):
             return await self._app.prompt(self._name, default_prompt)
-            
+
         # If not, check if it's an MCPApp with an _agent_app attribute
         if hasattr(self._app, "_agent_app"):
             agent_app = self._app._agent_app
             if agent_app:
                 return await agent_app.prompt(self._name, default_prompt)
-        
+
         # If we can't find an AgentApp, return an error message
         return "ERROR: Cannot prompt() - AgentApp not found"
 
@@ -62,23 +79,18 @@ class BaseAgentProxy:
         """Generate response for a message - must be implemented by subclasses"""
         raise NotImplementedError("Subclasses must implement generate_str")
 
-    async def load_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
-        """
-        Use a Prompt from an MCP Server - implemented by subclasses.
-        Always returns an Assistant message.
-        
-        Args:
-            prompt_name: Name of the prompt to load
-            arguments: Optional dictionary of string arguments for prompt templating
-        """
-        raise NotImplementedError("Subclasses must implement mcp-prompt")
-        
-    async def apply_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
+    async def send_prompt(self, prompt: PromptMessageMultipart) -> str:
+        """Send a message to the agent and return the response"""
+        raise NotImplementedError("Subclasses must implement send(prompt)")
+
+    async def apply_prompt(
+        self, prompt_name: str = None, arguments: dict[str, str] = None
+    ) -> str:
         """
         Apply a Prompt from an MCP Server - implemented by subclasses.
         This is the preferred method for applying prompts.
         Always returns an Assistant message.
-        
+
         Args:
             prompt_name: Name of the prompt to apply
             arguments: Optional dictionary of string arguments for prompt templating
@@ -97,28 +109,21 @@ class LLMAgentProxy(BaseAgentProxy):
         """Forward message and all kwargs to the agent's LLM"""
         return await self._agent._llm.generate_str(message, **kwargs)
 
-    async def load_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
-        """
-        Load and apply a prompt from an MCP server.
-        
-        Args:
-            prompt_name: Name of the prompt to load
-            arguments: Optional dictionary of string arguments for prompt templating
-            
-        Returns:
-            The assistant's response
-        """
-        return await self._agent.load_prompt(prompt_name, arguments)
-        
-    async def apply_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
+    async def send_prompt(self, prompt: PromptMessageMultipart) -> str:
+        """Send a message to the agent and return the response"""
+        return await self._agent._llm.generate_prompt(prompt, None)
+
+    async def apply_prompt(
+        self, prompt_name: str = None, arguments: dict[str, str] = None
+    ) -> str:
         """
         Apply a prompt from an MCP server.
         This is the preferred method for applying prompts.
-        
+
         Args:
             prompt_name: Name of the prompt to apply
             arguments: Optional dictionary of string arguments for prompt templating
-            
+
         Returns:
             The assistant's response
         """
@@ -220,4 +225,4 @@ class ChainProxy(BaseAgentProxy):
                 proxy = self._agent_proxies[agent_name]
                 current_message = await proxy.generate_str(current_message)
 
-            return current_message
+            return current_message

mcp_agent/logging/transport.py

@@ -290,6 +290,21 @@ class AsyncEventBus:
             # Update transport if provided
             cls._instance.transport = transport
         return cls._instance
+        
+    @classmethod
+    def reset(cls) -> None:
+        """
+        Reset the singleton instance.
+        This is primarily useful for testing scenarios where you need to ensure
+        a clean state between tests.
+        """
+        if cls._instance:
+            # Signal shutdown
+            cls._instance._running = False
+            cls._instance._stop_event.set()
+            
+            # Clear the singleton instance
+            cls._instance = None
 
     async def start(self):
         """Start the event bus and all lifecycle-aware listeners."""
@@ -383,11 +398,19 @@ class AsyncEventBus:
     async def _process_events(self):
         """Process events from the queue until stopped."""
         while self._running:
+            event = None
             try:
                 # Use wait_for with a timeout to allow checking running state
                 try:
+                    # Check if we should be stopping first
+                    if not self._running or self._stop_event.is_set():
+                        break
+
                     event = await asyncio.wait_for(self._queue.get(), timeout=0.1)
                 except asyncio.TimeoutError:
+                    # Check again before continuing
+                    if not self._running or self._stop_event.is_set():
+                        break
                     continue
 
                 # Process the event through all listeners
@@ -407,13 +430,17 @@ class AsyncEventBus:
                                 f"Stacktrace: {''.join(traceback.format_exception(type(r), r, r.__traceback__))}"
                             )
 
-                self._queue.task_done()
-
             except asyncio.CancelledError:
+                # If we have a current event, mark it done before breaking
+                if event is not None:
+                    self._queue.task_done()
                 break
             except Exception as e:
                 print(f"Error in event processing loop: {e}")
-                continue
+            finally:
+                # Always mark the task as done if we got an event
+                if event is not None:
+                    self._queue.task_done()
 
         # Process remaining events in queue
         while not self._queue.empty():

mcp_agent/mcp/mcp_aggregator.py

@@ -370,20 +370,11 @@ class MCPAggregator(ContextDependent):
         Returns:
             Result from the operation or an error result
         """
-        logger.info(
-            f"Requesting {operation_type}",
-            data={
-                "progress_action": ProgressAction.STARTING,
-                f"{operation_type}_name": operation_name,
-                "server_name": server_name,
-                "agent_name": self.agent_name,
-            },
-        )
 
         async def try_execute(client: ClientSession):
             try:
                 method = getattr(client, method_name)
-                return await method(**method_args) if method_args else await method()
+                return await method(**method_args)
             except Exception as e:
                 error_msg = f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
                 logger.error(error_msg)
@@ -469,6 +460,16 @@ class MCPAggregator(ContextDependent):
             logger.error(f"Error: Tool '{name}' not found")
             return CallToolResult(isError=True, message=f"Tool '{name}' not found")
 
+        logger.info(
+            "Requesting tool call",
+            data={
+                "progress_action": ProgressAction.CALLING_TOOL,
+                "tool_name": local_tool_name,
+                "server_name": server_name,
+                "agent_name": self.agent_name,
+            },
+        )
+
         return await self._execute_on_server(
             server_name=server_name,
             operation_type="tool",

mcp_agent/mcp/mime_utils.py

@@ -0,0 +1,69 @@
+# mime_utils.py
+
+import mimetypes
+
+# Initialize mimetypes database
+mimetypes.init()
+
+# Extend with additional types that might be missing
+mimetypes.add_type("text/x-python", ".py")
+mimetypes.add_type("image/webp", ".webp")
+
+# Known text-based MIME types not starting with "text/"
+TEXT_MIME_TYPES = {
+    "application/json",
+    "application/javascript",
+    "application/xml",
+    "application/ld+json",
+    "application/xhtml+xml",
+    "application/x-httpd-php",
+    "application/x-sh",
+    "application/ecmascript",
+    "application/graphql",
+    "application/x-www-form-urlencoded",
+    "application/yaml",
+    "application/toml",
+    "application/x-python-code",
+    "application/vnd.api+json",
+}
+
+# Common text-based MIME type patterns
+TEXT_MIME_PATTERNS = ("+xml", "+json", "+yaml", "+text")
+
+
+def guess_mime_type(file_path: str) -> str:
+    """
+    Guess the MIME type of a file based on its extension.
+    """
+    mime_type, _ = mimetypes.guess_type(file_path)
+    return mime_type or "application/octet-stream"
+
+
+def is_text_mime_type(mime_type: str) -> bool:
+    """Determine if a MIME type represents text content."""
+    if not mime_type:
+        return False
+
+    # Standard text types
+    if mime_type.startswith("text/"):
+        return True
+
+    # Known text types
+    if mime_type in TEXT_MIME_TYPES:
+        return True
+
+    # Common text patterns
+    if any(mime_type.endswith(pattern) for pattern in TEXT_MIME_PATTERNS):
+        return True
+
+    return False
+
+
+def is_binary_content(mime_type: str) -> bool:
+    """Check if content should be treated as binary."""
+    return not is_text_mime_type(mime_type)
+
+
+def is_image_mime_type(mime_type: str) -> bool:
+    """Check if a MIME type represents an image."""
+    return mime_type.startswith("image/") and mime_type != "image/svg+xml"

mcp_agent/mcp/prompt_message_multipart.py

@@ -0,0 +1,64 @@
+from typing import List, Union
+from pydantic import BaseModel
+
+from mcp.types import (
+    PromptMessage,
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    Role,
+    GetPromptResult,
+)
+
+
+class PromptMessageMultipart(BaseModel):
+    """
+    Extension of PromptMessage that handles multiple content parts.
+    Internally converts to/from a sequence of standard PromptMessages.
+    """
+
+    role: Role
+    content: List[Union[TextContent, ImageContent, EmbeddedResource]]
+
+    @classmethod
+    def from_prompt_messages(
+        cls, messages: List[PromptMessage]
+    ) -> List["PromptMessageMultipart"]:
+        """Convert a sequence of PromptMessages into PromptMessageMultipart objects."""
+        if not messages:
+            return []
+
+        result = []
+        current_group = None
+        current_role = None
+
+        for msg in messages:
+            if msg.role != current_role:
+                # Role changed, start new message
+                if current_group is not None:
+                    result.append(current_group)
+                current_role = msg.role
+                current_group = cls(role=msg.role, content=[msg.content])
+            else:
+                # Same role, add to current message
+                current_group.content.append(msg.content)
+
+        # Add the last group
+        if current_group is not None:
+            result.append(current_group)
+
+        return result
+
+    def to_prompt_messages(self) -> List[PromptMessage]:
+        """Convert this PromptMessageMultipart to a sequence of standard PromptMessages."""
+        return [
+            PromptMessage(role=self.role, content=content_part)
+            for content_part in self.content
+        ]
+
+    @classmethod
+    def parse_get_prompt_result(
+        cls, result: GetPromptResult
+    ) -> List["PromptMessageMultipart"]:
+        """Parse a GetPromptResult into PromptMessageMultipart objects."""
+        return cls.from_prompt_messages(result.messages)