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

mcp_agent/workflows/parallel/fan_in.py

@@ -1,320 +0,0 @@
-import contextlib
-from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Type
-
-from mcp_agent.agents.agent import Agent
-from mcp_agent.context_dependent import ContextDependent
-from mcp_agent.workflows.llm.augmented_llm import (
-    AugmentedLLM,
-    MessageParamT,
-    MessageT,
-    ModelT,
-    RequestParams,
-)
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-FanInInput = (
-    # Dict of agent/source name to list of messages generated by that agent
-    Dict[str, List[MessageT] | List[MessageParamT]]
-    # Dict of agent/source name to string generated by that agent
-    | Dict[str, str]
-    # List of lists of messages generated by each agent
-    | List[List[MessageT] | List[MessageParamT]]
-    # List of strings generated by each agent
-    | List[str]
-)
-
-
-class FanIn(ContextDependent):
-    """
-    Aggregate results from multiple parallel tasks into a single result.
-
-    This is a building block of the Parallel workflow, which can be used to fan out
-    work to multiple agents or other parallel tasks, and then aggregate the results.
-
-    For example, you can use FanIn to combine the results of multiple agents into a single response,
-    such as a Summarization Fan-In agent that combines the outputs of multiple language models.
-    """
-
-    def __init__(
-        self,
-        aggregator_agent: Agent | AugmentedLLM[MessageParamT, MessageT],
-        llm_factory: Callable[[Agent], AugmentedLLM[MessageParamT, MessageT]] = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        """
-        Initialize the FanIn with an Agent responsible for processing multiple responses into a single aggregated one.
-        """
-
-        super().__init__(context=context, **kwargs)
-
-        self.executor = self.context.executor
-        self.llm_factory = llm_factory
-        self.aggregator_agent = aggregator_agent
-
-        if not isinstance(self.aggregator_agent, AugmentedLLM):
-            if not self.llm_factory:
-                raise ValueError("llm_factory is required when using an Agent")
-
-    async def generate(
-        self,
-        messages: FanInInput,
-        request_params: RequestParams | None = None,
-    ) -> List[MessageT]:
-        """
-        Request fan-in agent generation from a list of messages from multiple sources/agents.
-        Internally aggregates the messages and then calls the aggregator agent to generate a response.
-        """
-        message: str | MessageParamT | List[MessageParamT] = await self.aggregate_messages(messages)
-
-        async with contextlib.AsyncExitStack() as stack:
-            if isinstance(self.aggregator_agent, AugmentedLLM):
-                llm = self.aggregator_agent
-            else:
-                # Enter agent context
-                ctx_agent = await stack.enter_async_context(self.aggregator_agent)
-                llm = await ctx_agent.attach_llm(self.llm_factory)
-
-            return await llm.generate(
-                message=message,
-                request_params=request_params,
-            )
-
-    async def generate_str(
-        self,
-        messages: FanInInput,
-        request_params: RequestParams | None = None,
-    ) -> str:
-        """
-        Request fan-in agent generation from a list of messages from multiple sources/agents.
-        Internally aggregates the messages and then calls the aggregator agent to generate a
-        response, which is returned as a string.
-        """
-
-        message: str | MessageParamT | List[MessageParamT] = await self.aggregate_messages(messages)
-
-        async with contextlib.AsyncExitStack() as stack:
-            if isinstance(self.aggregator_agent, AugmentedLLM):
-                llm = self.aggregator_agent
-            else:
-                # Enter agent context
-                ctx_agent = await stack.enter_async_context(self.aggregator_agent)
-                llm = await ctx_agent.attach_llm(self.llm_factory)
-
-            return await llm.generate_str(message=message, request_params=request_params)
-
-    async def generate_structured(
-        self,
-        messages: FanInInput,
-        response_model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> ModelT:
-        """
-        Request a structured fan-in agent generation from a list of messages
-        from multiple sources/agents. Internally aggregates the messages and then calls
-        the aggregator agent to generate a response, which is returned as a Pydantic model.
-        """
-
-        message: str | MessageParamT | List[MessageParamT] = await self.aggregate_messages(messages)
-
-        async with contextlib.AsyncExitStack() as stack:
-            if isinstance(self.aggregator_agent, AugmentedLLM):
-                llm = self.aggregator_agent
-            else:
-                # Enter agent context
-                ctx_agent = await stack.enter_async_context(self.aggregator_agent)
-                llm = await ctx_agent.attach_llm(self.llm_factory)
-
-            return await llm.generate_structured(
-                message=message,
-                response_model=response_model,
-                request_params=request_params,
-            )
-
-    async def aggregate_messages(self, messages: FanInInput) -> str | MessageParamT | List[MessageParamT]:
-        """
-        Aggregate messages from multiple sources/agents into a single message to
-        use with the aggregator agent generation.
-
-        The input can be a dictionary of agent/source name to list of messages
-        generated by that agent, or just the unattributed lists of messages to aggregate.
-
-        Args:
-            messages: Can be one of:
-                - Dict[str, List[MessageT] | List[MessageParamT]]: Dict of agent names to messages
-                - Dict[str, str]: Dict of agent names to message strings
-                - List[List[MessageT] | List[MessageParamT]]: List of message lists from agents
-                - List[str]: List of message strings from agents
-
-        Returns:
-            Aggregated message as string, MessageParamT or List[MessageParamT]
-
-        Raises:
-            ValueError: If input is empty or contains empty/invalid elements
-        """
-        # Handle dictionary inputs
-        if isinstance(messages, dict):
-            # Check for empty dict
-            if not messages:
-                raise ValueError("Input dictionary cannot be empty")
-
-            first_value = next(iter(messages.values()))
-
-            # Dict[str, List[MessageT] | List[MessageParamT]]
-            if isinstance(first_value, list):
-                if any(not isinstance(v, list) for v in messages.values()):
-                    raise ValueError("All dictionary values must be lists of messages")
-                # Process list of messages for each agent
-                return await self.aggregate_agent_messages(messages)
-
-            # Dict[str, str]
-            elif isinstance(first_value, str):
-                if any(not isinstance(v, str) for v in messages.values()):
-                    raise ValueError("All dictionary values must be strings")
-                # Process string outputs from each agent
-                return await self.aggregate_agent_message_strings(messages)
-
-            else:
-                raise ValueError("Dictionary values must be either lists of messages or strings")
-
-        # Handle list inputs
-        elif isinstance(messages, list):
-            # Check for empty list
-            if not messages:
-                raise ValueError("Input list cannot be empty")
-
-            first_item = messages[0]
-
-            # List[List[MessageT] | List[MessageParamT]]
-            if isinstance(first_item, list):
-                if any(not isinstance(item, list) for item in messages):
-                    raise ValueError("All list items must be lists of messages")
-                # Process list of message lists
-                return await self.aggregate_message_lists(messages)
-
-            # List[str]
-            elif isinstance(first_item, str):
-                if any(not isinstance(item, str) for item in messages):
-                    raise ValueError("All list items must be strings")
-                # Process list of strings
-                return await self.aggregate_message_strings(messages)
-
-            else:
-                raise ValueError("List items must be either lists of messages or strings")
-
-        else:
-            raise ValueError("Input must be either a dictionary of agent messages or a list of messages")
-
-    # Helper methods for processing different types of inputs
-    async def aggregate_agent_messages(self, messages: Dict[str, List[MessageT] | List[MessageParamT]]) -> str | MessageParamT | List[MessageParamT]:
-        """
-        Aggregate message lists with agent names.
-
-        Args:
-            messages: Dictionary mapping agent names to their message lists
-
-        Returns:
-            str | List[MessageParamT]: Messages formatted with agent attribution
-
-        """
-
-        # In the default implementation, we'll just convert the messages to a
-        # single string with agent attribution
-        aggregated_messages = []
-
-        if not messages:
-            return ""
-
-        # Format each agent's messages with attribution
-        for agent_name, agent_messages in messages.items():
-            agent_message_strings = []
-            for msg in agent_messages or []:
-                if isinstance(msg, str):
-                    agent_message_strings.append(f"Agent {agent_name}: {msg}")
-                else:
-                    # Assume it's a Message/MessageParamT and add attribution
-                    # TODO -- this should really unpack the text from the message
-                    agent_message_strings.append(f"Agent {agent_name}: {str(msg.content[0])}")
-
-            aggregated_messages.append("\n".join(agent_message_strings))
-
-        # Combine all messages with clear separation
-        final_message = "\n\n".join(aggregated_messages)
-        final_message = f"Aggregated responses from multiple Agents:\n\n{final_message}"
-        return final_message
-
-    async def aggregate_agent_message_strings(self, messages: Dict[str, str]) -> str:
-        """
-        Aggregate string outputs with agent names.
-
-        Args:
-            messages: Dictionary mapping agent names to their string outputs
-
-        Returns:
-            str: Combined string with agent attributions
-        """
-        if not messages:
-            return ""
-
-        # Format each agent's message with agent attribution
-        aggregated_messages = [f"Agent {agent_name}: {message}" for agent_name, message in messages.items()]
-
-        # Combine all messages with clear separation
-        final_message = "\n\n".join(aggregated_messages)
-        final_message = f"Aggregated responses from multiple Agents:\n\n{final_message}"
-        return final_message
-
-    async def aggregate_message_lists(self, messages: List[List[MessageT] | List[MessageParamT]]) -> str | MessageParamT | List[MessageParamT]:
-        """
-        Aggregate message lists without agent names.
-
-        Args:
-            messages: List of message lists from different agents
-
-        Returns:
-            List[MessageParamT]: List of formatted messages
-        """
-        aggregated_messages = []
-
-        if not messages:
-            return ""
-
-        # Format each source's messages
-        for i, source_messages in enumerate(messages, 1):
-            source_message_strings = []
-            for msg in source_messages or []:
-                if isinstance(msg, str):
-                    source_message_strings.append(f"Source {i}: {msg}")
-                else:
-                    # Assume it's a MessageParamT or MessageT and add source attribution
-                    source_message_strings.append(f"Source {i}: {str(msg)}")
-
-            aggregated_messages.append("\n".join(source_messages))
-
-        # Combine all messages with clear separation
-        final_message = "\n\n".join(aggregated_messages)
-        final_message = f"Aggregated responses from multiple sources:\n\n{final_message}"
-        return final_message
-
-    async def aggregate_message_strings(self, messages: List[str]) -> str:
-        """
-        Aggregate string outputs without agent names.
-
-        Args:
-            messages: List of string outputs from different agents
-
-        Returns:
-            str: Combined string with source attributions
-        """
-        if not messages:
-            return ""
-
-        # Format each source's message with attribution
-        aggregated_messages = [f"Source {i}: {message}" for i, message in enumerate(messages, 1)]
-
-        # Combine all messages with clear separation
-        final_message = "\n\n".join(aggregated_messages)
-        final_message = f"Aggregated responses from multiple sources:\n\n{final_message}"
-        return final_message

mcp_agent/workflows/parallel/fan_out.py

@@ -1,181 +0,0 @@
-import contextlib
-import functools
-from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, List, Optional, Type
-
-from mcp_agent.agents.agent import Agent
-from mcp_agent.context_dependent import ContextDependent
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.workflows.llm.augmented_llm import (
-    AugmentedLLM,
-    MessageParamT,
-    MessageT,
-    ModelT,
-    RequestParams,
-)
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-logger = get_logger(__name__)
-
-
-class FanOut(ContextDependent):
-    """
-    Distribute work to multiple parallel tasks.
-
-    This is a building block of the Parallel workflow, which can be used to fan out
-    work to multiple agents or other parallel tasks, and then aggregate the results.
-    """
-
-    def __init__(
-        self,
-        agents: List[Agent | AugmentedLLM[MessageParamT, MessageT]] | None = None,
-        functions: List[Callable[[MessageParamT], List[MessageT]]] | None = None,
-        llm_factory: Callable[[Agent], AugmentedLLM[MessageParamT, MessageT]] = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        """
-        Initialize the FanOut with a list of agents, functions, or LLMs.
-        If agents are provided, they will be wrapped in an AugmentedLLM using llm_factory if not already done so.
-        If functions are provided, they will be invoked in parallel directly.
-        """
-        super().__init__(context=context, **kwargs)
-        self.executor = self.context.executor
-        self.llm_factory = llm_factory
-        self.agents = agents or []
-        self.functions: List[Callable[[MessageParamT], MessageT]] = functions or []
-
-        if not self.agents and not self.functions:
-            raise ValueError("At least one agent or function must be provided for fan-out to work")
-
-        if not self.llm_factory:
-            for agent in self.agents:
-                if not isinstance(agent, AugmentedLLM):
-                    raise ValueError("llm_factory is required when using an Agent")
-
-    async def generate(
-        self,
-        message: str | MessageParamT | List[MessageParamT],
-        request_params: RequestParams | None = None,
-    ) -> Dict[str, List[MessageT]]:
-        """
-        Request fan-out agent/function generations, and return the results as a dictionary.
-        The keys are the names of the agents or functions that generated the results.
-        """
-        tasks: List[Callable[..., List[MessageT]] | Coroutine[Any, Any, List[MessageT]]] = []
-        task_names: List[str] = []
-        task_results = []
-
-        async with contextlib.AsyncExitStack() as stack:
-            for agent in self.agents:
-                if isinstance(agent, AugmentedLLM):
-                    llm = agent
-                else:
-                    # Enter agent context
-                    ctx_agent = await stack.enter_async_context(agent)
-                    llm = await ctx_agent.attach_llm(self.llm_factory)
-
-                tasks.append(
-                    llm.generate(
-                        message=message,
-                        request_params=request_params,
-                    )
-                )
-                task_names.append(agent.name)
-
-            # Create bound methods for regular functions
-            for function in self.functions:
-                tasks.append(functools.partial(function, message))
-                task_names.append(function.__name__ or id(function))
-
-            # Wait for all tasks to complete
-            logger.debug("Running fan-out tasks:", data=task_names)
-            task_results = await self.executor.execute(*tasks)
-
-        logger.debug("Fan-out tasks completed:", data=dict(zip(task_names, task_results)))
-        return dict(zip(task_names, task_results))
-
-    async def generate_str(
-        self,
-        message: str | MessageParamT | List[MessageParamT],
-        request_params: RequestParams | None = None,
-    ) -> Dict[str, str]:
-        """
-        Request fan-out agent/function generations and return the string results as a dictionary.
-        The keys are the names of the agents or functions that generated the results.
-        """
-
-        def fn_result_to_string(fn, message):
-            return str(fn(message))
-
-        tasks: List[Callable[..., str] | Coroutine[Any, Any, str]] = []
-        task_names: List[str] = []
-        task_results = []
-
-        async with contextlib.AsyncExitStack() as stack:
-            for agent in self.agents:
-                if isinstance(agent, AugmentedLLM):
-                    llm = agent
-                else:
-                    # Enter agent context
-                    ctx_agent = await stack.enter_async_context(agent)
-                    llm = await ctx_agent.attach_llm(self.llm_factory)
-
-                tasks.append(
-                    llm.generate_str(
-                        message=message,
-                        request_params=request_params,
-                    )
-                )
-                task_names.append(agent.name)
-
-            # Create bound methods for regular functions
-            for function in self.functions:
-                tasks.append(functools.partial(fn_result_to_string, function, message))
-                task_names.append(function.__name__ or id(function))
-
-            task_results = await self.executor.execute(*tasks)
-
-        return dict(zip(task_names, task_results))
-
-    async def generate_structured(
-        self,
-        message: str | MessageParamT | List[MessageParamT],
-        response_model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> Dict[str, ModelT]:
-        """
-        Request a structured fan-out agent/function generation and return the result as a Pydantic model.
-        The keys are the names of the agents or functions that generated the results.
-        """
-        tasks = []
-        task_names = []
-        task_results = []
-
-        async with contextlib.AsyncExitStack() as stack:
-            for agent in self.agents:
-                if isinstance(agent, AugmentedLLM):
-                    llm = agent
-                else:
-                    # Enter agent context
-                    ctx_agent = await stack.enter_async_context(agent)
-                    llm = await ctx_agent.attach_llm(self.llm_factory)
-
-                tasks.append(
-                    llm.generate_structured(
-                        message=message,
-                        response_model=response_model,
-                        request_params=request_params,
-                    )
-                )
-                task_names.append(agent.name)
-
-            # Create bound methods for regular functions
-            for function in self.functions:
-                tasks.append(functools.partial(function, message))
-                task_names.append(function.__name__ or id(function))
-
-            task_results = await self.executor.execute(*tasks)
-
-        return dict(zip(task_names, task_results))

mcp_agent/workflows/parallel/parallel_llm.py

@@ -1,149 +0,0 @@
-import asyncio
-from typing import TYPE_CHECKING, Any, Callable, List, Optional, Type, Union
-
-from mcp_agent.agents.agent import Agent
-from mcp_agent.workflows.llm.augmented_llm import (
-    AugmentedLLM,
-    MessageParamT,
-    MessageT,
-    ModelT,
-    RequestParams,
-)
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
-    """
-    LLMs can sometimes work simultaneously on a task (fan-out)
-    and have their outputs aggregated programmatically (fan-in).
-    This workflow performs both the fan-out and fan-in operations using LLMs.
-    From the user's perspective, an input is specified and the output is returned.
-    """
-
-    def __init__(
-        self,
-        fan_in_agent: Agent | AugmentedLLM,
-        fan_out_agents: List[Agent | AugmentedLLM],
-        llm_factory: Callable[[Agent], AugmentedLLM] = None,
-        context: Optional["Context"] = None,
-        include_request: bool = True,
-        **kwargs,
-    ) -> None:
-        super().__init__(context=context, **kwargs)
-        self.fan_in_agent = fan_in_agent
-        self.fan_out_agents = fan_out_agents
-        self.llm_factory = llm_factory
-        self.include_request = include_request
-        self.history = None  # History tracking is complex in this workflow
-
-    async def ensure_llm(self, agent: Union[Agent, AugmentedLLM]) -> AugmentedLLM:
-        """Ensure an agent has an LLM attached, using existing or creating new."""
-        if isinstance(agent, AugmentedLLM):
-            return agent
-
-        if not hasattr(agent, "_llm") or agent._llm is None:
-            return await agent.attach_llm(self.llm_factory)
-
-        return agent._llm
-
-    async def generate(
-        self,
-        message: str | MessageParamT | List[MessageParamT],
-        request_params: RequestParams | None = None,
-    ) -> List[MessageT] | Any:
-        """Generate responses using parallel fan-out and fan-in."""
-        # Ensure all agents have LLMs
-        fan_out_llms = []
-        for agent in self.fan_out_agents:
-            llm = await self.ensure_llm(agent)
-            fan_out_llms.append(llm)
-
-        fan_in_llm = await self.ensure_llm(self.fan_in_agent)
-
-        # Run fan-out operations in parallel
-        responses = await asyncio.gather(*[llm.generate(message, request_params) for llm in fan_out_llms])
-
-        # Get message string for inclusion in formatted output
-        message_str = str(message) if isinstance(message, (str, MessageParamT)) else None
-
-        # Run fan-in to aggregate results
-        result = await fan_in_llm.generate(
-            self._format_responses(responses, message_str),
-            request_params=request_params,
-        )
-
-        return result
-
-    async def generate_str(
-        self,
-        message: str | MessageParamT | List[MessageParamT],
-        request_params: RequestParams | None = None,
-    ) -> str:
-        """Generate string responses using parallel fan-out and fan-in."""
-        # Ensure all agents have LLMs
-        fan_out_llms = []
-        for agent in self.fan_out_agents:
-            llm = await self.ensure_llm(agent)
-            fan_out_llms.append(llm)
-
-        fan_in_llm = await self.ensure_llm(self.fan_in_agent)
-
-        # Run fan-out operations in parallel
-        responses = await asyncio.gather(*[llm.generate_str(message, request_params) for llm in fan_out_llms])
-
-        # Get message string for inclusion in formatted output
-        message_str = str(message) if isinstance(message, (str, MessageParamT)) else None
-
-        # Run fan-in to aggregate results
-        result = await fan_in_llm.generate_str(
-            self._format_responses(responses, message_str),
-            request_params=request_params,
-        )
-
-        return result
-
-    async def generate_structured(
-        self,
-        message: str | MessageParamT | List[MessageParamT],
-        response_model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> ModelT:
-        """Generate structured responses using parallel fan-out and fan-in."""
-        # Ensure all agents have LLMs
-        fan_out_llms = []
-        for agent in self.fan_out_agents:
-            llm = await self.ensure_llm(agent)
-            fan_out_llms.append(llm)
-
-        fan_in_llm = await self.ensure_llm(self.fan_in_agent)
-
-        # Run fan-out operations in parallel
-        responses = await asyncio.gather(*[llm.generate_structured(message, response_model, request_params) for llm in fan_out_llms])
-
-        # Get message string for inclusion in formatted output
-        message_str = str(message) if isinstance(message, (str, MessageParamT)) else None
-
-        # Run fan-in to aggregate results
-        result = await fan_in_llm.generate_structured(
-            self._format_responses(responses, message_str),
-            response_model=response_model,
-            request_params=request_params,
-        )
-
-        return result
-
-    def _format_responses(self, responses: List[Any], message: str = None) -> str:
-        """Format a list of responses for the fan-in agent."""
-        formatted = []
-
-        # Include the original message if specified
-        if self.include_request and message:
-            formatted.append("The following request was sent to the agents:")
-            formatted.append(f"<fastagent:request>\n{message}\n</fastagent:request>")
-
-        for i, response in enumerate(responses):
-            agent_name = self.fan_out_agents[i].name
-            formatted.append(f'<fastagent:response agent="{agent_name}">\n{response}\n</fastagent:response>')
-        return "\n\n".join(formatted)