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

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

@@ -1,4 +1,4 @@
-# Byte-compiled / optimized / DLL files
+s# Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 *$py.class
@@ -197,6 +197,5 @@ tests/integration/prompt-state/history.json
 !tests/integration/api/fastagent.secrets.yaml
 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.24}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.22
+Version: 0.2.24
 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/
@@ -218,6 +218,7 @@ Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
 Requires-Dist: opentelemetry-instrumentation-anthropic>=0.39.3
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.3
 Requires-Dist: opentelemetry-instrumentation-openai>=0.39.3
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0

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

@@ -1,12 +1,11 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.22"
+version = "0.2.24"
 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",
@@ -32,6 +31,7 @@ dependencies = [
     "opentelemetry-instrumentation-openai>=0.39.3",
     "opentelemetry-instrumentation-anthropic>=0.39.3",
     "tensorzero>=2025.4.7",
+    "opentelemetry-instrumentation-mcp>=0.40.3",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.24}/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.24}/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.24/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.24}/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.24}/src/mcp_agent/context.py

@@ -11,6 +11,7 @@ from mcp import ServerSession
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+from opentelemetry.instrumentation.mcp import McpInstrumentor
 from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.sdk.resources import Resource
@@ -111,6 +112,7 @@ async def configure_otel(config: "Settings") -> None:
     trace.set_tracer_provider(tracer_provider)
     AnthropicInstrumentor().instrument()
     OpenAIInstrumentor().instrument()
+    McpInstrumentor().instrument()
 
 
 async def configure_logger(config: "Settings") -> None:

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.24}/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.24}/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.24}/src/mcp_agent/llm/providers/augmented_llm_openai.py

@@ -274,7 +274,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # Calculate new conversation messages (excluding prompts)
             new_messages = messages[len(prompt_messages) :]
 
-            # Update conversation history
+            if system_prompt:
+                new_messages = new_messages[1:]
+
             self.history.set(new_messages)
 
         self._log_chat_finished(model=self.default_request_params.model)

{fast_agent_mcp-0.2.22 → fast_agent_mcp-0.2.24}/src/mcp_agent/mcp/mcp_agent_client_session.py

@@ -6,21 +6,16 @@ It adds logging and supports sampling requests.
 from datetime import timedelta
 from typing import TYPE_CHECKING, Optional
 
-from mcp import ClientSession
+from mcp import ClientSession, ServerNotification
 from mcp.shared.session import (
-    ReceiveNotificationT,
     ReceiveResultT,
     RequestId,
     SendNotificationT,
     SendRequestT,
     SendResultT,
 )
-from mcp.types import (
-    ErrorData,
-    ListRootsResult,
-    Root,
-)
-from pydantic import AnyUrl
+from mcp.types import ErrorData, ListRootsResult, Root, ToolListChangedNotification
+from pydantic import FileUrl
 
 from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.logging.logger import get_logger
@@ -45,7 +40,7 @@ async def list_roots(ctx: ClientSession) -> ListRootsResult:
     ):
         roots = [
             Root(
-                uri=AnyUrl(
+                uri=FileUrl(
                     root.server_uri_alias or root.uri,
                 ),
                 name=root.name,
@@ -67,6 +62,11 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
     """
 
     def __init__(self, *args, **kwargs) -> None:
+        # Extract server_name if provided in kwargs
+        self.session_server_name = kwargs.pop("server_name", None)
+        # Extract the notification callbacks if provided
+        self._tool_list_changed_callback = kwargs.pop("tool_list_changed_callback", None)
+
         super().__init__(*args, **kwargs, list_roots_callback=list_roots, sampling_callback=sample)
         self.server_config: Optional[MCPServerSettings] = None
 
@@ -104,7 +104,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         )
         return await super()._send_response(request_id, response)
 
-    async def _received_notification(self, notification: ReceiveNotificationT) -> None:
+    async def _received_notification(self, notification: ServerNotification) -> None:
         """
         Can be overridden by subclasses to handle a notification without needing
         to listen on the message stream.
@@ -113,7 +113,37 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             "_received_notification: notification=",
             data=notification.model_dump(),
         )
-        return await super()._received_notification(notification)
+
+        # Call parent notification handler first
+        await super()._received_notification(notification)
+
+        # Then process our specific notification types
+        match notification.root:
+            case ToolListChangedNotification():
+                # Simple notification handling - just call the callback if it exists
+                if self._tool_list_changed_callback and self.session_server_name:
+                    logger.info(
+                        f"Tool list changed for server '{self.session_server_name}', triggering callback"
+                    )
+                    # Use asyncio.create_task to prevent blocking the notification handler
+                    import asyncio
+                    asyncio.create_task(self._handle_tool_list_change_callback(self.session_server_name))
+                else:
+                    logger.debug(
+                        f"Tool list changed for server '{self.session_server_name}' but no callback registered"
+                    )
+
+        return None
+
+    async def _handle_tool_list_change_callback(self, server_name: str) -> None:
+        """
+        Helper method to handle tool list change callback in a separate task
+        to prevent blocking the notification handler
+        """
+        try:
+            await self._tool_list_changed_callback(server_name)
+        except Exception as e:
+            logger.error(f"Error in tool list changed callback: {e}")
 
     async def send_progress_notification(
         self, progress_token: str | int, progress: float, total: float | None = None