fast-agent-mcp 0.2.20__py3-none-any.whl → 0.2.22__py3-none-any.whl

mcp_agent/mcp/mcp_aggregator.py

@@ -41,10 +41,12 @@ SEP = "-"
 T = TypeVar("T")
 R = TypeVar("R")
 
+
 def create_namespaced_name(server_name: str, resource_name: str) -> str:
     """Create a namespaced resource name from server and resource names"""
     return f"{server_name}{SEP}{resource_name}"
 
+
 def is_namespaced_name(name: str) -> bool:
     """Check if a name is already namespaced"""
     return SEP in name
@@ -325,14 +327,14 @@ class MCPAggregator(ContextDependent):
         except Exception as e:
             logger.debug(f"Error getting capabilities for server '{server_name}': {e}")
             return None
-            
+
     async def validate_server(self, server_name: str) -> bool:
         """
         Validate that a server exists in our server list.
-        
+
         Args:
             server_name: Name of the server to validate
-            
+
         Returns:
             True if the server exists, False otherwise
         """
@@ -340,25 +342,25 @@ class MCPAggregator(ContextDependent):
         if not valid:
             logger.debug(f"Server '{server_name}' not found")
         return valid
-    
+
     async def server_supports_feature(self, server_name: str, feature: str) -> bool:
         """
         Check if a server supports a specific feature.
-        
+
         Args:
             server_name: Name of the server to check
             feature: Feature to check for (e.g., "prompts", "resources")
-            
+
         Returns:
             True if the server supports the feature, False otherwise
         """
         if not await self.validate_server(server_name):
             return False
-            
+
         capabilities = await self.get_capabilities(server_name)
         if not capabilities:
             return False
-            
+
         return getattr(capabilities, feature, False)
 
     async def list_servers(self) -> List[str]:
@@ -465,26 +467,26 @@ class MCPAggregator(ContextDependent):
         if resource_type == "tool" and name in self._namespaced_tool_map:
             namespaced_tool = self._namespaced_tool_map[name]
             return namespaced_tool.server_name, namespaced_tool.tool.name
-            
+
         # Next, attempt to interpret as a namespaced name
         if is_namespaced_name(name):
             parts = name.split(SEP, 1)
             server_name, local_name = parts[0], parts[1]
-            
+
             # Validate that the parsed server actually exists
             if server_name in self.server_names:
                 return server_name, local_name
-            
+
             # If the server name doesn't exist, it might be a tool with a hyphen in its name
             # Fall through to the next checks
-            
+
         # For tools, search all servers for the tool by exact name match
         if resource_type == "tool":
             for server_name, tools in self._server_to_tool_map.items():
                 for namespaced_tool in tools:
                     if namespaced_tool.tool.name == name:
                         return server_name, name
-                        
+
         # For all other resource types, use the first server
         return (self.server_names[0] if self.server_names else None, name)
 
@@ -524,7 +526,10 @@ class MCPAggregator(ContextDependent):
                 operation_type="tool",
                 operation_name=local_tool_name,
                 method_name="call_tool",
-                method_args={"name": local_tool_name, "arguments": arguments},
+                method_args={
+                    "name": local_tool_name,
+                    "arguments": arguments,
+                },
                 error_factory=lambda msg: CallToolResult(
                     isError=True, content=[TextContent(type="text", text=msg)]
                 ),
@@ -558,7 +563,7 @@ class MCPAggregator(ContextDependent):
         elif is_namespaced_name(prompt_name):
             parts = prompt_name.split(SEP, 1)
             potential_server = parts[0]
-            
+
             # Only treat as namespaced if the server part is valid
             if potential_server in self.server_names:
                 server_name = potential_server
@@ -570,7 +575,7 @@ class MCPAggregator(ContextDependent):
         else:
             local_prompt_name = prompt_name
             # We'll search all servers below
-        
+
         # If we have a specific server to check
         if server_name:
             if not await self.validate_server(server_name):
@@ -579,7 +584,7 @@ class MCPAggregator(ContextDependent):
                     description=f"Error: Server '{server_name}' not found",
                     messages=[],
                 )
-                
+
             # Check if server supports prompts
             if not await self.server_supports_feature(server_name, "prompts"):
                 logger.debug(f"Server '{server_name}' does not support prompts")

mcp_agent/mcp/mcp_connection_manager.py

@@ -15,6 +15,7 @@ from typing import (
 
 from anyio import Event, Lock, create_task_group
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from httpx import HTTPStatusError
 from mcp import ClientSession
 from mcp.client.sse import sse_client
 from mcp.client.stdio import (
@@ -162,14 +163,26 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
         transport_context = server_conn._transport_context_factory()
 
         async with transport_context as (read_stream, write_stream):
-            #      try:
             server_conn.create_session(read_stream, write_stream)
 
             async with server_conn.session:
                 await server_conn.initialize_session()
-
                 await server_conn.wait_for_shutdown_request()
 
+    except HTTPStatusError as http_exc:
+        logger.error(
+            f"{server_name}: Lifecycle task encountered HTTP error: {http_exc}",
+            exc_info=True,
+            data={
+                "progress_action": ProgressAction.FATAL_ERROR,
+                "server_name": server_name,
+            },
+        )
+        server_conn._error_occurred = True
+        server_conn._error_message = f"HTTP Error: {http_exc.response.status_code} {http_exc.response.reason_phrase} for URL: {http_exc.request.url}"
+        server_conn._initialized_event.set()
+        # No raise - let get_server handle it with a friendly message
+
     except Exception as exc:
         logger.error(
             f"{server_name}: Lifecycle task encountered an error: {exc}",
@@ -180,7 +193,27 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
             },
         )
         server_conn._error_occurred = True
-        server_conn._error_message = traceback.format_exception(exc)
+
+        if "ExceptionGroup" in type(exc).__name__ and hasattr(exc, "exceptions"):
+            # Handle ExceptionGroup better by extracting the actual errors
+            error_messages = []
+            for subexc in exc.exceptions:
+                if isinstance(subexc, HTTPStatusError):
+                    # Special handling for HTTP errors to make them more user-friendly
+                    error_messages.append(
+                        f"HTTP Error: {subexc.response.status_code} {subexc.response.reason_phrase} for URL: {subexc.request.url}"
+                    )
+                else:
+                    error_messages.append(f"Error: {type(subexc).__name__}: {subexc}")
+                if hasattr(subexc, "__cause__") and subexc.__cause__:
+                    error_messages.append(
+                        f"Caused by: {type(subexc.__cause__).__name__}: {subexc.__cause__}"
+                    )
+            server_conn._error_message = error_messages
+        else:
+            # For regular exceptions, keep the traceback but format it more cleanly
+            server_conn._error_message = traceback.format_exception(exc)
+
         # If there's an error, we should also set the event so that
         # 'get_server' won't hang
         server_conn._initialized_event.set()
@@ -277,6 +310,7 @@ class MCPConnectionManager(ContextDependent):
                     config.headers,
                     sse_read_timeout=config.read_transport_sse_timeout_seconds,
                 )
+
             else:
                 raise ValueError(f"Unsupported transport: {config.transport}")
 
@@ -333,9 +367,17 @@ class MCPConnectionManager(ContextDependent):
         # Check if the server is healthy after initialization
         if not server_conn.is_healthy():
             error_msg = server_conn._error_message or "Unknown error"
+
+            # Format the error message for better display
+            if isinstance(error_msg, list):
+                # Join the list with newlines for better readability
+                formatted_error = "\n".join(error_msg)
+            else:
+                formatted_error = str(error_msg)
+
             raise ServerInitializationError(
                 f"MCP Server: '{server_name}': Failed to initialize - see details. Check fastagent.config.yaml?",
-                error_msg,
+                formatted_error,
             )
 
         return server_conn

mcp_agent/mcp/prompts/prompt_server.py

@@ -82,6 +82,7 @@ class PromptConfig(PromptMetadata):
     http_timeout: float = 10.0
     transport: str = "stdio"
     port: int = 8000
+    host: str = "0.0.0.0"
 
 
 # We'll maintain registries of all exposed resources and prompts
@@ -344,6 +345,12 @@ def parse_args():
         default=8000,
         help="Port to use for SSE transport (default: 8000)",
     )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to bind to for SSE transport (default: 0.0.0.0)",
+    )
     parser.add_argument(
         "--test", type=str, help="Test a specific prompt without starting the server"
     )
@@ -380,6 +387,7 @@ def initialize_config(args) -> PromptConfig:
         http_timeout=args.http_timeout,
         transport=args.transport,
         port=args.port,
+        host=args.host,
     )
 
 
@@ -497,7 +505,10 @@ async def async_main() -> int:
     if config.transport == "stdio":
         await mcp.run_stdio_async()
     else:  # sse
-        # TODO update to 2025-03-26 specification and test config.
+        # 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()
     return 0