fast-agent-mcp 0.2.22__tar.gz → 0.2.23__tar.gz

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/.gitignore

@@ -1,4 +1,4 @@
-# Byte-compiled / optimized / DLL files
+s# Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 *$py.class
@@ -200,3 +200,4 @@ fastagent.jsonl
 # JetBrains IDEs
 .idea/
 tests/e2e/smoke/base/weather_location.txt
+tests/integration/roots/fastagent.jsonl

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.22
+Version: 0.2.23
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
-Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
+Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/pyproject.toml

@@ -1,12 +1,11 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.22"
+version = "0.2.23"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
 authors = [
     { name = "Shaun Smith", email = "fastagent@llmindset.co.uk"},
-    { name = "Sarmad Qadri", email = "sarmad@lastmileai.dev" }
 ]
 classifiers = [
     "Programming Language :: Python :: 3",

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/agents/workflow/orchestrator_agent.py

@@ -229,7 +229,7 @@ class OrchestratorAgent(BaseAgent):
                     self.logger.warning(
                         f"Reached maximum step limit ({max_steps}) without completing objective"
                     )
-                    plan_result.max_steps_reached = True
+                    plan_result.max_iterations_reached = True
                     break
 
                 # Execute the step and collect results
@@ -239,7 +239,7 @@ class OrchestratorAgent(BaseAgent):
                 total_steps_executed += 1
 
             # Check if we need to break due to hitting max steps
-            if getattr(plan_result, "max_steps_reached", False):
+            if getattr(plan_result, "max_iterations_reached", False):
                 break
 
             # If the plan is marked complete, finalize the result

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/cli/commands/go.py

@@ -2,16 +2,18 @@
 
 import asyncio
 import sys
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import typer
 
+from mcp_agent.cli.commands.url_parser import generate_server_configs, parse_server_urls
 from mcp_agent.core.fastagent import FastAgent
 
 app = typer.Typer(
     help="Run an interactive agent directly from the command line without creating an agent.py file"
 )
 
+
 async def _run_agent(
     name: str = "FastAgent CLI",
     instruction: str = "You are a helpful AI Agent.",
@@ -19,33 +21,61 @@ async def _run_agent(
     server_list: Optional[List[str]] = None,
     model: Optional[str] = None,
     message: Optional[str] = None,
-    prompt_file: Optional[str] = None
+    prompt_file: Optional[str] = None,
+    url_servers: Optional[Dict[str, Dict[str, str]]] = None,
 ) -> None:
     """Async implementation to run an interactive agent."""
     from pathlib import Path
 
+    from mcp_agent.config import MCPServerSettings, MCPSettings
     from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
 
-    # Create the FastAgent instance with CLI arg parsing enabled
-    # It will automatically parse args like --model, --quiet, etc.
+    # Create the FastAgent instance
     fast_kwargs = {
         "name": name,
         "config_path": config_path,
         "ignore_unknown_args": True,
         "parse_cli_args": False,  # Don't parse CLI args, we're handling it ourselves
     }
-    
+
     fast = FastAgent(**fast_kwargs)
 
+    # Add URL-based servers to the context configuration
+    if url_servers:
+        # Initialize the app to ensure context is ready
+        await fast.app.initialize()
+
+        # Initialize mcp settings if needed
+        if not hasattr(fast.app.context.config, "mcp"):
+            fast.app.context.config.mcp = MCPSettings()
+
+        # Initialize servers dictionary if needed
+        if (
+            not hasattr(fast.app.context.config.mcp, "servers")
+            or fast.app.context.config.mcp.servers is None
+        ):
+            fast.app.context.config.mcp.servers = {}
+
+        # Add each URL server to the config
+        for server_name, server_config in url_servers.items():
+            server_settings = {"transport": server_config["transport"], "url": server_config["url"]}
+
+            # Add headers if present in the server config
+            if "headers" in server_config:
+                server_settings["headers"] = server_config["headers"]
+
+            fast.app.context.config.mcp.servers[server_name] = MCPServerSettings(**server_settings)
+
     # Define the agent with specified parameters
     agent_kwargs = {"instruction": instruction}
     if server_list:
         agent_kwargs["servers"] = server_list
     if model:
         agent_kwargs["model"] = model
-    
+
     # Handle prompt file and message options
     if message or prompt_file:
+
         @fast.agent(**agent_kwargs)
         async def cli_agent():
             async with fast.run() as agent:
@@ -55,7 +85,7 @@ async def _run_agent(
                     print(response)
                 elif prompt_file:
                     prompt = load_prompt_multipart(Path(prompt_file))
-                    response = await agent.generate(prompt)
+                    response = await agent.default.generate(prompt)
                     # Print the response text and exit
                     print(response.last_text())
     else:
@@ -68,18 +98,37 @@ async def _run_agent(
     # Run the agent
     await cli_agent()
 
+
 def run_async_agent(
-    name: str, 
-    instruction: str, 
-    config_path: Optional[str] = None, 
+    name: str,
+    instruction: str,
+    config_path: Optional[str] = None,
     servers: Optional[str] = None,
+    urls: Optional[str] = None,
+    auth: Optional[str] = None,
     model: Optional[str] = None,
     message: Optional[str] = None,
-    prompt_file: Optional[str] = None
+    prompt_file: Optional[str] = None,
 ):
     """Run the async agent function with proper loop handling."""
-    server_list = servers.split(',') if servers else None
-    
+    server_list = servers.split(",") if servers else None
+
+    # Parse URLs and generate server configurations if provided
+    url_servers = None
+    if urls:
+        try:
+            parsed_urls = parse_server_urls(urls, auth)
+            url_servers = generate_server_configs(parsed_urls)
+            # If we have servers from URLs, add their names to the server_list
+            if url_servers and not server_list:
+                server_list = list(url_servers.keys())
+            elif url_servers and server_list:
+                # Merge both lists
+                server_list.extend(list(url_servers.keys()))
+        except ValueError as e:
+            print(f"Error parsing URLs: {e}")
+            return
+
     # Check if we're already in an event loop
     try:
         loop = asyncio.get_event_loop()
@@ -92,24 +141,27 @@ def run_async_agent(
         # No event loop exists, so we'll create one
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-    
+
     try:
-        loop.run_until_complete(_run_agent(
-            name=name, 
-            instruction=instruction, 
-            config_path=config_path, 
-            server_list=server_list,
-            model=model,
-            message=message,
-            prompt_file=prompt_file
-        ))
+        loop.run_until_complete(
+            _run_agent(
+                name=name,
+                instruction=instruction,
+                config_path=config_path,
+                server_list=server_list,
+                model=model,
+                message=message,
+                prompt_file=prompt_file,
+                url_servers=url_servers,
+            )
+        )
     finally:
         try:
             # Clean up the loop
             tasks = asyncio.all_tasks(loop)
             for task in tasks:
                 task.cancel()
-            
+
             # Run the event loop until all tasks are done
             if sys.version_info >= (3, 7):
                 loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
@@ -118,6 +170,7 @@ def run_async_agent(
         except Exception:
             pass
 
+
 @app.callback(invoke_without_command=True)
 def go(
     ctx: typer.Context,
@@ -131,6 +184,12 @@ def go(
     servers: Optional[str] = typer.Option(
         None, "--servers", help="Comma-separated list of server names to enable from config"
     ),
+    urls: Optional[str] = typer.Option(
+        None, "--url", help="Comma-separated list of HTTP/SSE URLs to connect to"
+    ),
+    auth: Optional[str] = typer.Option(
+        None, "--auth", help="Bearer token for authorization with URL-based servers"
+    ),
     model: Optional[str] = typer.Option(
         None, "--model", help="Override the default model (e.g., haiku, sonnet, gpt-4)"
     ),
@@ -148,6 +207,8 @@ def go(
         fast-agent go --model=haiku --instruction="You are a coding assistant" --servers=fetch,filesystem
         fast-agent go --message="What is the weather today?" --model=haiku
         fast-agent go --prompt-file=my-prompt.txt --model=haiku
+        fast-agent go --url=http://localhost:8001/mcp,http://api.example.com/sse
+        fast-agent go --url=https://api.example.com/mcp --auth=YOUR_API_TOKEN
 
     This will start an interactive session with the agent, using the specified model
     and instruction. It will use the default configuration from fastagent.config.yaml
@@ -157,15 +218,19 @@ def go(
         --model               Override the default model (e.g., --model=haiku)
         --quiet               Disable progress display and logging
         --servers             Comma-separated list of server names to enable from config
+        --url                 Comma-separated list of HTTP/SSE URLs to connect to
+        --auth                Bearer token for authorization with URL-based servers
         --message, -m         Send a single message and exit
         --prompt-file, -p     Use a prompt file instead of interactive mode
     """
     run_async_agent(
-        name=name, 
-        instruction=instruction, 
-        config_path=config_path, 
+        name=name,
+        instruction=instruction,
+        config_path=config_path,
         servers=servers,
+        urls=urls,
+        auth=auth,
         model=model,
         message=message,
-        prompt_file=prompt_file
-    )
+        prompt_file=prompt_file,
+    )

fast_agent_mcp-0.2.23/src/mcp_agent/cli/commands/url_parser.py

@@ -0,0 +1,185 @@
+"""
+URL parsing utility for the fast-agent CLI.
+Provides functions to parse URLs and determine MCP server configurations.
+"""
+
+import hashlib
+import re
+from typing import Dict, List, Literal, Tuple
+from urllib.parse import urlparse
+
+
+def parse_server_url(
+    url: str,
+) -> Tuple[str, Literal["http", "sse"], str]:
+    """
+    Parse a server URL and determine the transport type and server name.
+
+    Args:
+        url: The URL to parse
+
+    Returns:
+        Tuple containing:
+        - server_name: A generated name for the server
+        - transport_type: Either "http" or "sse" based on URL
+        - url: The parsed and validated URL
+
+    Raises:
+        ValueError: If the URL is invalid or unsupported
+    """
+    # Basic URL validation
+    if not url:
+        raise ValueError("URL cannot be empty")
+
+    # Parse the URL
+    parsed_url = urlparse(url)
+
+    # Ensure scheme is present and is either http or https
+    if not parsed_url.scheme or parsed_url.scheme not in ("http", "https"):
+        raise ValueError(f"URL must have http or https scheme: {url}")
+
+    # Ensure netloc (hostname) is present
+    if not parsed_url.netloc:
+        raise ValueError(f"URL must include a hostname: {url}")
+
+    # Determine transport type based on URL path
+    transport_type: Literal["http", "sse"] = "http"
+    if parsed_url.path.endswith("/sse"):
+        transport_type = "sse"
+    elif not parsed_url.path.endswith("/mcp"):
+        # If path doesn't end with /mcp or /sse, append /mcp
+        url = url if url.endswith("/") else f"{url}/"
+        url = f"{url}mcp"
+
+    # Generate a server name based on hostname and port
+    server_name = generate_server_name(url)
+
+    return server_name, transport_type, url
+
+
+def generate_server_name(url: str) -> str:
+    """
+    Generate a unique and readable server name from a URL.
+
+    Args:
+        url: The URL to generate a name for
+
+    Returns:
+        A server name string
+    """
+    parsed_url = urlparse(url)
+
+    # Extract hostname and port
+    hostname = parsed_url.netloc.split(":")[0]
+
+    # Clean the hostname for use in a server name
+    # Replace non-alphanumeric characters with underscores
+    clean_hostname = re.sub(r"[^a-zA-Z0-9]", "_", hostname)
+
+    if len(clean_hostname) > 15:
+        clean_hostname = clean_hostname[:9] + clean_hostname[-5:]
+
+    # If it's localhost or an IP, add a more unique identifier
+    if clean_hostname in ("localhost", "127_0_0_1") or re.match(r"^(\d+_){3}\d+$", clean_hostname):
+        # Use the path as part of the name for uniqueness
+        path = parsed_url.path.strip("/")
+        path = re.sub(r"[^a-zA-Z0-9]", "_", path)
+
+        # Include port if specified
+        port = ""
+        if ":" in parsed_url.netloc:
+            port = f"_{parsed_url.netloc.split(':')[1]}"
+
+        if path:
+            return f"{clean_hostname}{port}_{path[:20]}"  # Limit path length
+        else:
+            # Use a hash if no path for uniqueness
+            url_hash = hashlib.md5(url.encode()).hexdigest()[:8]
+            return f"{clean_hostname}{port}_{url_hash}"
+
+    return clean_hostname
+
+
+def parse_server_urls(
+    urls_param: str, auth_token: str = None
+) -> List[Tuple[str, Literal["http", "sse"], str, Dict[str, str] | None]]:
+    """
+    Parse a comma-separated list of URLs into server configurations.
+
+    Args:
+        urls_param: Comma-separated list of URLs
+        auth_token: Optional bearer token for authorization
+
+    Returns:
+        List of tuples containing (server_name, transport_type, url, headers)
+
+    Raises:
+        ValueError: If any URL is invalid
+    """
+    if not urls_param:
+        return []
+
+    # Split by comma and strip whitespace
+    url_list = [url.strip() for url in urls_param.split(",")]
+
+    # Prepare headers if auth token is provided
+    headers = None
+    if auth_token:
+        headers = {"Authorization": f"Bearer {auth_token}"}
+
+    # Parse each URL
+    result = []
+    for url in url_list:
+        server_name, transport_type, parsed_url = parse_server_url(url)
+        result.append((server_name, transport_type, parsed_url, headers))
+
+    return result
+
+
+def generate_server_configs(
+    parsed_urls: List[Tuple[str, Literal["http", "sse"], str, Dict[str, str] | None]],
+) -> Dict[str, Dict[str, str | Dict[str, str]]]:
+    """
+    Generate server configurations from parsed URLs.
+
+    Args:
+        parsed_urls: List of tuples containing (server_name, transport_type, url, headers)
+
+    Returns:
+        Dictionary of server configurations
+    """
+    server_configs = {}
+    # Keep track of server name occurrences to handle collisions
+    name_counts = {}
+
+    for server_name, transport_type, url, headers in parsed_urls:
+        # Handle name collisions by adding a suffix
+        final_name = server_name
+        if server_name in server_configs:
+            # Initialize counter if we haven't seen this name yet
+            if server_name not in name_counts:
+                name_counts[server_name] = 1
+
+            # Generate a new name with suffix
+            suffix = name_counts[server_name]
+            final_name = f"{server_name}_{suffix}"
+            name_counts[server_name] += 1
+
+            # Ensure the new name is also unique
+            while final_name in server_configs:
+                suffix = name_counts[server_name]
+                final_name = f"{server_name}_{suffix}"
+                name_counts[server_name] += 1
+
+        config = {
+            "transport": transport_type,
+            "url": url,
+        }
+
+        # Add headers if provided
+        if headers:
+            config["headers"] = headers
+
+        server_configs[final_name] = config
+
+    return server_configs

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/config.py

@@ -60,7 +60,7 @@ class MCPServerSettings(BaseModel):
     description: str | None = None
     """The description of the server."""
 
-    transport: Literal["stdio", "sse"] = "stdio"
+    transport: Literal["stdio", "sse", "http"] = "stdio"
     """The transport mechanism."""
 
     command: str | None = None
@@ -249,6 +249,8 @@ class LoggerSettings(BaseModel):
     """Show MCP Sever tool calls on the console"""
     truncate_tools: bool = True
     """Truncate display of long tool calls"""
+    enable_markup: bool = True
+    """Enable markup in console output. Disable for outputs that may conflict with rich console formatting"""
 
 
 class Settings(BaseSettings):

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/core/fastagent.py

@@ -131,8 +131,8 @@ class FastAgent:
             )
             parser.add_argument(
                 "--transport",
-                choices=["sse", "stdio"],
-                default="sse",
+                choices=["sse", "http", "stdio"],
+                default="http",
                 help="Transport protocol to use when running as a server (sse or stdio)",
             )
             parser.add_argument(

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/core/request_params.py

@@ -25,24 +25,23 @@ class RequestParams(CreateMessageRequestParams):
 
     model: str | None = None
     """
-    The model to use for the LLM generation.
+    The model to use for the LLM generation. This can only be set during Agent creation.
     If specified, this overrides the 'modelPreferences' selection criteria.
     """
 
     use_history: bool = True
     """
-    Include the message history in the generate request.
+    Agent/LLM maintains conversation history. Does not include applied Prompts
     """
 
-    max_iterations: int = 10
+    max_iterations: int = 20
     """
-    The maximum number of iterations to run the LLM for.
+    The maximum number of tool calls allowed in a conversation turn
     """
 
     parallel_tool_calls: bool = True
     """
-    Whether to allow multiple tool calls per iteration.
-    Also known as multi-step tool use.
+    Whether to allow simultaneous tool calls
     """
     response_format: Any | None = None
     """

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/mcp/mcp_connection_manager.py

@@ -23,6 +23,7 @@ from mcp.client.stdio import (
     get_default_environment,
     stdio_client,
 )
+from mcp.client.streamable_http import GetSessionIdCallback, streamablehttp_client
 from mcp.types import JSONRPCMessage, ServerCapabilities
 
 from mcp_agent.config import MCPServerSettings
@@ -40,6 +41,27 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+class StreamingContextAdapter:
+    """Adapter to provide a 3-value context from a 2-value context manager"""
+
+    def __init__(self, context_manager):
+        self.context_manager = context_manager
+        self.cm_instance = None
+
+    async def __aenter__(self):
+        self.cm_instance = await self.context_manager.__aenter__()
+        read_stream, write_stream = self.cm_instance
+        return read_stream, write_stream, None
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self.context_manager.__aexit__(exc_type, exc_val, exc_tb)
+
+
+def _add_none_to_context(context_manager):
+    """Helper to add a None value to context managers that return 2 values instead of 3"""
+    return StreamingContextAdapter(context_manager)
+
+
 class ServerConnection:
     """
     Represents a long-lived MCP server connection, including:
@@ -57,6 +79,7 @@ class ServerConnection:
                 tuple[
                     MemoryObjectReceiveStream[JSONRPCMessage | Exception],
                     MemoryObjectSendStream[JSONRPCMessage],
+                    GetSessionIdCallback | None,
                 ],
                 None,
             ],
@@ -162,7 +185,7 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
     try:
         transport_context = server_conn._transport_context_factory()
 
-        async with transport_context as (read_stream, write_stream):
+        async with transport_context as (read_stream, write_stream, _):
             server_conn.create_session(read_stream, write_stream)
 
             async with server_conn.session:
@@ -303,14 +326,17 @@ class MCPConnectionManager(ContextDependent):
                 error_handler = get_stderr_handler(server_name)
                 # Explicitly ensure we're using our custom logger for stderr
                 logger.debug(f"{server_name}: Creating stdio client with custom error handler")
-                return stdio_client(server_params, errlog=error_handler)
+                return _add_none_to_context(stdio_client(server_params, errlog=error_handler))
             elif config.transport == "sse":
-                return sse_client(
-                    config.url,
-                    config.headers,
-                    sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                return _add_none_to_context(
+                    sse_client(
+                        config.url,
+                        config.headers,
+                        sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                    )
                 )
-
+            elif config.transport == "http":
+                return streamablehttp_client(config.url, config.headers)
             else:
                 raise ValueError(f"Unsupported transport: {config.transport}")
 

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.23}/src/mcp_agent/mcp/prompts/prompt_server.py

@@ -335,7 +335,7 @@ def parse_args():
     parser.add_argument(
         "--transport",
         type=str,
-        choices=["stdio", "sse"],
+        choices=["stdio", "sse", "http"],
         default="stdio",
         help="Transport to use (default: stdio)",
     )
@@ -502,14 +502,22 @@ async def async_main() -> int:
         return await test_prompt(args.test, config)
 
     # Start the server with the specified transport
-    if config.transport == "stdio":
-        await mcp.run_stdio_async()
-    else:  # sse
+    if config.transport == "sse":  # sse
         # Set the host and port in settings before running the server
         mcp.settings.host = config.host
         mcp.settings.port = config.port
         logger.info(f"Starting SSE server on {config.host}:{config.port}")
         await mcp.run_sse_async()
+    elif config.transport == "http":
+        mcp.settings.host = config.host
+        mcp.settings.port = config.port
+        logger.info(f"Starting SSE server on {config.host}:{config.port}")
+        await mcp.run_streamable_http_async()
+    elif config.transport == "stdio":
+        await mcp.run_stdio_async()
+    else:
+        logger.error(f"Unknown transport: {config.transport}")
+        return 1
     return 0