fast-agent-mcp 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mcp_agent/resources/examples/internal/sizer.py

@@ -12,11 +12,6 @@ fast = FastAgent("Sizer Prompt Test")
 )
 async def main():
     async with fast.run() as agent:
-        # await agent["sizer"].load_prompt("sizing_prompt_units", {"metric": "False"})
-        # print(await agent["sizer"].load_prompt("category-category_prompt"))
-        #        await agent("What is the size of the moon?")
-        #        await agent("What is the size of the Earth?")
-        #        await agent("What is the size of the Sun?")
         await agent()
 
 

mcp_agent/resources/examples/prompting/__init__.py

@@ -0,0 +1,3 @@
+"""
+Prompting examples package for MCP Agent.
+"""

mcp_agent/resources/examples/prompting/agent.py

@@ -0,0 +1,23 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("FastAgent Example")
+
+
+# Define the agent
+@fast.agent(
+    "agent",
+    instruction="You are a helpful AI Agent",
+    servers=["prompts"],  # , "imgetage", "hfspace"],
+    #    model="gpt-4o",
+    #    instruction="You are a helpful AI Agent", servers=["prompts","basic_memory"], model="haiku"
+)
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/prompting/fastagent.config.yaml

@@ -0,0 +1,44 @@
+# FastAgent Configuration File
+
+# Default Model Configuration:
+#
+# Takes format:
+#   <provider>.<model_string>.<reasoning_effort?> (e.g. anthropic.claude-3-5-sonnet-20241022 or openai.o3-mini.low)
+# Accepts aliases for Anthropic Models: haiku, haiku3, sonnet, sonnet35, opus, opus3
+# and OpenAI Models: gpt-4o-mini, gpt-4o, o1, o1-mini, o3-mini
+#
+# If not specified, defaults to "haiku".
+# Can be overriden with a command line switch --model=<model>, or within the Agent constructor.
+
+default_model: haiku
+
+# Logging and Console Configuration:
+logger:
+  # level: "debug" | "info" | "warning" | "error"
+  # type: "none" | "console" | "file" | "http"
+  # path: "/path/to/logfile.jsonl"
+  type: file
+  level: error
+  # Switch the progress display on or off
+  progress_display: true
+
+  # Show chat User/Assistant messages on the console
+  show_chat: true
+  # Show tool calls on the console
+  show_tools: true
+  # Truncate long tool responses on the console
+  truncate_tools: true
+
+# MCP Servers
+mcp:
+  servers:
+    prompts:
+      command: "prompt-server"
+      args: ["sizing.md", "resource.md","resource-exe.md","pdf_prompt.md"]
+    hfspace:
+      command: "npx"
+      args: ["@llmindset/mcp-hfspace"]
+    image:
+      command: "uv"
+      args: ["run", "image_server.py"]
+

mcp_agent/resources/examples/prompting/image_server.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Simple MCP server that responds to tool calls with text and image content.
+"""
+
+import logging
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP, Context, Image
+from mcp.types import TextContent, ImageContent
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create the FastMCP server
+app = FastMCP(name="ImageToolServer", debug=True)
+
+
+@app.tool(name="get_image", description="Returns an image with a descriptive text")
+async def get_image(
+    image_name: str = "default", ctx: Context = None
+) -> list[TextContent | ImageContent]:
+    """
+    Returns an image file along with a descriptive text.
+
+    Args:
+        image_name: Name of the image to return (default just returns image.jpg)
+
+    Returns:
+        A list containing a text message and the requested image
+    """
+    try:
+        # Read the image file and convert to base64
+        # Create the response with text and image
+        return [
+            TextContent(type="text", text="Here's your image:"),
+            Image(path="image.jpg").to_image_content(),
+        ]
+    except Exception as e:
+        logger.exception(f"Error processing image: {e}")
+        return [TextContent(type="text", text=f"Error processing image: {str(e)}")]
+
+
+if __name__ == "__main__":
+    # Check if the default image exists
+    if not Path("image.jpg").exists():
+        logger.warning(
+            "Default image file 'image.jpg' not found in the current directory"
+        )
+        logger.warning(
+            "Please add an image file named 'image.jpg' to the current directory"
+        )
+
+    # Run the server using stdio transport
+    app.run(transport="stdio")

mcp_agent/resources/examples/researcher/researcher-eval.py

@@ -2,7 +2,7 @@ import asyncio
 
 from mcp_agent.core.fastagent import FastAgent
 
-agents = FastAgent(name="Researcher")
+agents = FastAgent(name="Researcher Agent (EO)")
 
 
 @agents.agent(

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -45,13 +45,14 @@ fast = FastAgent("Orchestrator-Workers")
 @fast.orchestrator(
     name="orchestrate",
     agents=["finder", "writer", "proofreader"],
-    plan_type="full",
+    plan_type="iterative",
 )
 async def main():
     async with fast.run() as agent:
-        await agent.author(
-            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-        )
+        await agent()
+#        await agent.author(
+#            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
+#        )
 
         # The orchestrator can be used just like any other agent
         task = (

mcp_agent/resources/examples/workflows/router.py

@@ -25,7 +25,6 @@ SAMPLE_REQUESTS = [
     name="fetcher",
     instruction="""You are an agent, with a tool enabling you to fetch URLs.""",
     servers=["fetch"],
-    model="haiku",
 )
 @fast.agent(
     name="code_expert",
@@ -33,7 +32,6 @@ SAMPLE_REQUESTS = [
     When asked about code, architecture, or development practices,
     you provide thorough and practical insights.""",
     servers=["filesystem"],
-    model="gpt-4o",
 )
 @fast.agent(
     name="general_assistant",

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -12,6 +12,7 @@ from mcp_agent.workflows.llm.augmented_llm import (
 )
 from mcp_agent.agents.agent import Agent, AgentConfig
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -89,45 +90,33 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         evaluator: str | Agent | AugmentedLLM,
         min_rating: QualityRating = QualityRating.GOOD,
         max_refinements: int = 3,
-        llm_factory: Callable[[Agent], AugmentedLLM]
-        | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
+        llm_factory: Callable[[Agent], AugmentedLLM] | None = None,
         context: Optional["Context"] = None,
-        name: Optional[str] = None,  # Allow overriding the name
-        instruction: Optional[str] = None,  # Allow overriding the instruction
+        name: Optional[str] = None,
+        instruction: Optional[str] = None,
     ):
         """
         Initialize the evaluator-optimizer workflow.
 
         Args:
-            generator: The agent/LLM/workflow that generates responses. Can be:
-                     - An Agent that will be converted to an AugmentedLLM
-                     - An AugmentedLLM instance
-                     - An Orchestrator/Router/ParallelLLM workflow
-            evaluator_agent: The agent/LLM that evaluates responses
-            evaluation_criteria: Criteria for the evaluator to assess responses
+            generator: The agent/LLM/workflow that generates responses
+            evaluator: The evaluator (string instruction, Agent or AugmentedLLM)
             min_rating: Minimum acceptable quality rating
             max_refinements: Maximum refinement iterations
-            llm_factory: Optional factory to create LLMs from agents
+            llm_factory: Factory to create LLMs from agents when needed
             name: Optional name for the workflow (defaults to generator's name)
             instruction: Optional instruction (defaults to generator's instruction)
-
-        Note on History Management:
-            This workflow manages two distinct history contexts:
-            1. Generator History: Controlled by the generator's use_history setting. When False,
-               each refinement iteration starts fresh without previous context.
-            2. Evaluator History: Always disabled as each evaluation should be independent
-               and based solely on the current response.
         """
-        # Set up initial instance attributes - allow name override
-        self.name = name or generator.name
+        # Set initial attributes
+        self.name = name or getattr(generator, "name", "EvaluatorOptimizer")
         self.llm_factory = llm_factory
         self.generator = generator
         self.evaluator = evaluator
         self.min_rating = min_rating
         self.max_refinements = max_refinements
 
-        # Determine generator's history setting before super().__init__
-
+        # Determine generator's history setting directly based on type
+        self.generator_use_history = False
         if isinstance(generator, Agent):
             self.generator_use_history = generator.config.use_history
         elif isinstance(generator, AugmentedLLM):
@@ -135,90 +124,55 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                 generator.aggregator, Agent
             ):
                 self.generator_use_history = generator.aggregator.config.use_history
-            else:
+            elif hasattr(generator, "default_request_params"):
                 self.generator_use_history = getattr(
-                    generator,
-                    "use_history",
-                    getattr(generator.default_request_params, "use_history", False),
+                    generator.default_request_params, "use_history", False
                 )
-        # Handle ChainProxy with type checking
-        elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
-            # This is how we detect a ChainProxy without directly importing it
-            # For ChainProxy, we'll default use_history to False
-            self.generator_use_history = False
-        else:
-            raise ValueError(f"Unsupported optimizer type: {type(generator)}")
-
-        # Now we can call super().__init__ which will use generator_use_history
-        super().__init__(context=context, name=name or generator.name)
+        # All other types default to False
 
-        # Add a PassthroughLLM as _llm property for compatibility with Orchestrator
-        from mcp_agent.workflows.llm.augmented_llm import PassthroughLLM
+        # Initialize parent class
+        super().__init__(context=context, name=name or getattr(generator, "name", None))
 
+        # Create a PassthroughLLM as _llm property
+        # TODO -- remove this when we fix/remove the inheritance hierarchy
         self._llm = PassthroughLLM(name=f"{self.name}_passthrough", context=context)
 
-        # Set up the generator
-
+        # Set up the generator based on type
         if isinstance(generator, Agent):
             if not llm_factory:
-                raise ValueError("llm_factory is required when using an Agent")
-
-            # Only create new LLM if agent doesn't have one
-            if hasattr(generator, "_llm") and generator._llm:
-                self.generator_llm = generator._llm
-            else:
-                self.generator_llm = llm_factory(agent=generator)
+                raise ValueError(
+                    "llm_factory is required when using an Agent generator"
+                )
 
+            # Use existing LLM if available, otherwise create new one
+            self.generator_llm = getattr(generator, "_llm", None) or llm_factory(
+                agent=generator
+            )
             self.aggregator = generator
-            self.instruction = (
-                instruction  # Use provided instruction if any
-                or (
-                    generator.instruction
-                    if isinstance(generator.instruction, str)
-                    else None
-                )  # Fallback to generator's
+            self.instruction = instruction or (
+                generator.instruction
+                if isinstance(generator.instruction, str)
+                else None
             )
-        elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
-            # For ChainProxy, use it directly for generation
+        elif isinstance(generator, AugmentedLLM):
+            self.generator_llm = generator
+            self.aggregator = getattr(generator, "aggregator", None)
+            self.instruction = instruction or generator.instruction
+        else:
+            # ChainProxy-like object
             self.generator_llm = generator
             self.aggregator = None
             self.instruction = (
                 instruction or f"Chain of agents: {', '.join(generator._sequence)}"
             )
 
-        elif isinstance(generator, AugmentedLLM):
-            self.generator_llm = generator
-            self.aggregator = generator.aggregator
-            self.instruction = generator.instruction
-
-        # Set up the evaluator - evaluations should be independent, so history is always disabled
-        if isinstance(evaluator, AugmentedLLM):
-            self.evaluator_llm = evaluator
-            # Override evaluator's history setting
-            if hasattr(evaluator, "default_request_params"):
-                evaluator.default_request_params.use_history = False
-        elif isinstance(evaluator, Agent):
-            if not llm_factory:
-                raise ValueError(
-                    "llm_factory is required when using an Agent evaluator"
-                )
-
-            # Create evaluator with history disabled
-            if hasattr(evaluator, "_llm") and evaluator._llm:
-                self.evaluator_llm = evaluator._llm
-                if hasattr(self.evaluator_llm, "default_request_params"):
-                    self.evaluator_llm.default_request_params.use_history = False
-            else:
-                # Force history off in config before creating LLM
-                evaluator.config.use_history = False
-                self.evaluator_llm = llm_factory(agent=evaluator)
-        elif isinstance(evaluator, str):
+        # Set up the evaluator - always disable history
+        if isinstance(evaluator, str):
             if not llm_factory:
                 raise ValueError(
                     "llm_factory is required when using a string evaluator"
                 )
 
-            # Create evaluator agent with history disabled
             evaluator_agent = Agent(
                 name="Evaluator",
                 instruction=evaluator,
@@ -226,17 +180,33 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                     name="Evaluator",
                     instruction=evaluator,
                     servers=[],
-                    use_history=False,  # Force history off for evaluator
+                    use_history=False,
                 ),
             )
             self.evaluator_llm = llm_factory(agent=evaluator_agent)
+        elif isinstance(evaluator, Agent):
+            if not llm_factory:
+                raise ValueError(
+                    "llm_factory is required when using an Agent evaluator"
+                )
+
+            # Disable history and use/create LLM
+            evaluator.config.use_history = False
+            self.evaluator_llm = getattr(evaluator, "_llm", None) or llm_factory(
+                agent=evaluator
+            )
+        elif isinstance(evaluator, AugmentedLLM):
+            self.evaluator_llm = evaluator
+            # Ensure history is disabled
+            if hasattr(self.evaluator_llm, "default_request_params"):
+                self.evaluator_llm.default_request_params.use_history = False
         else:
             raise ValueError(f"Unsupported evaluator type: {type(evaluator)}")
 
-        # Track iteration history (for the workflow itself)
+        # Track iteration history
         self.refinement_history = []
 
-        # Set up workflow's default params based on generator's history setting
+        # Set up workflow's default params
         self.default_request_params = self._initialize_default_params({})
 
         # Ensure evaluator's request params have history disabled

mcp_agent/workflows/llm/anthropic_utils.py

@@ -0,0 +1,101 @@
+"""
+Utility functions for Anthropic integration with MCP.
+
+Provides conversion between Anthropic message formats and PromptMessageMultipart,
+leveraging existing code for resource handling and delimited formats.
+"""
+
+from anthropic.types import (
+    MessageParam,
+)
+
+from mcp.types import (
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    TextResourceContents,
+)
+
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+
+# TODO -- only used for saving, but this will be driven directly from PromptMessages
+def anthropic_message_param_to_prompt_message_multipart(
+    message_param: MessageParam,
+) -> PromptMessageMultipart:
+    """
+    Convert an Anthropic MessageParam to a PromptMessageMultipart.
+
+    Args:
+        message_param: The Anthropic MessageParam to convert
+
+    Returns:
+        A PromptMessageMultipart representation
+    """
+    role = message_param["role"]
+    content = message_param["content"]
+
+    # Handle string content (user messages can be simple strings)
+    if isinstance(content, str):
+        return PromptMessageMultipart(
+            role=role, content=[TextContent(type="text", text=content)]
+        )
+
+    # Convert content blocks to MCP content types
+    mcp_contents = []
+
+    for block in content:
+        if isinstance(block, dict):
+            if block.get("type") == "text":
+                text = block.get("text", "")
+
+                # Check if this is a resource marker
+                if (
+                    text
+                    and (
+                        text.startswith("[Resource:")
+                        or text.startswith("[Binary Resource:")
+                    )
+                    and "\n" in text
+                ):
+                    header, content_text = text.split("\n", 1)
+                    if "MIME:" in header:
+                        mime_match = header.split("MIME:", 1)[1].split("]")[0].strip()
+                        if (
+                            mime_match != "text/plain"
+                        ):  # Only process non-plain text resources
+                            if (
+                                "Resource:" in header
+                                and "Binary Resource:" not in header
+                            ):
+                                uri = (
+                                    header.split("Resource:", 1)[1]
+                                    .split(",")[0]
+                                    .strip()
+                                )
+                                mcp_contents.append(
+                                    EmbeddedResource(
+                                        type="resource",
+                                        resource=TextResourceContents(
+                                            uri=uri,
+                                            mimeType=mime_match,
+                                            text=content_text,
+                                        ),
+                                    )
+                                )
+                                continue
+
+                # Regular text content
+                mcp_contents.append(TextContent(type="text", text=text))
+
+            elif block.get("type") == "image":
+                # Image content
+                source = block.get("source", {})
+                if isinstance(source, dict) and source.get("type") == "base64":
+                    media_type = source.get("media_type", "image/png")
+                    data = source.get("data", "")
+                    mcp_contents.append(
+                        ImageContent(type="image", data=data, mimeType=media_type)
+                    )
+
+    return PromptMessageMultipart(role=role, content=mcp_contents)