fast-agent-mcp 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

mcp_agent/mcp/stdio.py

@@ -9,10 +9,12 @@ 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 1.4.2 is released
 @asynccontextmanager
 async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     """
@@ -22,10 +24,16 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     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(),
@@ -67,19 +75,19 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
         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 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"
@@ -87,6 +95,7 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
             async with write_stream_reader:
                 async for message in write_stream_reader:
                     json = message.model_dump_json(by_alias=True, exclude_none=True)
+                    print(f"**********{id(process.stdin)}")
                     await process.stdin.send(
                         (json + "\n").encode(
                             encoding=server.encoding,
@@ -100,5 +109,4 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     async with anyio.create_task_group() as tg, process:
         tg.start_soon(stdout_reader)
         tg.start_soon(stdin_writer)
-        tg.start_soon(stderr_reader)
         yield read_stream, write_stream

mcp_agent/mcp_server_registry.py

@@ -15,9 +15,9 @@ from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStre
 from mcp import ClientSession
 from mcp.client.stdio import (
     StdioServerParameters,
-    stdio_client,
     get_default_environment,
 )
+from mcp_agent.mcp.stdio import stdio_client_with_rich_stderr
 from mcp.client.sse import sse_client
 
 from mcp_agent.config import (
@@ -134,7 +134,10 @@ class ServerRegistry:
                 env={**get_default_environment(), **(config.env or {})},
             )
 
-            async with stdio_client(server_params) as (read_stream, write_stream):
+            async with stdio_client_with_rich_stderr(server_params) as (
+                read_stream,
+                write_stream,
+            ):
                 session = client_session_factory(
                     read_stream,
                     write_stream,

mcp_agent/resources/examples/internal/agent.py

@@ -10,7 +10,7 @@ fast = FastAgent("FastAgent Example")
 async def main():
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:
-        await agent()
+        await agent.prompt()
 
 
 if __name__ == "__main__":

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

@@ -44,9 +44,9 @@ mcp:
       # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js"]
       command: "npx"
       args: ["-y", "@modelcontextprotocol/server-brave-search"]
-    sizer:
+    sizing_setup:
       command: "uv"
-      args: ["run", "prompt_sizing.py"]
+      args: ["run", "prompt_sizing1.py"]
     category:
       command: "uv"
       args: ["run", "prompt_category.py"]

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/workflows/orchestrator.py

@@ -50,9 +50,9 @@ fast = FastAgent("Orchestrator-Workers")
 async def main():
     async with fast.run() as agent:
         await agent()
-#        await agent.author(
-#            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-#        )
+        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/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)