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

mcp_agent/core/mcp_content.py

@@ -0,0 +1,222 @@
+"""
+Helper functions for creating MCP content types with minimal code.
+
+This module provides simple functions to create TextContent, ImageContent,
+EmbeddedResource, and other MCP content types with minimal boilerplate.
+"""
+
+import base64
+from pathlib import Path
+from typing import Literal, Optional, Union, List, Any
+
+from mcp.types import (
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    TextResourceContents,
+    BlobResourceContents,
+)
+
+from mcp_agent.mcp.mime_utils import (
+    guess_mime_type,
+    is_binary_content,
+    is_image_mime_type,
+)
+
+
+def MCPText(
+    text: str,
+    role: Literal["user", "assistant"] = "user",
+    annotations: Optional[dict] = None,
+) -> dict:
+    """
+    Create a message with text content.
+
+    Args:
+        text: The text content
+        role: Role of the message, defaults to "user"
+        annotations: Optional annotations
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    return {
+        "role": role,
+        "content": TextContent(type="text", text=text, annotations=annotations),
+    }
+
+
+def MCPImage(
+    path: Union[str, Path] = None,
+    data: bytes = None,
+    mime_type: Optional[str] = None,
+    role: Literal["user", "assistant"] = "user",
+    annotations: Optional[dict] = None,
+) -> dict:
+    """
+    Create a message with image content.
+
+    Args:
+        path: Path to the image file
+        data: Raw image data bytes (alternative to path)
+        mime_type: Optional mime type, will be guessed from path if not provided
+        role: Role of the message, defaults to "user"
+        annotations: Optional annotations
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    if path is None and data is None:
+        raise ValueError("Either path or data must be provided")
+
+    if path is not None and data is not None:
+        raise ValueError("Only one of path or data can be provided")
+
+    if path is not None:
+        path = Path(path)
+        if not mime_type:
+            mime_type = guess_mime_type(str(path))
+        with open(path, "rb") as f:
+            data = f.read()
+
+    if not mime_type:
+        mime_type = "image/png"  # Default
+
+    b64_data = base64.b64encode(data).decode("ascii")
+
+    return {
+        "role": role,
+        "content": ImageContent(
+            type="image", data=b64_data, mimeType=mime_type, annotations=annotations
+        ),
+    }
+
+
+def MCPFile(
+    path: Union[str, Path],
+    mime_type: Optional[str] = None,
+    role: Literal["user", "assistant"] = "user",
+    annotations: Optional[dict] = None,
+) -> dict:
+    """
+    Create a message with an embedded resource from a file.
+
+    Args:
+        path: Path to the resource file
+        mime_type: Optional mime type, will be guessed from path if not provided
+        role: Role of the message, defaults to "user"
+        annotations: Optional annotations
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    path = Path(path)
+    uri = f"file://{path.absolute()}"
+
+    if not mime_type:
+        mime_type = guess_mime_type(str(path))
+
+    # Determine if this is text or binary content
+    is_binary = is_binary_content(mime_type)
+
+    if is_binary:
+        # Read as binary
+        binary_data = path.read_bytes()
+        b64_data = base64.b64encode(binary_data).decode("ascii")
+
+        resource = BlobResourceContents(uri=uri, blob=b64_data, mimeType=mime_type)
+    else:
+        # Read as text
+        try:
+            text_data = path.read_text(encoding="utf-8")
+            resource = TextResourceContents(uri=uri, text=text_data, mimeType=mime_type)
+        except UnicodeDecodeError:
+            # Fallback to binary if text read fails
+            binary_data = path.read_bytes()
+            b64_data = base64.b64encode(binary_data).decode("ascii")
+            resource = BlobResourceContents(
+                uri=uri, blob=b64_data, mimeType=mime_type or "application/octet-stream"
+            )
+
+    return {
+        "role": role,
+        "content": EmbeddedResource(
+            type="resource", resource=resource, annotations=annotations
+        ),
+    }
+
+
+
+def MCPPrompt(
+    *content_items, role: Literal["user", "assistant"] = "user"
+) -> List[dict]:
+    """
+    Create one or more prompt messages with various content types.
+
+    This function intelligently creates different content types:
+    - Strings become TextContent 
+    - File paths with image mime types become ImageContent
+    - File paths with text mime types or other mime types become EmbeddedResource
+    - Dicts with role and content are passed through unchanged
+    - Raw bytes become ImageContent
+
+    Args:
+        *content_items: Content items of various types
+        role: Role for all items (user or assistant)
+
+    Returns:
+        List of messages that can be used in a prompt
+    """
+    result = []
+
+    for item in content_items:
+        if isinstance(item, dict) and "role" in item and "content" in item:
+            # Already a fully formed message
+            result.append(item)
+        elif isinstance(item, str) and not Path(item).exists():
+            # Simple text content (that's not a file path)
+            result.append(MCPText(item, role=role))
+        elif isinstance(item, Path) or isinstance(item, str):
+            # File path - determine the content type based on mime type
+            path_str = str(item)
+            mime_type = guess_mime_type(path_str)
+            
+            if is_image_mime_type(mime_type):
+                # Image files (except SVG which is handled as text)
+                result.append(MCPImage(path=item, role=role))
+            else:
+                # All other file types (text documents, PDFs, SVGs, etc.)
+                result.append(MCPFile(path=item, role=role))
+        elif isinstance(item, bytes):
+            # Raw binary data, assume image
+            result.append(MCPImage(data=item, role=role))
+        else:
+            # Try to convert to string
+            result.append(MCPText(str(item), role=role))
+
+    return result
+
+
+def User(*content_items) -> List[dict]:
+    """Create user message(s) with various content types."""
+    return MCPPrompt(*content_items, role="user")
+
+
+def Assistant(*content_items) -> List[dict]:
+    """Create assistant message(s) with various content types."""
+    return MCPPrompt(*content_items, role="assistant")
+
+
+def create_message(content: Any, role: Literal["user", "assistant"] = "user") -> dict:
+    """
+    Create a single prompt message from content of various types.
+
+    Args:
+        content: Content of various types (str, Path, bytes, etc.)
+        role: Role of the message
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    messages = MCPPrompt(content, role=role)
+    return messages[0] if messages else {}

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,12 @@ 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
+from mcp.types import EmbeddedResource
 
 # Handle circular imports
 if TYPE_CHECKING:
@@ -34,27 +36,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 +80,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,33 +110,63 @@ 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
         """
         return await self._agent.apply_prompt(prompt_name, arguments)
 
+    # Add the new methods
+    async def get_embedded_resources(
+        self, server_name: str, resource_name: str
+    ) -> List[EmbeddedResource]:
+        """
+        Get a resource from an MCP server and return it as a list of embedded resources ready for use in prompts.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            List of EmbeddedResource objects ready to use in a PromptMessageMultipart
+        """
+        return await self._agent.get_embedded_resources(server_name, resource_name)
+
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessageMultipart],
+        server_name: str,
+        resource_name: str,
+    ) -> str:
+        """
+        Create a prompt with the given content and resource, then send it to the agent.
+
+        Args:
+            prompt_content: Either a string message or an existing PromptMessageMultipart
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent.with_resource(
+            prompt_content, server_name, resource_name
+        )
+
 
 class WorkflowProxy(BaseAgentProxy):
     """Proxy for workflow types that implement generate_str() directly"""
@@ -220,4 +263,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/listeners.py

@@ -177,10 +177,7 @@ class BatchingListener(FilteredListener):
 
         if self._flush_task and not self._flush_task.done():
             self._flush_task.cancel()
-            try:
-                await self._flush_task
-            except asyncio.CancelledError:
-                pass
+            await self._flush_task
             self._flush_task = None
         await self.flush()
 
@@ -193,8 +190,8 @@ class BatchingListener(FilteredListener):
                     )
                 except asyncio.TimeoutError:
                     await self.flush()
-        except asyncio.CancelledError:
-            pass
+        # except asyncio.CancelledError:
+        #     break
         finally:
             await self.flush()  # Final flush
 

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():