fast-agent-mcp 0.2.21__py3-none-any.whl → 0.2.23__py3-none-any.whl

mcp_agent/llm/providers/multipart_converter_tensorzero.py

@@ -0,0 +1,200 @@
+import json
+from typing import Any, Dict, List, Optional, Union
+
+from mcp.types import (
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+)
+
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.content_helpers import (
+    get_text,
+)
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+_logger = get_logger(__name__)
+
+
+class TensorZeroConverter:
+    """Converts MCP message types to/from TensorZero API format."""
+
+    @staticmethod
+    def _convert_content_part(
+        part: Union[TextContent, ImageContent, EmbeddedResource],
+    ) -> Optional[Dict[str, Any]]:
+        """Converts a single MCP content part to a T0 content block dictionary."""
+        if isinstance(part, TextContent):
+            text = get_text(part)
+            if text is not None:
+                return {"type": "text", "text": text}
+        elif isinstance(part, ImageContent):
+            # Handle Base64: needs data, mimeType (and mimeType must not be empty)
+            if hasattr(part, "data") and part.data and hasattr(part, "mimeType") and part.mimeType:
+                _logger.debug(
+                    f"Converting ImageContent as base64 for T0 native: mime={part.mimeType}, data_len={len(part.data) if isinstance(part.data, str) else 'N/A'}"
+                )
+                supported_mime_types = ["image/jpeg", "image/png", "image/webp"]
+                mime_type = getattr(part, "mimeType", "")
+
+                # Use the provided mime_type if supported, otherwise default to png
+                if mime_type not in supported_mime_types:
+                    _logger.warning(
+                        f"Unsupported mimeType '{mime_type}' for T0 base64 image, defaulting to image/png."
+                    )
+                    mime_type = "image/png"
+
+                return {
+                    "type": "image",
+                    "mime_type": mime_type,  # Note: T0 uses mime_type, not media_type
+                    "data": getattr(part, "data", ""),  # Data is direct property
+                }
+            else:
+                # Log cases where it's an ImageContent but doesn't fit Base64 criteria
+                _logger.warning(
+                    f"Skipping ImageContent: Missing required base64 fields (mimeType/data), or mimeType is empty: {part}"
+                )
+
+        elif isinstance(part, EmbeddedResource):
+            _logger.warning(f"Skipping EmbeddedResource, T0 conversion not implemented: {part}")
+        else:
+            _logger.error(
+                f"Unsupported content part type for T0 conversion: {type(part)}"
+            )  # Changed to error
+
+        return None  # Return None if no block was successfully created
+
+    @staticmethod
+    def _get_text_from_call_tool_result(result: CallToolResult) -> str:
+        """Helper to extract combined text from a CallToolResult's content list."""
+        texts = []
+        if result.content:
+            for part in result.content:
+                text = get_text(part)
+                if text:
+                    texts.append(text)
+        return "\n".join(texts)
+
+    @staticmethod
+    def convert_tool_results_to_t0_user_message(
+        results: List[CallToolResult],
+    ) -> Optional[Dict[str, Any]]:
+        """Formats CallToolResult list into T0's tool_result blocks within a user message dict."""
+        t0_tool_result_blocks = []
+        for result in results:
+            tool_use_id = getattr(result, "_t0_tool_use_id_temp", None)
+            tool_name = getattr(result, "_t0_tool_name_temp", None)
+
+            if tool_use_id and tool_name:
+                result_content_str = TensorZeroConverter._get_text_from_call_tool_result(result)
+                try:
+                    # Attempt to treat result as JSON if possible, else use raw string
+                    try:
+                        json_result = json.loads(result_content_str)
+                    except json.JSONDecodeError:
+                        json_result = result_content_str  # Fallback to string if not valid JSON
+                except Exception as e:
+                    _logger.error(f"Unexpected error processing tool result content: {e}")
+                    json_result = str(result_content_str)  # Safest fallback
+
+                t0_block = {
+                    "type": "tool_result",
+                    "id": tool_use_id,
+                    "name": tool_name,
+                    "result": json_result,  # T0 expects the result directly
+                }
+                t0_tool_result_blocks.append(t0_block)
+
+                # Clean up temporary attributes
+                try:
+                    delattr(result, "_t0_tool_use_id_temp")
+                    delattr(result, "_t0_tool_name_temp")
+                    if hasattr(result, "_t0_is_error_temp"):
+                        delattr(result, "_t0_is_error_temp")
+                except AttributeError:
+                    pass
+            else:
+                _logger.warning(
+                    f"Could not find id/name temp attributes for CallToolResult: {result}"
+                )
+
+        if not t0_tool_result_blocks:
+            return None
+
+        return {"role": "user", "content": t0_tool_result_blocks}
+
+    @staticmethod
+    def convert_mcp_to_t0_message(msg: PromptMessageMultipart) -> Optional[Dict[str, Any]]:
+        """
+        Converts a single PromptMessageMultipart to a T0 API message dictionary.
+        Handles Text, Image, and embedded CallToolResult content.
+        Skips system messages.
+        """
+        if msg.role == "system":
+            return None
+
+        t0_content_blocks = []
+        contains_tool_result = False
+
+        for part in msg.content:
+            # Use the corrected _convert_content_part
+            converted_block = TensorZeroConverter._convert_content_part(part)
+            if converted_block:
+                t0_content_blocks.append(converted_block)
+            elif isinstance(part, CallToolResult):
+                # Existing logic for handling embedded CallToolResult (seems compatible with T0 tool_result spec)
+                contains_tool_result = True
+                tool_use_id = getattr(part, "_t0_tool_use_id_temp", None)
+                tool_name = getattr(part, "_t0_tool_name_temp", None)
+                if tool_use_id and tool_name:
+                    result_content_str = TensorZeroConverter._get_text_from_call_tool_result(part)
+                    # Try to format result as JSON object/string
+                    try:
+                        json_result = json.loads(result_content_str)
+                    except json.JSONDecodeError:
+                        json_result = result_content_str  # Fallback
+                    except Exception as e:
+                        _logger.error(f"Error processing embedded tool result: {e}")
+                        json_result = str(result_content_str)
+
+                    t0_content_blocks.append(
+                        {
+                            "type": "tool_result",
+                            "id": tool_use_id,
+                            "name": tool_name,
+                            "result": json_result,
+                        }
+                    )
+                    # Clean up temp attributes
+                    try:
+                        delattr(part, "_t0_tool_use_id_temp")
+                        delattr(part, "_t0_tool_name_temp")
+                    except AttributeError:
+                        pass
+                else:
+                    _logger.warning(
+                        f"Found embedded CallToolResult without required temp attributes: {part}"
+                    )
+            # Note: The _convert_content_part handles logging for other skipped/unsupported types
+
+        if not t0_content_blocks:
+            return None
+
+        # Determine role - logic remains the same
+        valid_role = msg.role if msg.role in ["user", "assistant"] else "user"
+        if contains_tool_result and all(
+            block.get("type") == "tool_result" for block in t0_content_blocks
+        ):
+            final_role = "user"
+            if valid_role != final_role:
+                _logger.debug(f"Overriding role to '{final_role}' for tool result message.")
+        else:
+            final_role = valid_role
+            if valid_role != msg.role:
+                _logger.warning(f"Mapping message role '{msg.role}' to '{valid_role}' for T0.")
+
+        return {"role": final_role, "content": t0_content_blocks}
+
+    # Add methods here if needed to convert *from* T0 format back to MCP types
+    # e.g., adapt_t0_response_to_mcp(...) - this logic stays in the LLM class for now

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 (
@@ -22,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
@@ -39,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:
@@ -56,6 +79,7 @@ class ServerConnection:
                 tuple[
                     MemoryObjectReceiveStream[JSONRPCMessage | Exception],
                     MemoryObjectSendStream[JSONRPCMessage],
+                    GetSessionIdCallback | None,
                 ],
                 None,
             ],
@@ -161,15 +185,27 @@ 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):
-            #      try:
+        async with transport_context as (read_stream, write_stream, _):
             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 +216,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()
@@ -270,13 +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}")
 
@@ -333,9 +393,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

@@ -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
 
 

mcp_agent/mcp_server/agent_server.py

@@ -140,9 +140,9 @@ class AgentMCPServer:
         print("Press Ctrl+C again to force exit.")
         self._graceful_shutdown_event.set()
 
-    def run(self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000) -> None:
+    def run(self, transport: str = "http", host: str = "0.0.0.0", port: int = 8000) -> None:
         """Run the MCP server synchronously."""
-        if transport == "sse":
+        if transport in ["sse", "http"]:
             self.mcp_server.settings.host = host
             self.mcp_server.settings.port = port
 
@@ -180,12 +180,12 @@ class AgentMCPServer:
                 asyncio.run(self._cleanup_stdio())
 
     async def run_async(
-        self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000
+        self, transport: str = "http", host: str = "0.0.0.0", port: int = 8000
     ) -> None:
         """Run the MCP server asynchronously with improved shutdown handling."""
         # Use different handling strategies based on transport type
-        if transport == "sse":
-            # For SSE, use our enhanced shutdown handling
+        if transport in ["sse", "http"]:
+            # For SSE/HTTP, use our enhanced shutdown handling
             self._setup_signal_handlers()
 
             self.mcp_server.settings.host = host
@@ -236,9 +236,9 @@ class AgentMCPServer:
 
     async def _run_server_with_shutdown(self, transport: str):
         """Run the server with proper shutdown handling."""
-        # This method is only used for SSE transport
-        if transport != "sse":
-            raise ValueError("This method should only be used with SSE transport")
+        # This method is used for SSE/HTTP transport
+        if transport not in ["sse", "http"]:
+            raise ValueError("This method should only be used with SSE or HTTP transport")
 
         # Start a monitor task for shutdown
         shutdown_monitor = asyncio.create_task(self._monitor_shutdown())
@@ -262,8 +262,11 @@ class AgentMCPServer:
                 # Replace with our tracking version
                 self.mcp_server._sse_transport.connect_sse = tracked_connect_sse
 
-            # Run the server (SSE only)
-            await self.mcp_server.run_sse_async()
+            # Run the server based on transport type
+            if transport == "sse":
+                await self.mcp_server.run_sse_async()
+            elif transport == "http":
+                await self.mcp_server.run_streamable_http_async()
         finally:
             # Cancel the monitor when the server exits
             shutdown_monitor.cancel()

mcp_agent/mcp_server_registry.py

@@ -18,6 +18,7 @@ from mcp.client.stdio import (
     StdioServerParameters,
     get_default_environment,
 )
+from mcp.client.streamable_http import GetSessionIdCallback, streamablehttp_client
 
 from mcp_agent.config import (
     MCPServerAuthSettings,
@@ -27,7 +28,10 @@ from mcp_agent.config import (
 )
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.logger_textio import get_stderr_handler
-from mcp_agent.mcp.mcp_connection_manager import MCPConnectionManager
+from mcp_agent.mcp.mcp_connection_manager import (
+    MCPConnectionManager,
+    _add_none_to_context,
+)
 
 logger = get_logger(__name__)
 
@@ -93,7 +97,12 @@ class ServerRegistry:
         self,
         server_name: str,
         client_session_factory: Callable[
-            [MemoryObjectReceiveStream, MemoryObjectSendStream, timedelta | None],
+            [
+                MemoryObjectReceiveStream,
+                MemoryObjectSendStream,
+                timedelta | None,
+                GetSessionIdCallback | None,
+            ],
             ClientSession,
         ] = ClientSession,
     ) -> AsyncGenerator[ClientSession, None]:
@@ -132,14 +141,18 @@ class ServerRegistry:
             )
 
             # Create a stderr handler that logs to our application logger
-            async with stdio_client(server_params, errlog=get_stderr_handler(server_name)) as (
+            async with _add_none_to_context(
+                stdio_client(server_params, errlog=get_stderr_handler(server_name))
+            ) as (
                 read_stream,
                 write_stream,
+                _,
             ):
                 session = client_session_factory(
                     read_stream,
                     write_stream,
                     read_timeout_seconds,
+                    None,  # No callback for stdio
                 )
                 async with session:
                     logger.info(f"{server_name}: Connected to server using stdio transport.")
@@ -153,15 +166,18 @@ class ServerRegistry:
                 raise ValueError(f"URL is required for SSE transport: {server_name}")
 
             # Use sse_client to get the read and write streams
-            async with sse_client(
-                config.url,
-                config.headers,
-                sse_read_timeout=config.read_transport_sse_timeout_seconds,
-            ) as (read_stream, write_stream):
+            async with _add_none_to_context(
+                sse_client(
+                    config.url,
+                    config.headers,
+                    sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                )
+            ) as (read_stream, write_stream, _):
                 session = client_session_factory(
                     read_stream,
                     write_stream,
                     read_timeout_seconds,
+                    None,  # No callback for stdio
                 )
                 async with session:
                     logger.info(f"{server_name}: Connected to server using SSE transport.")
@@ -169,6 +185,27 @@ class ServerRegistry:
                         yield session
                     finally:
                         logger.debug(f"{server_name}: Closed session to server")
+        elif config.transport == "http":
+            if not config.url:
+                raise ValueError(f"URL is required for SSE transport: {server_name}")
+
+            async with streamablehttp_client(config.url, config.headers) as (
+                read_stream,
+                write_stream,
+                _,
+            ):
+                session = client_session_factory(
+                    read_stream,
+                    write_stream,
+                    read_timeout_seconds,
+                    None,  # No callback for stdio
+                )
+                async with session:
+                    logger.info(f"{server_name}: Connected to server using HTTP transport.")
+                    try:
+                        yield session
+                    finally:
+                        logger.debug(f"{server_name}: Closed session to server")
 
         # Unsupported transport
         else:
@@ -179,7 +216,12 @@ class ServerRegistry:
         self,
         server_name: str,
         client_session_factory: Callable[
-            [MemoryObjectReceiveStream, MemoryObjectSendStream, timedelta | None],
+            [
+                MemoryObjectReceiveStream,
+                MemoryObjectSendStream,
+                timedelta | None,
+                GetSessionIdCallback,
+            ],
             ClientSession,
         ] = ClientSession,
         init_hook: InitHookCallable = None,

mcp_agent/resources/examples/mcp/state-transfer/fastagent.config.yaml

@@ -23,5 +23,5 @@ logger:
 mcp:
   servers:
     agent_one:
-      transport: sse
-      url: http://localhost:8001/sse
+      transport: http
+      url: http://localhost:8001/mcp

mcp_agent/ui/console_display.py

@@ -25,6 +25,7 @@ class ConsoleDisplay:
             config: Configuration object containing display preferences
         """
         self.config = config
+        self._markup = config.logger.enable_markup if config else True
 
     def show_tool_result(self, result: CallToolResult) -> None:
         """Display a tool result in a formatted panel."""
@@ -46,7 +47,7 @@ class ConsoleDisplay:
             if len(str(result.content)) > 360:
                 panel.height = 8
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def show_oai_tool_result(self, result) -> None:
@@ -67,7 +68,7 @@ class ConsoleDisplay:
             if len(str(result)) > 360:
                 panel.height = 8
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def show_tool_call(self, available_tools, tool_name, tool_args) -> None:
@@ -92,7 +93,7 @@ class ConsoleDisplay:
             if len(str(tool_args)) > 360:
                 panel.height = 8
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def _format_tool_list(self, available_tools, selected_tool_name):
@@ -172,7 +173,7 @@ class ConsoleDisplay:
             subtitle=display_server_list,
             subtitle_align="left",
         )
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def show_user_message(
@@ -196,7 +197,7 @@ class ConsoleDisplay:
             subtitle=subtitle_text,
             subtitle_align="left",
         )
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     async def show_prompt_loaded(
@@ -270,5 +271,5 @@ class ConsoleDisplay:
             subtitle_align="left",
         )
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")