fast-agent-mcp 0.1.8__tar.gz → 0.1.9__tar.gz

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.8
+Version: 0.1.9
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -212,7 +212,7 @@ Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.49.0
 Requires-Dist: fastapi>=0.115.6
-Requires-Dist: mcp==1.2.1
+Requires-Dist: mcp>=1.4.1
 Requires-Dist: numpy>=2.2.1
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
@@ -259,6 +259,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+
 ### Agent Application Development
 
 Prompts and configurations that define your Agent Applications are stored in simple files, with minimal boilerplate, enabling simple management and version control.
@@ -588,6 +592,19 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
 )
 ```
 
+### Multimodal Support
+
+Add Resources to prompts using either the inbuilt `prompt-server` or MCP Types directly. Convenience class are made available to do so simply, for example:
+
+#### MCP Tool Result Conversion
+
+LLM APIs have restrictions on the content types that can be returned as Tool Calls/Function results via their Chat Completions API's:
+
+- OpenAI supports Text
+- Anthropic supports Text and Image
+
+For MCP Tool Results, `ImageResources` and `EmbeddedResources` are converted to User Messages and added to the conversation.
+
 ### Prompts
 
 MCP Prompts are supported with `apply_prompt(name,arguments)`, which always returns an Assistant Message. If the last message from the MCP Server is a 'User' message, it is sent to the LLM for processing. Prompts applied to the Agent's Context are retained - meaning that with `use_history=False`, Agents can act as finely tuned responders.
@@ -605,8 +622,9 @@ Prompts can also be applied interactively through the interactive interface by u
 
 ### llmindset.co.uk fork:
 
+- Addition of MCP Prompts including Prompt Server and agent save/replay ability.
 - Overhaul of Eval/Opt for Conversation Management
-- Remove instructor use for Orchestrator
+- Removed instructor/double-llm calling - native structured outputs for OAI.
 - Improved handling of Parallel/Fan-In and respose option
 - XML based generated prompts
 - "FastAgent" style prototyping, with per-agent models
@@ -625,4 +643,8 @@ Prompts can also be applied interactively through the interactive interface by u
 - Declarative workflows
 - Numerous defect fixes
 
-### Features to add.
+### Features to add (Commmitted)
+
+- Run Agent as MCP Server, with interop
+- Multi-part content types supporing Vision, PDF and multi-part Text.
+- Improved test automation (supported by prompt_server.py and augmented_llm_playback.py)

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.9}/README.md

@@ -16,6 +16,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+
 ### Agent Application Development
 
 Prompts and configurations that define your Agent Applications are stored in simple files, with minimal boilerplate, enabling simple management and version control.
@@ -345,6 +349,19 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
 )
 ```
 
+### Multimodal Support
+
+Add Resources to prompts using either the inbuilt `prompt-server` or MCP Types directly. Convenience class are made available to do so simply, for example:
+
+#### MCP Tool Result Conversion
+
+LLM APIs have restrictions on the content types that can be returned as Tool Calls/Function results via their Chat Completions API's:
+
+- OpenAI supports Text
+- Anthropic supports Text and Image
+
+For MCP Tool Results, `ImageResources` and `EmbeddedResources` are converted to User Messages and added to the conversation.
+
 ### Prompts
 
 MCP Prompts are supported with `apply_prompt(name,arguments)`, which always returns an Assistant Message. If the last message from the MCP Server is a 'User' message, it is sent to the LLM for processing. Prompts applied to the Agent's Context are retained - meaning that with `use_history=False`, Agents can act as finely tuned responders.
@@ -362,8 +379,9 @@ Prompts can also be applied interactively through the interactive interface by u
 
 ### llmindset.co.uk fork:
 
+- Addition of MCP Prompts including Prompt Server and agent save/replay ability.
 - Overhaul of Eval/Opt for Conversation Management
-- Remove instructor use for Orchestrator
+- Removed instructor/double-llm calling - native structured outputs for OAI.
 - Improved handling of Parallel/Fan-In and respose option
 - XML based generated prompts
 - "FastAgent" style prototyping, with per-agent models
@@ -382,4 +400,8 @@ Prompts can also be applied interactively through the interactive interface by u
 - Declarative workflows
 - Numerous defect fixes
 
-### Features to add.
+### Features to add (Commmitted)
+
+- Run Agent as MCP Server, with interop
+- Multi-part content types supporing Vision, PDF and multi-part Text.
+- Improved test automation (supported by prompt_server.py and augmented_llm_playback.py)

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.1.8"
+version = "0.1.9"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -16,7 +16,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.2.1",
+    "mcp>=1.4.1",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -72,9 +72,20 @@ include = [
     "src/mcp_agent/resources/**/*.csv",
 ]
 
+[tool.pytest.ini_options]
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"
+markers = [
+    "e2e: tests that connect to external resources (llms)",
+    "integration: marks tests as integration tests",
+    "simulated_endpoints: marks tests that use simulated external endpoints"
+]
+# Other pytest options can go here too
+testpaths = ["test", "integration_tests"]
+
 [dependency-groups]
 dev = [
-    "anthropic>=0.42.0",
+    "anthropic>=0.49.0",
     "pre-commit>=4.0.1",
     "pydantic>=2.10.4",
     "pyyaml>=6.0.2",
@@ -89,6 +100,7 @@ fast-agent = "mcp_agent.cli.__main__:app"
 fast_agent = "mcp_agent.cli.__main__:app"
 fastagent = "mcp_agent.cli.__main__:app"
 silsila = "mcp_agent.cli.__main__:app"
+prompt-server = "mcp_agent.mcp.prompts.__main__:main"
 
 [tool.setuptools.package-data]
 mcp_agent = [

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.9}/src/mcp_agent/agents/agent.py

@@ -320,18 +320,20 @@ class Agent(MCPAggregator):
                 ],
             )
 
-    async def apply_prompt(self, prompt_name: str, arguments: dict[str, str] = None) -> str:
+    async def apply_prompt(
+        self, prompt_name: str, arguments: dict[str, str] = None
+    ) -> str:
         """
         Apply an MCP Server Prompt by name and return the assistant's response.
         Will search all available servers for the prompt if not namespaced.
-        
+
         If the last message in the prompt is from a user, this will automatically
         generate an assistant response to ensure we always end with an assistant message.
 
         Args:
             prompt_name: The name of the prompt to apply
             arguments: Optional dictionary of string arguments to pass to the prompt template
-            
+
         Returns:
             The assistant's response or error message
         """
@@ -357,11 +359,3 @@ class Agent(MCPAggregator):
         # The LLM will automatically generate a response if needed
         result = await self._llm.apply_prompt_template(prompt_result, display_name)
         return result
-
-    # For backward compatibility
-    async def load_prompt(self, prompt_name: str, arguments: dict[str, str] = None) -> str:
-        """
-        Legacy method - use apply_prompt instead.
-        This is maintained for backward compatibility.
-        """
-        return await self.apply_prompt(prompt_name, arguments)

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.9}/src/mcp_agent/core/agent_app.py

@@ -2,9 +2,10 @@
 Main application wrapper for interacting with agents.
 """
 
-from typing import Optional, Dict, TYPE_CHECKING
+from typing import Optional, Dict, Union, TYPE_CHECKING
 
 from mcp_agent.app import MCPApp
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
 from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
 from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
@@ -37,16 +38,80 @@ class AgentApp:
         # Optional: set default agent for direct calls
         self._default = next(iter(agents)) if agents else None
 
-    async def send(self, agent_name: str, message: Optional[str]) -> str:
-        """Core message sending"""
-        if agent_name not in self._agents:
-            raise ValueError(f"No agent named '{agent_name}'")
+    async def send_prompt(
+        self, prompt: PromptMessageMultipart, agent_name: Optional[str] = None
+    ) -> str:
+        """
+        Send a PromptMessageMultipart to an agent
+
+        Args:
+            prompt: The PromptMessageMultipart to send
+            agent_name: The name of the agent to send to (uses default if None)
+
+        Returns:
+            The agent's response as a string
+        """
+        target = agent_name or self._default
+        if not target:
+            raise ValueError("No default agent available")
+
+        if target not in self._agents:
+            raise ValueError(f"No agent named '{target}'")
+
+        proxy = self._agents[target]
+        return await proxy.send_prompt(prompt)
+
+    async def send(
+        self,
+        message: Union[str, PromptMessageMultipart] = None,
+        agent_name: Optional[str] = None,
+    ) -> str:
+        """
+        Send a message to the default agent or specified agent
+
+        Args:
+            message: Either a string message or a PromptMessageMultipart object
+            agent_name: The name of the agent to send to (uses default if None)
+
+        Returns:
+            The agent's response as a string
+        """
+        target = agent_name or self._default
+        if not target:
+            raise ValueError("No default agent available")
+
+        if target not in self._agents:
+            raise ValueError(f"No agent named '{target}'")
 
-        if not message or "" == message:
-            return await self.prompt(agent_name)
+        proxy = self._agents[target]
+        return await proxy.send(message)
+
+    async def apply_prompt(
+        self,
+        prompt_name: str,
+        arguments: Optional[dict[str, str]] = None,
+        agent_name: Optional[str] = None,
+    ) -> str:
+        """
+        Apply an MCP Server Prompt by name and return the assistant's response
 
-        proxy = self._agents[agent_name]
-        return await proxy.generate_str(message)
+        Args:
+            prompt_name: The name of the prompt to apply
+            arguments: Optional dictionary of string arguments to pass to the prompt template
+            agent_name: The name of the agent to use (uses default if None)
+
+        Returns:
+            The assistant's response as a string
+        """
+        target = agent_name or self._default
+        if not target:
+            raise ValueError("No default agent available")
+
+        if target not in self._agents:
+            raise ValueError(f"No agent named '{target}'")
+
+        proxy = self._agents[target]
+        return await proxy.apply_prompt(prompt_name, arguments)
 
     async def prompt(self, agent_name: Optional[str] = None, default: str = "") -> str:
         """
@@ -506,7 +571,7 @@ class AgentApp:
                 if user_input == "":
                     continue
 
-            result = await self.send(agent, user_input)
+            result = await self.send(user_input, agent)
 
             # Check if current agent is a chain that should continue with final agent
             if agent_types.get(agent) == "Chain":
@@ -532,10 +597,21 @@ class AgentApp:
         return self._agents[name]
 
     async def __call__(
-        self, message: Optional[str] = "", agent_name: Optional[str] = None
+        self,
+        message: Optional[Union[str, PromptMessageMultipart]] = None,
+        agent_name: Optional[str] = None,
     ) -> str:
-        """Support: agent('message')"""
+        """
+        Support: agent('message') or agent(Prompt.user('message'))
+
+        Args:
+            message: Either a string message or a PromptMessageMultipart object
+            agent_name: The name of the agent to use (uses default if None)
+
+        Returns:
+            The agent's response as a string
+        """
         target = agent_name or self._default
         if not target:
             raise ValueError("No default agent available")
-        return await self.send(target, message)
+        return await self.send(message, target)

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.9}/src/mcp_agent/core/fastagent.py

@@ -70,7 +70,12 @@ class FastAgent(ContextDependent):
     Provides a simplified way to create and manage agents using decorators.
     """
 
-    def __init__(self, name: str, config_path: Optional[str] = None):
+    def __init__(
+        self,
+        name: str,
+        config_path: Optional[str] = None,
+        ignore_unknown_args: bool = False,
+    ):
         """
         Initialize the decorator interface.
 
@@ -101,7 +106,12 @@ class FastAgent(ContextDependent):
             action="store_true",
             help="Disable progress display, tool and message logging for cleaner output",
         )
-        self.args = parser.parse_args()
+
+        if ignore_unknown_args:
+            known_args, _ = parser.parse_known_args()
+            self.args = known_args
+        else:
+            self.args = parser.parse_args()
 
         # Quiet mode will be handled in _load_config()
 
@@ -372,7 +382,7 @@ class FastAgent(ContextDependent):
 
                 # Create wrapper with all agents
                 wrapper = AgentApp(agent_app, active_agents)
-                
+
                 # Store reference to AgentApp in MCPApp for proxies to access
                 agent_app._agent_app = wrapper
 

fast_agent_mcp-0.1.9/src/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 {}