fast-agent-mcp 0.1.12__py3-none-any.whl → 0.2.0__py3-none-any.whl

mcp_agent/core/proxies.py

@@ -1,269 +0,0 @@
-"""
-Proxy classes for agent interactions.
-These proxies provide a consistent interface for interacting with different types of agents.
-
-FOR COMPATIBILITY WITH LEGACY MCP-AGENT CODE
-
-"""
-
-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:
-    from mcp_agent.core.types import WorkflowType, ProxyDict
-else:
-    # Define minimal versions for runtime
-    from typing import Any
-
-    # Use Any for runtime to avoid circular imports
-    WorkflowType = Any
-    ProxyDict = Dict[str, "BaseAgentProxy"]
-
-
-class BaseAgentProxy:
-    """Base class for all proxy types"""
-
-    def __init__(self, app: MCPApp, name: str):
-        self._app = app
-        self._name = name
-
-    async def __call__(self, message: Optional[str] = None) -> str:
-        """Allow: agent.researcher('message') or just agent.researcher()"""
-        if message is None:
-            # When called with no arguments, use prompt() to open the interactive interface
-            return await self.prompt()
-        return await self.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"
-
-    async def generate_str(self, message: str) -> str:
-        """Generate response for a message - must be implemented by subclasses"""
-        raise NotImplementedError("Subclasses must implement generate_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
-        """
-        raise NotImplementedError("Subclasses must implement apply_prompt")
-
-
-class LLMAgentProxy(BaseAgentProxy):
-    """Proxy for regular agents that use _llm.generate_str()"""
-
-    def __init__(self, app: MCPApp, name: str, agent: Agent):
-        super().__init__(app, name)
-        self._agent = agent
-
-    async def generate_str(self, message: str, **kwargs) -> str:
-        """Forward message and all kwargs to the agent's LLM"""
-        return await self._agent._llm.generate_str(message, **kwargs)
-
-    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"""
-
-    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType):
-        super().__init__(app, name)
-        self._workflow = workflow
-
-    async def generate_str(self, message: str, **kwargs) -> str:
-        """Forward message and all kwargs to the underlying workflow"""
-        return await self._workflow.generate_str(message, **kwargs)
-
-
-class RouterProxy(BaseAgentProxy):
-    """Proxy for LLM Routers"""
-
-    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType):
-        super().__init__(app, name)
-        self._workflow = workflow
-
-    async def generate_str(self, message: str, **kwargs) -> str:
-        """
-        Route the message and forward kwargs to the resulting agent if applicable.
-        Note: For now, route() itself doesn't accept kwargs.
-        """
-        results = await self._workflow.route(message)
-        if not results:
-            return "No appropriate route found for the request."
-
-        # Get the top result
-        top_result = results[0]
-        if isinstance(top_result.result, Agent):
-            # Agent route - delegate to the agent, passing along kwargs
-            agent = top_result.result
-            return await agent._llm.generate_str(message, **kwargs)
-        elif isinstance(top_result.result, str):
-            # Server route - use the router directly
-            return "Tool call requested by router - not yet supported"
-
-        return f"Routed to: {top_result.result} ({top_result.confidence}): {top_result.reasoning}"
-
-
-class ChainProxy(BaseAgentProxy):
-    """Proxy for chained agent operations"""
-
-    def __init__(
-        self, app: MCPApp, name: str, sequence: List[str], agent_proxies: ProxyDict
-    ):
-        super().__init__(app, name)
-        self._sequence = sequence
-        self._agent_proxies = agent_proxies
-        self._continue_with_final = True  # Default behavior
-        self._cumulative = False  # Default to sequential chaining
-
-    async def generate_str(self, message: str, **kwargs) -> str:
-        """Chain message through a sequence of agents.
-
-        For the first agent in the chain, pass all kwargs to maintain transparency.
-
-        Two modes of operation:
-        1. Sequential (default): Each agent receives only the output of the previous agent
-        2. Cumulative: Each agent receives all previous agent responses concatenated
-        """
-        if not self._sequence:
-            return message
-
-        # Process the first agent (same for both modes)
-        first_agent = self._sequence[0]
-        first_proxy = self._agent_proxies[first_agent]
-        first_response = await first_proxy.generate_str(message, **kwargs)
-
-        if len(self._sequence) == 1:
-            return first_response
-
-        if self._cumulative:
-            # Cumulative mode: each agent gets all previous responses
-            cumulative_response = f'<fastagent:response agent="{first_agent}">\n{first_response}\n</fastagent:response>'
-
-            # Process subsequent agents with cumulative results
-            for agent_name in self._sequence[1:]:
-                proxy = self._agent_proxies[agent_name]
-                # Pass all previous responses to next agent
-                agent_response = await proxy.generate_str(cumulative_response)
-                # Add this agent's response to the cumulative result
-                cumulative_response += f'\n\n<fastagent:response agent="{agent_name}">\n{agent_response}\n</fastagent:response>'
-
-            return cumulative_response
-        else:
-            # Sequential chaining (original behavior)
-            current_message = first_response
-
-            # For subsequent agents, just pass the message from previous agent
-            for agent_name in self._sequence[1:]:
-                proxy = self._agent_proxies[agent_name]
-                current_message = await proxy.generate_str(current_message)
-
-            return current_message

mcp_agent/core/types.py

@@ -1,24 +0,0 @@
-"""
-Type definitions for fast-agent core module.
-"""
-
-from typing import Dict, Union, TypeAlias, TYPE_CHECKING
-
-from mcp_agent.agents.agent import Agent
-from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
-from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
-from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
-    EvaluatorOptimizerLLM,
-)
-from mcp_agent.workflows.router.router_llm import LLMRouter
-
-# Avoid circular imports
-if TYPE_CHECKING:
-    from mcp_agent.core.proxies import BaseAgentProxy
-
-# Type aliases for better readability
-WorkflowType: TypeAlias = Union[
-    Orchestrator, ParallelLLM, EvaluatorOptimizerLLM, LLMRouter
-]
-AgentOrWorkflow: TypeAlias = Union[Agent, WorkflowType]
-ProxyDict: TypeAlias = Dict[str, "BaseAgentProxy"]  # Forward reference as string

mcp_agent/mcp/stdio.py

@@ -1,111 +0,0 @@
-"""
-Custom implementation of stdio_client that handles stderr through rich console.
-"""
-
-from contextlib import asynccontextmanager
-import subprocess
-import anyio
-from anyio.streams.text import TextReceiveStream
-from mcp.client.stdio import StdioServerParameters, get_default_environment
-import mcp.types as types
-from mcp_agent.logging.logger import get_logger
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-
-logger = get_logger(__name__)
-
-
-# TODO this will be removed when client library with https://github.com/modelcontextprotocol/python-sdk/pull/343 is released
-@asynccontextmanager
-async def stdio_client_with_rich_stderr(server: StdioServerParameters):
-    """
-    Modified version of stdio_client that captures stderr and routes it through our rich console.
-    Follows the original pattern closely for reliability.
-
-    Args:
-        server: The server parameters for the stdio connection
-    """
-    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
-    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
-
-    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
-    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
-
-    read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
-    write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-    # Open process with stderr piped for capture
-
-    process = await anyio.open_process(
-        [server.command, *server.args],
-        env=server.env if server.env is not None else get_default_environment(),
-        stderr=subprocess.PIPE,
-    )
-
-    if process.pid:
-        logger.debug(f"Started process '{server.command}' with PID: {process.pid}")
-
-    if process.returncode is not None:
-        logger.debug(f"return code (early){process.returncode}")
-        raise RuntimeError(
-            f"Process terminated immediately with code {process.returncode}"
-        )
-
-    async def stdout_reader():
-        assert process.stdout, "Opened process is missing stdout"
-        try:
-            async with read_stream_writer:
-                buffer = ""
-                async for chunk in TextReceiveStream(
-                    process.stdout,
-                    encoding=server.encoding,
-                    errors=server.encoding_error_handler,
-                ):
-                    lines = (buffer + chunk).split("\n")
-                    buffer = lines.pop()
-
-                    for line in lines:
-                        if not line:
-                            continue
-                        try:
-                            message = types.JSONRPCMessage.model_validate_json(line)
-                        except Exception as exc:
-                            await read_stream_writer.send(exc)
-                            continue
-
-                        await read_stream_writer.send(message)
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
-
-    # async def stderr_reader():
-    #     assert process.stderr, "Opened process is missing stderr"
-    #     try:
-    #         async for chunk in TextReceiveStream(
-    #             process.stderr,
-    #             encoding=server.encoding,
-    #             errors=server.encoding_error_handler,
-    #         ):
-    #             if chunk.strip():
-    #                 # Let the logging system handle the formatting consistently
-    #                 logger.event("info", "mcpserver.stderr", chunk.rstrip(), None, {})
-    #     except anyio.ClosedResourceError:
-    #         await anyio.lowlevel.checkpoint()
-
-    async def stdin_writer():
-        assert process.stdin, "Opened process is missing stdin"
-        try:
-            async with write_stream_reader:
-                async for message in write_stream_reader:
-                    json = message.model_dump_json(by_alias=True, exclude_none=True)
-                    await process.stdin.send(
-                        (json + "\n").encode(
-                            encoding=server.encoding,
-                            errors=server.encoding_error_handler,
-                        )
-                    )
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
-
-    # Use context managers to handle cleanup automatically
-    async with anyio.create_task_group() as tg, process:
-        tg.start_soon(stdout_reader)
-        tg.start_soon(stdin_writer)
-        yield read_stream, write_stream

mcp_agent/resources/examples/data-analysis/analysis-campaign.py

@@ -1,188 +0,0 @@
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-from mcp_agent.workflows.llm.augmented_llm import RequestParams
-
-# Create the application
-fast = FastAgent("Data Analysis & Campaign Generator")
-
-
-# Original data analysis components
-@fast.agent(
-    name="data_analysis",
-    instruction="""
-You have access to a Python 3.12 interpreter and you can use this to analyse and process data. 
-Common analysis packages such as Pandas, Seaborn and Matplotlib are already installed. 
-You can add further packages if needed.
-Data files are accessible from the /mnt/data/ directory (this is the current working directory).
-Visualisations should be saved as .png files in the current working directory.
-Extract key insights that would be compelling for a social media campaign.
-""",
-    servers=["interpreter"],
-    request_params=RequestParams(maxTokens=8192),
-    model="sonnet",
-)
-@fast.agent(
-    "evaluator",
-    """You are collaborating with a Data Analysis tool that has the capability to analyse data and produce visualisations.
-    You must make sure that the tool has:
-     - Considered the best way for a Human to interpret the data
-     - Produced insightful visualisations.
-     - Provided a high level summary report for the Human.
-     - Has had its findings challenged, and justified
-     - Extracted compelling insights suitable for social media promotion
-    """,
-    request_params=RequestParams(maxTokens=8192),
-    model="gpt-4o",
-)
-@fast.evaluator_optimizer(
-    "analysis_tool",
-    generator="data_analysis",
-    evaluator="evaluator",
-    max_refinements=3,
-    min_rating="EXCELLENT",
-)
-# Research component using Brave search
-@fast.agent(
-    "context_researcher",
-    """You are a research specialist who provides cultural context for different regions.
-    For any given data insight and target language/region, research:
-    1. Cultural sensitivities related to presenting this type of data
-    2. Local social media trends and preferences
-    3. Region-specific considerations for marketing campaigns
-    
-    Always provide actionable recommendations for adapting content to each culture.
-    """,
-    servers=["fetch", "brave"],  # Using the fetch MCP server for Brave search
-    request_params=RequestParams(temperature=0.3),
-    model="gpt-4o",
-)
-# Social media content generator
-@fast.agent(
-    "campaign_generator",
-    """Generate engaging social media content based on data insights.
-    Create compelling, shareable content that:
-    - Highlights key research findings in an accessible way
-    - Uses appropriate tone for the platform (Twitter/X, LinkedIn, Instagram, etc.)
-    - Is concise and impactful
-    - Includes suggested hashtags and posting schedule
-    
-    Format your response with clear sections for each platform.
-    Save different campaign elements as separate files in the current directory.
-    """,
-    servers=["filesystem"],  # Using filesystem MCP server to save files
-    request_params=RequestParams(temperature=0.7),
-    model="sonnet",
-    use_history=False,
-)
-# Translation agents with cultural adaptation
-@fast.agent(
-    "translate_fr",
-    """Translate social media content to French with cultural adaptation.
-    Consider French cultural norms, expressions, and social media preferences.
-    Ensure the translation maintains the impact of the original while being culturally appropriate.
-    Save the translated content to a file with appropriate naming.
-    """,
-    model="haiku",
-    use_history=False,
-    servers=["filesystem"],
-)
-@fast.agent(
-    "translate_es",
-    """Translate social media content to Spanish with cultural adaptation.
-    Consider Spanish-speaking cultural contexts, expressions, and social media preferences.
-    Ensure the translation maintains the impact of the original while being culturally appropriate.
-    Save the translated content to a file with appropriate naming.
-    """,
-    model="haiku",
-    use_history=False,
-    servers=["filesystem"],
-)
-@fast.agent(
-    "translate_de",
-    """Translate social media content to German with cultural adaptation.
-    Consider German cultural norms, expressions, and social media preferences.
-    Ensure the translation maintains the impact of the original while being culturally appropriate.
-    Save the translated content to a file with appropriate naming.
-    """,
-    model="haiku",
-    use_history=False,
-    servers=["filesystem"],
-)
-@fast.agent(
-    "translate_ja",
-    """Translate social media content to Japanese with cultural adaptation.
-    Consider Japanese cultural norms, expressions, and social media preferences.
-    Ensure the translation maintains the impact of the original while being culturally appropriate.
-    Save the translated content to a file with appropriate naming.
-    """,
-    model="haiku",
-    use_history=False,
-    servers=["filesystem"],
-)
-# Parallel workflow for translations
-@fast.parallel(
-    "translate_campaign",
-    instruction="Translates content to French, Spanish, German and Japanese. Supply the content to translate, translations will be saved to the filesystem.",
-    fan_out=["translate_fr", "translate_es", "translate_de", "translate_ja"],
-    include_request=True,
-)
-# Cultural sensitivity review agent
-@fast.agent(
-    "cultural_reviewer",
-    """Review all translated content for cultural sensitivity and appropriateness.
-    For each language version, evaluate:
-    - Cultural appropriateness
-    - Potential misunderstandings or sensitivities
-    - Effectiveness for the target culture
-    
-    Provide specific recommendations for any needed adjustments and save a review report.
-    """,
-    servers=["filesystem"],
-    request_params=RequestParams(temperature=0.2),
-)
-# Campaign optimization workflow
-@fast.evaluator_optimizer(
-    "campaign_optimizer",
-    generator="campaign_generator",
-    evaluator="cultural_reviewer",
-    max_refinements=2,
-    min_rating="EXCELLENT",
-)
-# Main workflow orchestration
-@fast.orchestrator(
-    "research_campaign_creator",
-    instruction="""
-    Create a complete multi-lingual social media campaign based on data analysis results.
-    The workflow will:
-    1. Analyze the provided data and extract key insights
-    2. Research cultural contexts for target languages
-    3. Generate appropriate social media content
-    4. Translate and culturally adapt the content
-    5. Review and optimize all materials
-    6. Save all campaign elements to files
-    """,
-    agents=[
-        "analysis_tool",
-        "context_researcher",
-        "campaign_optimizer",
-        "translate_campaign",
-    ],
-    model="sonnet",  # Using a more capable model for orchestration
-    request_params=RequestParams(maxTokens=8192),
-    plan_type="full",
-)
-async def main():
-    # Use the app's context manager
-    print(
-        "WARNING: This workflow will likely run for >10 minutes and consume a lot of tokens. Press Enter to accept the default prompt and proceed"
-    )
-
-    async with fast.run() as agent:
-        await agent.research_campaign_creator.prompt(
-            default_prompt="Analyze the CSV file in the current directory and create a comprehensive multi-lingual social media campaign based on the findings. Save all campaign elements as separate files."
-        )
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/data-analysis/analysis.py

@@ -1,65 +0,0 @@
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-from mcp_agent.workflows.llm.augmented_llm import RequestParams
-
-# Create the application
-fast = FastAgent("Data Analysis (Roots)")
-
-
-# The sample data is under Database Contents License (DbCL) v1.0.
-# Available here : https://www.kaggle.com/datasets/pavansubhasht/ibm-hr-analytics-attrition-dataset
-
-
-@fast.agent(
-    name="data_analysis",
-    instruction="""
-You have access to a Python 3.12 interpreter and you can use this to analyse and process data. 
-Common analysis packages such as Pandas, Seaborn and Matplotlib are already installed. 
-You can add further packages if needed.
-Data files are accessible from the /mnt/data/ directory (this is the current working directory).
-Visualisations should be saved as .png files in the current working directory.
-""",
-    servers=["interpreter"],
-    request_params=RequestParams(maxTokens=8192),
-)
-async def main():
-    # Use the app's context manager
-    async with fast.run() as agent:
-        await agent(
-            "There is a csv file in the current directory. "
-            "Analyse the file, produce a detailed description of the data, and any patterns it contains.",
-        )
-        await agent(
-            "Consider the data, and how to usefully group it for presentation to a Human. Find insights, using the Python Interpreter as needed.\n"
-            "Use MatPlotLib to produce insightful visualisations. Save them as '.png' files in the current directory. Be sure to run the code and save the files.\n"
-            "Produce a summary with major insights to the data",
-        )
-        await agent()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-
-
-############################################################################################################
-# Example of evaluator/optimizer flow
-############################################################################################################
-# @fast.agent(
-#     "evaluator",
-#     """You are collaborating with a Data Analysis tool that has the capability to analyse data and produce visualisations.
-#     You must make sure that the tool has:
-#      - Considered the best way for a Human to interpret the data
-#      - Produced insightful visualasions.
-#      - Provided a high level summary report for the Human.
-#      - Has had its findings challenged, and justified
-#     """,
-#     request_params=RequestParams(maxTokens=8192),
-# )
-# @fast.evaluator_optimizer(
-#     "analysis_tool",
-#     generator="data_analysis",
-#     evaluator="evaluator",
-#     max_refinements=3,
-#     min_rating="EXCELLENT",
-# )