fast-agent-mcp 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

mcp_agent/core/proxies.py

@@ -0,0 +1,127 @@
+"""
+Proxy classes for agent interactions.
+These proxies provide a consistent interface for interacting with different types of agents.
+"""
+
+from typing import List, Optional, Dict, TYPE_CHECKING
+
+from mcp_agent.agents.agent import Agent
+from mcp_agent.app import MCPApp
+
+# Handle circular imports
+if TYPE_CHECKING:
+    from mcp_agent.core.types import WorkflowType, ProxyDict
+else:
+    # Define minimal versions for runtime
+    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
+    from typing import Union
+    WorkflowType = Union[Orchestrator, ParallelLLM, EvaluatorOptimizerLLM, LLMRouter]
+    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')"""
+        return await self.send(message)
+
+    async def send(self, message: Optional[str] = None) -> str:
+        """Allow: agent.researcher.send('message')"""
+        if message is None:
+            return await self.prompt()
+        return await self.generate_str(message)
+
+    async def prompt(self, default_prompt: str = "") -> str:
+        """Allow: agent.researcher.prompt()"""
+        return await self._app.prompt(self._name, default_prompt)
+
+    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")
+
+
+class AgentProxy(BaseAgentProxy):
+    """Legacy proxy for individual agent operations"""
+
+    async def generate_str(self, message: str) -> str:
+        return await self._app.send(self._name, message)
+
+
+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) -> str:
+        return await self._agent._llm.generate_str(message)
+
+
+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) -> str:
+        return await self._workflow.generate_str(message)
+
+
+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) -> str:
+        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
+            agent = top_result.result
+
+            return await agent._llm.generate_str(message)
+        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
+
+    async def generate_str(self, message: str) -> str:
+        """Chain message through a sequence of agents"""
+        current_message = message
+
+        for agent_name in self._sequence:
+            proxy = self._agent_proxies[agent_name]
+            current_message = await proxy.generate_str(current_message)
+
+        return current_message
+
+

mcp_agent/core/types.py

@@ -0,0 +1,22 @@
+"""
+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/resources/examples/internal/social.py

@@ -0,0 +1,66 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("Social Media Manager")
+
+
+@fast.agent(
+    "url_fetcher",
+    "Given a URL, provide a complete and comprehensive summary",
+    servers=["fetch"],
+)
+@fast.agent(
+    "post_author",
+    """
+    Write a 280 character social media post for any given text. 
+    Respond only with the post, never use hashtags.
+    """,
+)
+@fast.agent("translate_fr", "Translate the text to French.")
+@fast.agent("translate_de", "Translate the text to German.")
+@fast.agent(
+    "review",
+    """
+    Cleanly format the original content and translations for  review by a Social Media manager.
+    Highlight any cultural sensitivities.
+    """,
+    model="sonnet",
+)
+@fast.parallel(
+    "translated_plan",
+    fan_out=["translate_fr", "translate_de"],
+)
+@fast.agent(
+    "human_review_and_post",
+    """
+- You can send a social media post by saving it to a file name 'post-<lang>.md'.
+- NEVER POST TO SOCIAL MEDIA UNLESS THE HUMAN HAS REVIEWED AND APPROVED.
+
+Present the Social Media report to the Human, and then provide direct actionable questions to assist
+the Human in posting the content. 
+
+You are being connected to a Human now, the first message you receive will be a
+Social Media report ready to review with the Human.
+
+""",
+    human_input=True,
+    servers=["filesystem"],
+)
+@fast.chain(
+    "post_writer",
+    sequence=[
+        "url_fetcher",
+        "post_author",
+        "translated_plan",
+        "human_review_and_post",
+    ],
+)
+async def main():
+    async with fast.run() as agent:
+        # using chain workflow
+        await agent.post_writer.prompt()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/workflows/chaining.py

@@ -17,17 +17,27 @@ fast = FastAgent("Agent Chaining")
     Respond only with the post, never use hashtags.
     """,
 )
+@fast.chain(
+    name="post_writer",
+    sequence=["url_fetcher", "social_media"],
+)
 async def main():
     async with fast.run() as agent:
-        await agent.social_media(
-            await agent.url_fetcher("http://llmindset.co.uk/resources/mcp-hfspace/")
-        )
+        # using chain workflow
+        await agent.post_writer.prompt()
+
+        # calling directly
+        # await agent.url_fetcher("http://llmindset.co.uk/resources/mcp-hfspace/")
+        # await agent.social_media(
+        #     await agent.url_fetcher("http://llmindset.co.uk/resources/mcp-hfspace/")
+        # )
 
+        # agents can also be accessed like dictionaries:
+        # awwait agent["post_writer"].prompt()
 
-#      uncomment below to interact with agents
-#      await agent()
 
-# alternative syntax for above is agent["social_media"].send(message)
+# alternative syntax for above is result = agent["post_writer"].send(message)
+# alternative syntax for above is result = agent["post_writer"].prompt()
 
 
 if __name__ == "__main__":

mcp_agent/resources/examples/workflows/parallel.py

@@ -60,6 +60,10 @@ and whispers of a hidden agenda linger among the villagers.
     and give an overall grade based on the feedback.""",
     model="o3-mini.low",
 )
+@fast.agent(
+    name="cats-to-dogs",
+    instruction="you should take any text, and change references about cats to dogs",
+)
 @fast.parallel(
     fan_out=["proofreader", "fact_checker", "style_enforcer"],
     fan_in="grader",

mcp_agent/workflows/llm/augmented_llm.py

@@ -1,6 +1,16 @@
 from abc import abstractmethod
 
-from typing import Generic, List, Optional, Protocol, Type, TypeVar, TYPE_CHECKING
+from typing import (
+    Any,
+    Generic,
+    List,
+    Optional,
+    Protocol,
+    Type,
+    TypeVar,
+    TYPE_CHECKING,
+    Union,
+)
 
 from pydantic import Field
 
@@ -657,3 +667,67 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
             "agent_name": self.name,
         }
         self.logger.debug("Chat finished", data=data)
+
+
+class PassthroughLLM(AugmentedLLM):
+    """
+    A specialized LLM implementation that simply passes through input messages without modification.
+
+    This is useful for cases where you need an object with the AugmentedLLM interface
+    but want to preserve the original message without any processing, such as in a
+    parallel workflow where no fan-in aggregation is needed.
+    """
+
+    def __init__(self, name: str = "Passthrough", context=None, **kwargs):
+        super().__init__(name=name, context=context, **kwargs)
+
+    async def generate(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> Union[List[MessageT], Any]:
+        """Simply return the input message as is."""
+        # Return in the format expected by the caller
+        return [message] if isinstance(message, list) else message
+
+    async def generate_str(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> str:
+        """Return the input message as a string."""
+        self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
+        await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
+
+        return str(message)
+
+    async def generate_structured(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        response_model: Type[ModelT],
+        request_params: Optional[RequestParams] = None,
+    ) -> ModelT:
+        """
+        Return the input message as the requested model type.
+        This is a best-effort implementation - it may fail if the
+        message cannot be converted to the requested model.
+        """
+        if isinstance(message, response_model):
+            return message
+        elif isinstance(message, dict):
+            return response_model(**message)
+        elif isinstance(message, str):
+            try:
+                # Try to parse as JSON if it's a string
+                import json
+
+                data = json.loads(message)
+                return response_model(**data)
+            except:  # noqa: E722
+                raise ValueError(
+                    f"Cannot convert message of type {type(message)} to {response_model}"
+                )
+        else:
+            raise ValueError(
+                f"Cannot convert message of type {type(message)} to {response_model}"
+            )

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -39,8 +39,9 @@ from mcp_agent.workflows.llm.augmented_llm import (
 )
 from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.logging.logger import get_logger
+from rich.text import Text
 
-DEFAULT_ANTHROPIC_MODEL = "claude-3-5-sonnet-latest"
+DEFAULT_ANTHROPIC_MODEL = "claude-3-7-sonnet-latest"
 
 
 class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
@@ -149,9 +150,23 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                     "Please check that your API key is valid and not expired.",
                 ) from response
             elif isinstance(response, BaseException):
-                self.logger.error(f"Error: {executor_result}")
+                error_details = str(response)
+                self.logger.error(f"Error: {error_details}", data=executor_result)
+
+                # Try to extract more useful information for API errors
+                if hasattr(response, "status_code") and hasattr(response, "response"):
+                    try:
+                        error_json = response.response.json()
+                        error_details = (
+                            f"Error code: {response.status_code} - {error_json}"
+                        )
+                    except:  # noqa: E722
+                        error_details = (
+                            f"Error code: {response.status_code} - {str(response)}"
+                        )
+
                 # Convert other errors to text response
-                error_message = f"Error during generation: {str(response)}"
+                error_message = f"Error during generation: {error_details}"
                 response = Message(
                     id="error",  # Required field
                     model="error",  # Required field
@@ -207,14 +222,25 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                         message_text += block.text
 
                 # response.stop_reason == "tool_use":
-                for content in response.content:
-                    if content.type == "tool_use":
+                # First, collect all tool uses in this turn
+                tool_uses = [c for c in response.content if c.type == "tool_use"]
+
+                if tool_uses:
+                    if message_text == "":
+                        message_text = Text(
+                            "the assistant requested tool calls",
+                            style="dim green italic",
+                        )
+
+                    await self.show_assistant_message(message_text)
+
+                    # Process all tool calls and collect results
+                    tool_results = []
+                    for content in tool_uses:
                         tool_name = content.name
                         tool_args = content.input
                         tool_use_id = content.id
 
-                        await self.show_assistant_message(message_text, tool_name)
-
                         self.show_tool_call(available_tools, tool_name, tool_args)
                         tool_call_request = CallToolRequest(
                             method="tools/call",
@@ -227,20 +253,25 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                             request=tool_call_request, tool_call_id=tool_use_id
                         )
                         self.show_tool_result(result)
-                        messages.append(
-                            MessageParam(
-                                role="user",
-                                content=[
-                                    ToolResultBlockParam(
-                                        type="tool_result",
-                                        tool_use_id=tool_use_id,
-                                        content=result.content,
-                                        is_error=result.isError,
-                                    )
-                                ],
+
+                        # Add each result to our collection
+                        tool_results.append(
+                            ToolResultBlockParam(
+                                type="tool_result",
+                                tool_use_id=tool_use_id,
+                                content=result.content,
+                                is_error=result.isError,
                             )
                         )
 
+                    # Add all tool results in a single message
+                    messages.append(
+                        MessageParam(
+                            role="user",
+                            content=tool_results,
+                        )
+                    )
+
         if params.use_history:
             self.history.set(messages)
 

mcp_agent/workflows/parallel/parallel_llm.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, List, Optional, Type, TYPE_CHECKING
+from typing import Any, Callable, List, Optional, Type, TYPE_CHECKING, Union
 import asyncio
 
 from mcp_agent.agents.agent import Agent
@@ -28,15 +28,17 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
         fan_out_agents: List[Agent | AugmentedLLM],
         llm_factory: Callable[[Agent], AugmentedLLM] = None,
         context: Optional["Context"] = None,
+        include_request: bool = True,
         **kwargs,
     ):
         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: Agent | AugmentedLLM) -> AugmentedLLM:
+    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
@@ -65,9 +67,14 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
             *[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),
+            self._format_responses(responses, message_str),
             request_params=request_params,
         )
 
@@ -92,9 +99,14 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
             *[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),
+            self._format_responses(responses, message_str),
             request_params=request_params,
         )
 
@@ -123,19 +135,32 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
             ]
         )
 
+        # 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),
+            self._format_responses(responses, message_str),
             response_model=response_model,
             request_params=request_params,
         )
 
         return result
 
-    def _format_responses(self, responses: List[Any]) -> str:
+    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"Response from {agent_name}:\n{response}")
+            formatted.append(
+                f'<fastagent:response agent="{agent_name}">\n{response}\n</fastagent:response>'
+            )
         return "\n\n".join(formatted)