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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.8
+Version: 0.1.10
 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,11 @@ 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, Resources 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 +593,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 +623,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 +644,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.10}/README.md

@@ -16,6 +16,11 @@ 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, Resources 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 +350,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 +380,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 +401,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.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.1.8"
+version = "0.1.10"
 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.10}/src/mcp_agent/agents/agent.py

@@ -9,7 +9,10 @@ from mcp.types import (
     ListToolsResult,
     TextContent,
     Tool,
+    EmbeddedResource,
+    ReadResourceResult,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 from mcp_agent.core.exceptions import PromptExitError
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
@@ -320,18 +323,25 @@ class Agent(MCPAggregator):
                 ],
             )
 
-    async def apply_prompt(self, prompt_name: str, arguments: dict[str, str] = None) -> str:
+    async def read_resource(
+        self, server_name: str, resource_name: str
+    ) -> ReadResourceResult:
+        return None
+
+    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
         """
@@ -358,10 +368,106 @@ class Agent(MCPAggregator):
         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:
+    async def get_resource(self, server_name: str, resource_name: str):
+        """
+        Get a resource directly from an MCP server by name.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name of the resource to retrieve
+
+        Returns:
+            The resource object from the MCP server
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Get the specified server connection
+        server = self.get_server(server_name)
+        if not server:
+            raise ValueError(f"Server '{server_name}' not found or not connected")
+
+        # Request the resource directly from the server
+        try:
+            resource_result = await server.get_resource(resource_name)
+            return resource_result
+        except Exception as e:
+            self.logger.error(
+                f"Error retrieving resource '{resource_name}' from server '{server_name}': {str(e)}"
+            )
+            raise ValueError(
+                f"Failed to retrieve resource '{resource_name}' from server '{server_name}': {str(e)}"
+            )
+
+    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
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
         """
-        Legacy method - use apply_prompt instead.
-        This is maintained for backward compatibility.
+        # Get the raw resource result
+        result: ReadResourceResult = await super().get_resource(
+            server_name, resource_name
+        )
+
+        # Convert each resource content to an EmbeddedResource
+        embedded_resources: List[EmbeddedResource] = []
+        for resource_content in result.contents:
+            embedded_resource = EmbeddedResource(
+                type="resource", resource=resource_content, annotations=None
+            )
+            embedded_resources.append(embedded_resource)
+
+        return embedded_resources
+
+    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.apply_prompt(prompt_name, arguments)
+        # Get the embedded resources
+        embedded_resources: List[EmbeddedResource] = await self.get_embedded_resources(
+            server_name, resource_name
+        )
+
+        # Create or update the prompt message
+        prompt: PromptMessageMultipart
+        if isinstance(prompt_content, str):
+            # Create a new prompt with the text and resources
+            content = [TextContent(type="text", text=prompt_content)]
+            content.extend(embedded_resources)
+            prompt = PromptMessageMultipart(role="user", content=content)
+        elif isinstance(prompt_content, PromptMessageMultipart):
+            # Add resources to the existing prompt
+            prompt = prompt_content
+            prompt.content.extend(embedded_resources)
+        else:
+            raise TypeError("prompt_content must be a string or PromptMessageMultipart")
+
+        # Send the prompt to the agent and return the response
+        return await self._llm.generate_prompt(prompt, None)

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.10}/src/mcp_agent/context.py

@@ -24,7 +24,6 @@ from mcp_agent.executor.executor import Executor
 from mcp_agent.executor.decorator_registry import (
     DecoratorRegistry,
     register_asyncio_decorators,
-    register_temporal_decorators,
 )
 from mcp_agent.executor.task_registry import ActivityRegistry
 from mcp_agent.executor.executor import AsyncioExecutor
@@ -194,7 +193,6 @@ async def initialize_context(
 
     context.decorator_registry = DecoratorRegistry()
     register_asyncio_decorators(context.decorator_registry)
-    register_temporal_decorators(context.decorator_registry)
 
     # Store the tracer in context if needed
     context.tracer = trace.get_tracer(config.otel.service_name)

{fast_agent_mcp-0.1.8 → fast_agent_mcp-0.1.10}/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.10}/src/mcp_agent/core/factory.py

@@ -172,16 +172,17 @@ async def create_agents_by_type(
             if agent_type == AgentType.BASIC:
                 # Get the agent name for special handling
                 agent_name = agent_data["config"].name
-                agent = Agent(config=config, context=app_instance.context)
-
-                # Set up LLM with proper configuration
-                async with agent:
-                    llm_factory = model_factory_func(
-                        model=config.model,
-                        request_params=config.default_request_params,
-                    )
-                    agent._llm = await agent.attach_llm(llm_factory)
+                agent = Agent(
+                    config=config,
+                    context=app_instance.context,
+                )
+                await agent.initialize()
 
+                llm_factory = model_factory_func(
+                    model=config.model,
+                    request_params=config.default_request_params,
+                )
+                agent._llm = await agent.attach_llm(llm_factory)
                 # Store the agent
                 instance = agent
 
@@ -222,16 +223,16 @@ async def create_agents_by_type(
                     default_request_params=base_params,
                 )
                 planner_agent = Agent(
-                    config=planner_config, context=app_instance.context
+                    config=planner_config,
+                    context=app_instance.context,
                 )
                 planner_factory = model_factory_func(
                     model=config.model,
                     request_params=config.default_request_params,
                 )
 
-                async with planner_agent:
-                    planner = await planner_agent.attach_llm(planner_factory)
-
+                planner = await planner_agent.attach_llm(planner_factory)
+                await planner.initialize()
                 # Create the orchestrator with pre-configured planner
                 instance = Orchestrator(
                     name=config.name,

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

@@ -16,7 +16,6 @@ from contextlib import asynccontextmanager
 from functools import partial
 
 from mcp_agent.app import MCPApp
-from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.config import Settings
 
 from mcp_agent.core.agent_app import AgentApp
@@ -64,13 +63,18 @@ from mcp_agent.mcp_server import AgentMCPServer
 T = TypeVar("T")  # For the wrapper classes
 
 
-class FastAgent(ContextDependent):
+class FastAgent:
     """
     A decorator-based interface for MCP Agent applications.
     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 +105,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()
 
@@ -310,6 +319,7 @@ class FastAgent(ContextDependent):
         """
         active_agents = {}
         had_error = False
+        await self.app.initialize()
 
         # Handle quiet mode by disabling logger settings after initialization
         quiet_mode = hasattr(self, "args") and self.args.quiet
@@ -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