fast-agent-mcp 0.1.13__py3-none-any.whl → 0.2.0__py3-none-any.whl

mcp_agent/mcp/mcp_aggregator.py

@@ -77,7 +77,9 @@ class MCPAggregator(ContextDependent):
         if self.connection_persistence:
             # Try to get existing connection manager from context
             if not hasattr(self.context, "_connection_manager"):
-                self.context._connection_manager = MCPConnectionManager(self.context.server_registry)
+                self.context._connection_manager = MCPConnectionManager(
+                    self.context.server_registry
+                )
                 await self.context._connection_manager.__aenter__()
             self._persistent_connection_manager = self.context._connection_manager
 
@@ -133,7 +135,10 @@ class MCPAggregator(ContextDependent):
         if self.connection_persistence and self._persistent_connection_manager:
             try:
                 # Only attempt cleanup if we own the connection manager
-                if hasattr(self.context, "_connection_manager") and self.context._connection_manager == self._persistent_connection_manager:
+                if (
+                    hasattr(self.context, "_connection_manager")
+                    and self.context._connection_manager == self._persistent_connection_manager
+                ):
                     logger.info("Shutting down all persistent connections...")
                     await self._persistent_connection_manager.disconnect_all()
                     await self._persistent_connection_manager.__aexit__(None, None, None)
@@ -202,7 +207,9 @@ class MCPAggregator(ContextDependent):
                     },
                 )
 
-                await self._persistent_connection_manager.get_server(server_name, client_session_factory=MCPAgentClientSession)
+                await self._persistent_connection_manager.get_server(
+                    server_name, client_session_factory=MCPAgentClientSession
+                )
 
             logger.info(
                 f"MCP Servers initialized for agent '{self.agent_name}'",
@@ -239,11 +246,15 @@ class MCPAggregator(ContextDependent):
             prompts: List[Prompt] = []
 
             if self.connection_persistence:
-                server_connection = await self._persistent_connection_manager.get_server(server_name, client_session_factory=MCPAgentClientSession)
+                server_connection = await self._persistent_connection_manager.get_server(
+                    server_name, client_session_factory=MCPAgentClientSession
+                )
                 tools = await fetch_tools(server_connection.session)
                 prompts = await fetch_prompts(server_connection.session, server_name)
             else:
-                async with gen_client(server_name, server_registry=self.context.server_registry) as client:
+                async with gen_client(
+                    server_name, server_registry=self.context.server_registry
+                ) as client:
                     tools = await fetch_tools(client)
                     prompts = await fetch_prompts(client, server_name)
 
@@ -299,7 +310,9 @@ class MCPAggregator(ContextDependent):
             return None
 
         try:
-            server_conn = await self._persistent_connection_manager.get_server(server_name, client_session_factory=MCPAgentClientSession)
+            server_conn = await self._persistent_connection_manager.get_server(
+                server_name, client_session_factory=MCPAgentClientSession
+            )
             # server_capabilities is a property, not a coroutine
             return server_conn.server_capabilities
         except Exception as e:
@@ -356,12 +369,16 @@ class MCPAggregator(ContextDependent):
                 method = getattr(client, method_name)
                 return await method(**method_args)
             except Exception as e:
-                error_msg = f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
+                error_msg = (
+                    f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
+                )
                 logger.error(error_msg)
                 return error_factory(error_msg) if error_factory else None
 
         if self.connection_persistence:
-            server_connection = await self._persistent_connection_manager.get_server(server_name, client_session_factory=MCPAgentClientSession)
+            server_connection = await self._persistent_connection_manager.get_server(
+                server_name, client_session_factory=MCPAgentClientSession
+            )
             return await try_execute(server_connection.session)
         else:
             logger.debug(
@@ -372,7 +389,9 @@ class MCPAggregator(ContextDependent):
                     "agent_name": self.agent_name,
                 },
             )
-            async with gen_client(server_name, server_registry=self.context.server_registry) as client:
+            async with gen_client(
+                server_name, server_registry=self.context.server_registry
+            ) as client:
                 result = await try_execute(client)
                 logger.debug(
                     f"Closing temporary connection to server: {server_name}",
@@ -451,10 +470,14 @@ class MCPAggregator(ContextDependent):
             operation_name=local_tool_name,
             method_name="call_tool",
             method_args={"name": local_tool_name, "arguments": arguments},
-            error_factory=lambda msg: CallToolResult(isError=True, content=[TextContent(type="text", text=msg)]),
+            error_factory=lambda msg: CallToolResult(
+                isError=True, content=[TextContent(type="text", text=msg)]
+            ),
         )
 
-    async def get_prompt(self, prompt_name: str | None, arguments: dict[str, str] | None) -> GetPromptResult:
+    async def get_prompt(
+        self, prompt_name: str | None, arguments: dict[str, str] | None
+    ) -> GetPromptResult:
         """
         Get a prompt from a server.
 
@@ -508,7 +531,9 @@ class MCPAggregator(ContextDependent):
                         # Check if any prompt in the cache has this name
                         prompt_names = [prompt.name for prompt in self._prompt_cache[server_name]]
                         if local_prompt_name not in prompt_names:
-                            logger.debug(f"Prompt '{local_prompt_name}' not found in cache for server '{server_name}'")
+                            logger.debug(
+                                f"Prompt '{local_prompt_name}' not found in cache for server '{server_name}'"
+                            )
                             return GetPromptResult(
                                 description=f"Prompt '{local_prompt_name}' not found on server '{server_name}'",
                                 messages=[],
@@ -550,7 +575,9 @@ class MCPAggregator(ContextDependent):
                     potential_servers.append(s_name)
 
         if potential_servers:
-            logger.debug(f"Found prompt '{local_prompt_name}' in cache for servers: {potential_servers}")
+            logger.debug(
+                f"Found prompt '{local_prompt_name}' in cache for servers: {potential_servers}"
+            )
 
             # Try each server from the cache
             for s_name in potential_servers:
@@ -576,7 +603,9 @@ class MCPAggregator(ContextDependent):
 
                     # If we got a successful result with messages, return it
                     if result and result.messages:
-                        logger.debug(f"Successfully retrieved prompt '{local_prompt_name}' from server '{s_name}'")
+                        logger.debug(
+                            f"Successfully retrieved prompt '{local_prompt_name}' from server '{s_name}'"
+                        )
                         # Add namespaced name using the actual server where found
                         result.namespaced_name = f"{s_name}{SEP}{local_prompt_name}"
 
@@ -599,7 +628,9 @@ class MCPAggregator(ContextDependent):
                 if capabilities and capabilities.prompts:
                     supported_servers.append(s_name)
                 else:
-                    logger.debug(f"Server '{s_name}' does not support prompts, skipping from fallback search")
+                    logger.debug(
+                        f"Server '{s_name}' does not support prompts, skipping from fallback search"
+                    )
 
             # Try all supported servers in order
             for s_name in supported_servers:
@@ -620,7 +651,9 @@ class MCPAggregator(ContextDependent):
 
                     # If we got a successful result with messages, return it
                     if result and result.messages:
-                        logger.debug(f"Found prompt '{local_prompt_name}' on server '{s_name}' (not in cache)")
+                        logger.debug(
+                            f"Found prompt '{local_prompt_name}' on server '{s_name}' (not in cache)"
+                        )
                         # Add namespaced name using the actual server where found
                         result.namespaced_name = f"{s_name}{SEP}{local_prompt_name}"
 
@@ -645,7 +678,9 @@ class MCPAggregator(ContextDependent):
                                     if s_name not in self._prompt_cache:
                                         self._prompt_cache[s_name] = []
                                     # Add if not already in the cache
-                                    prompt_names_in_cache = [p.name for p in self._prompt_cache[s_name]]
+                                    prompt_names_in_cache = [
+                                        p.name for p in self._prompt_cache[s_name]
+                                    ]
                                     if local_prompt_name not in prompt_names_in_cache:
                                         self._prompt_cache[s_name].append(matching_prompts[0])
                         except Exception:
@@ -665,103 +700,97 @@ class MCPAggregator(ContextDependent):
             messages=[],
         )
 
-    async def list_prompts(self, server_name: str = None):
+    async def list_prompts(self, server_name: str = None) -> Dict[str, List[Prompt]]:
         """
         List available prompts from one or all servers.
 
         :param server_name: Optional server name to list prompts from. If not provided,
                            lists prompts from all servers.
-        :return: Dictionary mapping server names to lists of available prompts
+        :return: Dictionary mapping server names to lists of Prompt objects
         """
         if not self.initialized:
             await self.load_servers()
 
-        results = {}
+        results: Dict[str, List[Prompt]] = {}
 
-        # If we already have the data in cache and not requesting a specific server,
-        # we can use the cache directly
-        if not server_name:
+        # If specific server requested
+        if server_name:
+            if server_name not in self.server_names:
+                logger.error(f"Server '{server_name}' not found")
+                return results
+
+            # Check cache first
             async with self._prompt_cache_lock:
-                if all(s_name in self._prompt_cache for s_name in self.server_names):
-                    # Return the cached prompt objects
-                    for s_name, prompt_list in self._prompt_cache.items():
-                        results[s_name] = prompt_list
-                    logger.debug("Returning cached prompts for all servers")
+                if server_name in self._prompt_cache:
+                    results[server_name] = self._prompt_cache[server_name]
+                    logger.debug(f"Returning cached prompts for server '{server_name}'")
                     return results
 
-        # If server_name is provided, only list prompts from that server
-        if server_name:
-            if server_name in self.server_names:
-                # Check if we can use the cache
-                async with self._prompt_cache_lock:
-                    if server_name in self._prompt_cache:
-                        results[server_name] = self._prompt_cache[server_name]
-                        logger.debug(f"Returning cached prompts for server '{server_name}'")
-                        return results
+            # Check if server supports prompts
+            capabilities = await self.get_capabilities(server_name)
+            if not capabilities or not capabilities.prompts:
+                logger.debug(f"Server '{server_name}' does not support prompts")
+                results[server_name] = []
+                return results
 
-                # Check if server supports prompts
-                capabilities = await self.get_capabilities(server_name)
-                if not capabilities or not capabilities.prompts:
-                    logger.debug(f"Server '{server_name}' does not support prompts")
-                    results[server_name] = []
-                    return results
+            # Fetch from server
+            result = await self._execute_on_server(
+                server_name=server_name,
+                operation_type="prompts-list",
+                operation_name="",
+                method_name="list_prompts",
+                error_factory=lambda _: None,
+            )
+
+            # Get prompts from result
+            prompts = getattr(result, "prompts", [])
+
+            # Update cache
+            async with self._prompt_cache_lock:
+                self._prompt_cache[server_name] = prompts
+
+            results[server_name] = prompts
+            return results
+
+        # No specific server - check if we can use the cache for all servers
+        async with self._prompt_cache_lock:
+            if all(s_name in self._prompt_cache for s_name in self.server_names):
+                for s_name, prompt_list in self._prompt_cache.items():
+                    results[s_name] = prompt_list
+                logger.debug("Returning cached prompts for all servers")
+                return results
+
+        # Identify servers that support prompts
+        supported_servers = []
+        for s_name in self.server_names:
+            capabilities = await self.get_capabilities(s_name)
+            if capabilities and capabilities.prompts:
+                supported_servers.append(s_name)
+            else:
+                logger.debug(f"Server '{s_name}' does not support prompts, skipping")
+                results[s_name] = []
 
-                # If not in cache and server supports prompts, fetch from server
+        # Fetch prompts from supported servers
+        for s_name in supported_servers:
+            try:
                 result = await self._execute_on_server(
-                    server_name=server_name,
+                    server_name=s_name,
                     operation_type="prompts-list",
                     operation_name="",
                     method_name="list_prompts",
-                    error_factory=lambda _: [],
+                    error_factory=lambda _: None,
                 )
 
-                # Update cache with the result
-                async with self._prompt_cache_lock:
-                    self._prompt_cache[server_name] = getattr(result, "prompts", [])
+                prompts = getattr(result, "prompts", [])
 
-                results[server_name] = result
-            else:
-                logger.error(f"Server '{server_name}' not found")
-        else:
-            # We need to filter the servers that support prompts
-            supported_servers = []
-            for s_name in self.server_names:
-                capabilities = await self.get_capabilities(s_name)
-                if capabilities and capabilities.prompts:
-                    supported_servers.append(s_name)
-                else:
-                    logger.debug(f"Server '{s_name}' does not support prompts, skipping")
-                    # Add empty list to results for this server
-                    results[s_name] = []
-
-            # Process servers sequentially to ensure proper resource cleanup
-            # This helps prevent resource leaks especially on Windows
-            if supported_servers:
-                server_results = []
-                for s_name in supported_servers:
-                    try:
-                        result = await self._execute_on_server(
-                            server_name=s_name,
-                            operation_type="prompts-list",
-                            operation_name="",
-                            method_name="list_prompts",
-                            error_factory=lambda _: [],
-                        )
-                        server_results.append(result)
-                    except Exception as e:
-                        logger.debug(f"Error fetching prompts from {s_name}: {e}")
-                        server_results.append(e)
-
-                for i, result in enumerate(server_results):
-                    if isinstance(result, BaseException):
-                        continue
-
-                    s_name = supported_servers[i]
-                    results[s_name] = result
+                # Update cache and results
+                async with self._prompt_cache_lock:
+                    self._prompt_cache[s_name] = prompts
 
-                    # Update cache with the result
-                    async with self._prompt_cache_lock:
-                        self._prompt_cache[s_name] = getattr(result, "prompts", [])
+                results[s_name] = prompts
+            except Exception as e:
+                logger.debug(f"Error fetching prompts from {s_name}: {e}")
+                results[s_name] = []
 
         logger.debug(f"Available prompts across servers: {results}")
         return results
@@ -843,7 +872,9 @@ class MCPCompoundServer(Server):
                 content=[TextContent(type="text", text=f"Error calling tool: {e}")],
             )
 
-    async def _get_prompt(self, name: str = None, arguments: dict[str, str] = None) -> GetPromptResult:
+    async def _get_prompt(
+        self, name: str = None, arguments: dict[str, str] = None
+    ) -> GetPromptResult:
         """
         Get a prompt from the aggregated servers.
 
@@ -857,7 +888,7 @@ class MCPCompoundServer(Server):
         except Exception as e:
             return GetPromptResult(description=f"Error getting prompt: {e}", messages=[])
 
-    async def _list_prompts(self, server_name: str = None) -> Dict[str, List[str]]:
+    async def _list_prompts(self, server_name: str = None) -> Dict[str, List[Prompt]]:
         """List available prompts from the aggregated servers."""
         try:
             return await self.aggregator.list_prompts(server_name=server_name)

mcp_agent/mcp/mcp_connection_manager.py

@@ -19,6 +19,7 @@ from mcp.client.sse import sse_client
 from mcp.client.stdio import (
     StdioServerParameters,
     get_default_environment,
+    stdio_client,
 )
 from mcp.types import JSONRPCMessage, ServerCapabilities
 
@@ -27,8 +28,8 @@ from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.core.exceptions import ServerInitializationError
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.logger_textio import get_stderr_handler
 from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
-from mcp_agent.mcp.stdio import stdio_client_with_rich_stderr
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -133,7 +134,11 @@ class ServerConnection:
         Create a new session instance for this server connection.
         """
 
-        read_timeout = timedelta(seconds=self.server_config.read_timeout_seconds) if self.server_config.read_timeout_seconds else None
+        read_timeout = (
+            timedelta(seconds=self.server_config.read_timeout_seconds)
+            if self.server_config.read_timeout_seconds
+            else None
+        )
 
         session = self._client_session_factory(read_stream, send_stream, read_timeout)
 
@@ -187,7 +192,9 @@ class MCPConnectionManager(ContextDependent):
     Integrates with the application context system for proper resource management.
     """
 
-    def __init__(self, server_registry: "ServerRegistry", context: Optional["Context"] = None) -> None:
+    def __init__(
+        self, server_registry: "ServerRegistry", context: Optional["Context"] = None
+    ) -> None:
         super().__init__(context=context)
         self.server_registry = server_registry
         self.running_servers: Dict[str, ServerConnection] = {}
@@ -257,8 +264,11 @@ class MCPConnectionManager(ContextDependent):
                     args=config.args,
                     env={**get_default_environment(), **(config.env or {})},
                 )
-                # Create stdio client config with redirected stderr
-                return stdio_client_with_rich_stderr(server_params)
+                # Create custom error handler to ensure all output is captured
+                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)
             elif config.transport == "sse":
                 return sse_client(config.url)
             else:
@@ -317,13 +327,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"
-            raise ServerInitializationError(f"MCP Server: '{server_name}': Failed to initialize with error: '{error_msg}'. Check fastagent.config.yaml")
+            raise ServerInitializationError(
+                f"MCP Server: '{server_name}': Failed to initialize with error: '{error_msg}'. Check fastagent.config.yaml"
+            )
 
         return server_conn
 
     async def get_server_capabilities(self, server_name: str) -> ServerCapabilities | None:
         """Get the capabilities of a specific server."""
-        server_conn = await self.get_server(server_name, client_session_factory=MCPAgentClientSession)
+        server_conn = await self.get_server(
+            server_name, client_session_factory=MCPAgentClientSession
+        )
         return server_conn.server_capabilities if server_conn else None
 
     async def disconnect_server(self, server_name: str) -> None:

mcp_agent/mcp/prompt_message_multipart.py

@@ -7,10 +7,31 @@ from mcp.types import (
     PromptMessage,
     Role,
     TextContent,
+    TextResourceContents,
 )
 from pydantic import BaseModel
 
 
+def get_text(content: Union[TextContent, ImageContent, EmbeddedResource]) -> str | None:
+    """
+    Extract text content from a content object if available.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        The text content as a string or None if not a text content
+    """
+    if isinstance(content, TextContent):
+        return content.text
+
+    if isinstance(content, EmbeddedResource):
+        if isinstance(content.resource, TextResourceContents):
+            return content.resource.text
+
+    return None
+
+
 class PromptMessageMultipart(BaseModel):
     """
     Extension of PromptMessage that handles multiple content parts.
@@ -50,7 +71,44 @@ class PromptMessageMultipart(BaseModel):
 
     def from_multipart(self) -> List[PromptMessage]:
         """Convert this PromptMessageMultipart to a sequence of standard PromptMessages."""
-        return [PromptMessage(role=self.role, content=content_part) for content_part in self.content]
+        return [
+            PromptMessage(role=self.role, content=content_part) for content_part in self.content
+        ]
+
+    def first_text(self) -> str:
+        """
+        Get the first available text content from a message.
+
+        Args:
+            message: A PromptMessage or PromptMessageMultipart
+
+        Returns:
+            First text content or None if no text content exists
+        """
+        for content in self.content:
+            text = get_text(content)
+            if text is not None:
+                return text
+
+        return "<no text>"
+
+    def all_text(self) -> str:
+        """
+        Get all the text available.
+
+        Args:
+            message: A PromptMessage or PromptMessageMultipart
+
+        Returns:
+            First text content or None if no text content exists
+        """
+        result = []
+        for content in self.content:
+            text = get_text(content)
+            if text is not None:
+                result.append(text)
+
+        return "\n".join(result)
 
     @classmethod
     def parse_get_prompt_result(cls, result: GetPromptResult) -> List["PromptMessageMultipart"]:

mcp_agent/mcp/prompt_render.py

@@ -0,0 +1,77 @@
+"""
+Utilities for rendering PromptMessageMultipart objects for display.
+"""
+
+from typing import List
+
+from mcp.types import BlobResourceContents, TextResourceContents
+
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import (
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
+)
+
+
+def render_multipart_message(message: PromptMessageMultipart) -> str:
+    """
+    Render a multipart message for display purposes.
+    
+    This function formats the message content for user-friendly display,
+    handling different content types appropriately.
+    
+    Args:
+        message: A PromptMessageMultipart object to render
+        
+    Returns:
+        A string representation of the message's content
+    """
+    rendered_parts: List[str] = []
+    
+    for content in message.content:
+        if is_text_content(content):
+            # Handle text content
+            text_content = content  # type: TextContent
+            rendered_parts.append(text_content.text)
+            
+        elif is_image_content(content):
+            # Format details about the image
+            image_content = content  # type: ImageContent
+            data_size = len(image_content.data) if image_content.data else 0
+            image_info = f"[IMAGE: {image_content.mimeType}, {data_size} bytes]"
+            rendered_parts.append(image_info)
+            
+        elif is_resource_content(content):
+            # Handle embedded resources
+            resource = content  # type: EmbeddedResource
+            uri = get_resource_uri(resource)
+            
+            if isinstance(resource.resource, TextResourceContents):
+                # Handle text resources
+                text = resource.resource.text
+                text_length = len(text)
+                mime_type = resource.resource.mimeType
+                
+                # Preview with truncation for long content
+                preview = text[:300] + ("..." if text_length > 300 else "")
+                resource_info = f"[EMBEDDED TEXT RESOURCE: {mime_type}, {uri}, {text_length} chars]\n{preview}"
+                rendered_parts.append(resource_info)
+                
+            elif isinstance(resource.resource, BlobResourceContents):
+                # Handle blob resources (binary data)
+                blob_length = len(resource.resource.blob) if resource.resource.blob else 0
+                mime_type = resource.resource.mimeType
+                
+                resource_info = f"[EMBEDDED BLOB RESOURCE: {mime_type}, {uri}, {blob_length} bytes]"
+                rendered_parts.append(resource_info)
+                
+        else:
+            # Fallback for other content types
+            text = get_text(content)
+            if text is not None:
+                rendered_parts.append(text)
+    
+    return "\n".join(rendered_parts)

mcp_agent/mcp/prompt_serialization.py

@@ -22,6 +22,11 @@ from typing import List
 from mcp.types import EmbeddedResource, ImageContent, TextContent, TextResourceContents
 
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_constants import (
+    ASSISTANT_DELIMITER,
+    RESOURCE_DELIMITER,
+    USER_DELIMITER,
+)
 
 # -------------------------------------------------------------------------
 # JSON Serialization Functions
@@ -43,7 +48,9 @@ def multipart_messages_to_json(messages: List[PromptMessageMultipart]) -> str:
     """
     # Convert to dictionaries using model_dump with proper JSON mode
     # The mode="json" parameter ensures proper handling of AnyUrl objects
-    message_dicts = [message.model_dump(by_alias=True, mode="json", exclude_none=True) for message in messages]
+    message_dicts = [
+        message.model_dump(by_alias=True, mode="json", exclude_none=True) for message in messages
+    ]
 
     # Convert to JSON string
     return json.dumps(message_dicts, indent=2)
@@ -110,9 +117,9 @@ def load_messages_from_json_file(file_path: str) -> List[PromptMessageMultipart]
 
 def multipart_messages_to_delimited_format(
     messages: List[PromptMessageMultipart],
-    user_delimiter: str = "---USER",
-    assistant_delimiter: str = "---ASSISTANT",
-    resource_delimiter: str = "---RESOURCE",
+    user_delimiter: str = USER_DELIMITER,
+    assistant_delimiter: str = ASSISTANT_DELIMITER,
+    resource_delimiter: str = RESOURCE_DELIMITER,
     combine_text: bool = True,  # Set to False to maintain backward compatibility
 ) -> List[str]:
     """
@@ -189,9 +196,9 @@ def multipart_messages_to_delimited_format(
 
 def delimited_format_to_multipart_messages(
     content: str,
-    user_delimiter: str = "---USER",
-    assistant_delimiter: str = "---ASSISTANT",
-    resource_delimiter: str = "---RESOURCE",
+    user_delimiter: str = USER_DELIMITER,
+    assistant_delimiter: str = ASSISTANT_DELIMITER,
+    resource_delimiter: str = RESOURCE_DELIMITER,
 ) -> List[PromptMessageMultipart]:
     """
     Parse hybrid delimited format into PromptMessageMultipart objects:
@@ -365,9 +372,9 @@ def delimited_format_to_multipart_messages(
 def save_messages_to_delimited_file(
     messages: List[PromptMessageMultipart],
     file_path: str,
-    user_delimiter: str = "---USER",
-    assistant_delimiter: str = "---ASSISTANT",
-    resource_delimiter: str = "---RESOURCE",
+    user_delimiter: str = USER_DELIMITER,
+    assistant_delimiter: str = ASSISTANT_DELIMITER,
+    resource_delimiter: str = RESOURCE_DELIMITER,
     combine_text: bool = True,
 ) -> None:
     """
@@ -395,9 +402,9 @@ def save_messages_to_delimited_file(
 
 def load_messages_from_delimited_file(
     file_path: str,
-    user_delimiter: str = "---USER",
-    assistant_delimiter: str = "---ASSISTANT",
-    resource_delimiter: str = "---RESOURCE",
+    user_delimiter: str = USER_DELIMITER,
+    assistant_delimiter: str = ASSISTANT_DELIMITER,
+    resource_delimiter: str = RESOURCE_DELIMITER,
 ) -> List[PromptMessageMultipart]:
     """
     Load PromptMessageMultipart objects from a file in hybrid delimited format.