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

mcp_agent/mcp/prompts/prompt_server.py

@@ -15,86 +15,84 @@ from typing import Any, Awaitable, Callable, Dict, List, Optional
 
 from mcp.server.fastmcp import FastMCP
 from mcp.server.fastmcp.prompts.base import (
+    AssistantMessage,
     Message,
+    UserMessage,
 )
 from mcp.server.fastmcp.resources import FileResource
+from mcp.types import PromptMessage
 from pydantic import AnyUrl
 
 from mcp_agent.mcp import mime_utils, resource_utils
+from mcp_agent.mcp.prompts.prompt_constants import (
+    ASSISTANT_DELIMITER as DEFAULT_ASSISTANT_DELIMITER,
+)
+from mcp_agent.mcp.prompts.prompt_constants import (
+    RESOURCE_DELIMITER as DEFAULT_RESOURCE_DELIMITER,
+)
+from mcp_agent.mcp.prompts.prompt_constants import (
+    USER_DELIMITER as DEFAULT_USER_DELIMITER,
+)
 from mcp_agent.mcp.prompts.prompt_load import create_messages_with_resources
 from mcp_agent.mcp.prompts.prompt_template import (
     PromptMetadata,
-    PromptTemplate,
     PromptTemplateLoader,
 )
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.ERROR)
 logger = logging.getLogger("prompt_server")
 
 # Create FastMCP server
 mcp = FastMCP("Prompt Server")
 
 
+def convert_to_fastmcp_messages(prompt_messages: List[PromptMessage]) -> List[Message]:
+    """
+    Convert PromptMessage objects from prompt_load to FastMCP Message objects.
+    This adapter prevents double-wrapping of messages.
+
+    Args:
+        prompt_messages: List of PromptMessage objects from prompt_load
+
+    Returns:
+        List of FastMCP Message objects
+    """
+    result = []
+
+    for msg in prompt_messages:
+        if msg.role == "user":
+            result.append(UserMessage(content=msg.content))
+        elif msg.role == "assistant":
+            result.append(AssistantMessage(content=msg.content))
+        else:
+            logger.warning(f"Unknown message role: {msg.role}, defaulting to user")
+            result.append(UserMessage(content=msg.content))
+
+    return result
+
+
 class PromptConfig(PromptMetadata):
     """Configuration for the prompt server"""
 
     prompt_files: List[Path] = []
-    user_delimiter: str = "---USER"
-    assistant_delimiter: str = "---ASSISTANT"
-    resource_delimiter: str = "---RESOURCE"
+    user_delimiter: str = DEFAULT_USER_DELIMITER
+    assistant_delimiter: str = DEFAULT_ASSISTANT_DELIMITER
+    resource_delimiter: str = DEFAULT_RESOURCE_DELIMITER
     http_timeout: float = 10.0
     transport: str = "stdio"
     port: int = 8000
 
 
-# Will be initialized with command line args
-config = None
-
 # We'll maintain registries of all exposed resources and prompts
 exposed_resources: Dict[str, Path] = {}
 prompt_registry: Dict[str, PromptMetadata] = {}
 
-# Default delimiter values
-DEFAULT_USER_DELIMITER = "---USER"
-DEFAULT_ASSISTANT_DELIMITER = "---ASSISTANT"
-DEFAULT_RESOURCE_DELIMITER = "---RESOURCE"
-
 
 # Define a single type for prompt handlers to avoid mypy issues
 PromptHandler = Callable[..., Awaitable[List[Message]]]
 
 
-def create_prompt_handler(template: "PromptTemplate", template_vars: List[str], prompt_files: List[Path]) -> PromptHandler:
-    """Create a prompt handler function for the given template"""
-    if template_vars:
-        # With template variables
-        docstring = f"Prompt with template variables: {', '.join(template_vars)}"
-
-        async def prompt_handler(**kwargs: Any) -> List[Message]:
-            # Build context from parameters
-            context = {var: kwargs.get(var) for var in template_vars if var in kwargs and kwargs[var] is not None}
-
-            content_sections = template.apply_substitutions(context)
-
-            # Convert to MCP Message objects, handling resources properly
-            return create_messages_with_resources(content_sections, prompt_files)
-
-    else:
-        # No template variables
-        docstring = "Get a prompt with no variable substitution"
-
-        async def prompt_handler(**kwargs: Any) -> List[Message]:
-            content_sections = template.content_sections
-
-            # Convert to MCP Message objects, handling resources properly
-            return create_messages_with_resources(content_sections, prompt_files)
-
-    # Set the docstring
-    prompt_handler.__doc__ = docstring
-    return prompt_handler
-
-
 # Type for resource handler
 ResourceHandler = Callable[[], Awaitable[str | bytes]]
 
@@ -117,7 +115,9 @@ def create_resource_handler(resource_path: Path, mime_type: str) -> ResourceHand
     return get_resource
 
 
-def get_delimiter_config(file_path: Optional[Path] = None) -> Dict[str, Any]:
+def get_delimiter_config(
+    config: Optional[PromptConfig] = None, file_path: Optional[Path] = None
+) -> Dict[str, Any]:
     """Get delimiter configuration, falling back to defaults if config is None"""
     # Set defaults
     config_values = {
@@ -137,11 +137,11 @@ def get_delimiter_config(file_path: Optional[Path] = None) -> Dict[str, Any]:
     return config_values
 
 
-def register_prompt(file_path: Path) -> None:
+def register_prompt(file_path: Path, config: Optional[PromptConfig] = None) -> None:
     """Register a prompt file"""
     try:
         # Get delimiter configuration
-        config_values = get_delimiter_config(file_path)
+        config_values = get_delimiter_config(config, file_path)
 
         # Use our prompt template loader to analyze the file
         loader = PromptTemplateLoader(
@@ -171,8 +171,61 @@ def register_prompt(file_path: Path) -> None:
 
         # Create and register prompt handler
         template_vars = list(metadata.template_variables)
-        handler = create_prompt_handler(template, template_vars, config_values["prompt_files"])
-        mcp.prompt(name=metadata.name, description=metadata.description)(handler)
+
+        from mcp.server.fastmcp.prompts.base import Prompt, PromptArgument
+
+        # For prompts with variables, create arguments list for FastMCP
+        if template_vars:
+            # Create a function with properly typed parameters
+            async def template_handler_with_vars(**kwargs):
+                # Extract template variables from kwargs
+                context = {var: kwargs.get(var) for var in template_vars if var in kwargs}
+
+                # Check for missing variables
+                missing_vars = [var for var in template_vars if var not in context]
+                if missing_vars:
+                    raise ValueError(
+                        f"Missing required template variables: {', '.join(missing_vars)}"
+                    )
+
+                # Apply template and create messages
+                content_sections = template.apply_substitutions(context)
+                prompt_messages = create_messages_with_resources(
+                    content_sections, config_values["prompt_files"]
+                )
+                return convert_to_fastmcp_messages(prompt_messages)
+
+            # Create a Prompt directly
+            arguments = [
+                PromptArgument(name=var, description=f"Template variable: {var}", required=True)
+                for var in template_vars
+            ]
+
+            # Create and add the prompt directly to the prompt manager
+            prompt = Prompt(
+                name=metadata.name,
+                description=metadata.description,
+                arguments=arguments,
+                fn=template_handler_with_vars,
+            )
+            mcp._prompt_manager.add_prompt(prompt)
+        else:
+            # Create a simple prompt without variables
+            async def template_handler_without_vars() -> list[Message]:
+                content_sections = template.content_sections
+                prompt_messages = create_messages_with_resources(
+                    content_sections, config_values["prompt_files"]
+                )
+                return convert_to_fastmcp_messages(prompt_messages)
+
+            # Create a Prompt object directly instead of using the decorator
+            prompt = Prompt(
+                name=metadata.name,
+                description=metadata.description,
+                arguments=[],
+                fn=template_handler_without_vars,
+            )
+            mcp._prompt_manager.add_prompt(prompt)
 
         # Register any referenced resources in the prompt
         for resource_path in metadata.resource_paths:
@@ -242,12 +295,46 @@ def parse_args():
         default=8000,
         help="Port to use for SSE transport (default: 8000)",
     )
-    parser.add_argument("--test", type=str, help="Test a specific prompt without starting the server")
+    parser.add_argument(
+        "--test", type=str, help="Test a specific prompt without starting the server"
+    )
 
     return parser.parse_args()
 
 
-async def register_file_resource_handler() -> None:
+def initialize_config(args) -> PromptConfig:
+    """Initialize configuration from command line arguments"""
+    # Resolve file paths
+    prompt_files = []
+    for file_path in args.prompt_files:
+        path = Path(file_path)
+        if not path.exists():
+            logger.warning(f"File not found: {path}")
+            continue
+        prompt_files.append(path.resolve())
+
+    if not prompt_files:
+        logger.error("No valid prompt files specified")
+        raise ValueError("No valid prompt files specified")
+
+    # Initialize configuration
+    return PromptConfig(
+        name="prompt_server",
+        description="FastMCP Prompt Server",
+        template_variables=set(),
+        resource_paths=[],
+        file_path=Path(__file__),
+        prompt_files=prompt_files,
+        user_delimiter=args.user_delimiter,
+        assistant_delimiter=args.assistant_delimiter,
+        resource_delimiter=args.resource_delimiter,
+        http_timeout=args.http_timeout,
+        transport=args.transport,
+        port=args.port,
+    )
+
+
+async def register_file_resource_handler(config: PromptConfig) -> None:
     """Register the general file resource handler"""
 
     @mcp.resource("file://{path}")
@@ -279,14 +366,14 @@ async def register_file_resource_handler() -> None:
             raise
 
 
-async def test_prompt(prompt_name: str) -> int:
+async def test_prompt(prompt_name: str, config: PromptConfig) -> int:
     """Test a prompt and print its details"""
     if prompt_name not in prompt_registry:
         logger.error(f"Test prompt not found: {prompt_name}")
         return 1
 
     # Get delimiter configuration with reasonable defaults
-    config_values = get_delimiter_config()
+    config_values = get_delimiter_config(config)
 
     metadata = prompt_registry[prompt_name]
     print(f"\nTesting prompt: {prompt_name}")
@@ -326,64 +413,44 @@ async def test_prompt(prompt_name: str) -> int:
     return 0
 
 
-async def async_main():
+async def async_main() -> int:
     """Run the FastMCP server (async version)"""
-    global config
-
     # Parse command line arguments
     args = parse_args()
 
-    # Resolve file paths
-    prompt_files = []
-    for file_path in args.prompt_files:
-        path = Path(file_path)
-        if not path.exists():
-            logger.warning(f"File not found: {path}")
-            continue
-        prompt_files.append(path.resolve())
-
-    if not prompt_files:
-        logger.error("No valid prompt files specified")
+    try:
+        # Initialize configuration
+        config = initialize_config(args)
+    except ValueError as e:
+        logger.error(str(e))
         return 1
 
-    # Initialize configuration
-    config = PromptConfig(
-        name="prompt_server",
-        description="FastMCP Prompt Server",
-        template_variables=set(),
-        resource_paths=[],
-        file_path=Path(__file__),
-        prompt_files=prompt_files,
-        user_delimiter=args.user_delimiter,
-        assistant_delimiter=args.assistant_delimiter,
-        resource_delimiter=args.resource_delimiter,
-        http_timeout=args.http_timeout,
-        transport=args.transport,
-        port=args.port,
-    )
-
     # Register resource handlers
-    await register_file_resource_handler()
+    await register_file_resource_handler(config)
 
     # Register all prompts
     for file_path in config.prompt_files:
-        register_prompt(file_path)
+        register_prompt(file_path, config)
 
     # Print startup info
     logger.info("Starting prompt server")
     logger.info(f"Registered {len(prompt_registry)} prompts")
     logger.info(f"Registered {len(exposed_resources)} resources")
-    logger.info(f"Using delimiters: {config.user_delimiter}, {config.assistant_delimiter}, {config.resource_delimiter}")
+    logger.info(
+        f"Using delimiters: {config.user_delimiter}, {config.assistant_delimiter}, {config.resource_delimiter}"
+    )
 
     # If a test prompt was specified, print it and exit
     if args.test:
-        return await test_prompt(args.test)
+        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
-        await mcp.run_sse_async(port=config.port)
+        # TODO update to 2025-03-26 specification and test config.
+        await mcp.run_sse_async()
+    return 0
 
 
 def main() -> int:

mcp_agent/mcp/prompts/prompt_template.py

@@ -20,6 +20,12 @@ from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.prompt_serialization import (
     multipart_messages_to_delimited_format,
 )
+from mcp_agent.mcp.prompts.prompt_constants import (
+    ASSISTANT_DELIMITER,
+    DEFAULT_DELIMITER_MAP,
+    RESOURCE_DELIMITER,
+    USER_DELIMITER,
+)
 
 
 class PromptMetadata(BaseModel):
@@ -95,11 +101,7 @@ class PromptTemplate:
         """
         self.template_text = template_text
         self.template_file_path = template_file_path
-        self.delimiter_map = delimiter_map or {
-            "---USER": "user",
-            "---ASSISTANT": "assistant",
-            "---RESOURCE": "resource",
-        }
+        self.delimiter_map = delimiter_map or DEFAULT_DELIMITER_MAP
         self._template_variables = self._extract_template_variables(template_text)
         self._parsed_content = self._parse_template()
 
@@ -120,19 +122,17 @@ class PromptTemplate:
             A new PromptTemplate object
         """
         # Use default delimiter map if none provided
-        delimiter_map = delimiter_map or {
-            "---USER": "user",
-            "---ASSISTANT": "assistant",
-            "---RESOURCE": "resource",
-        }
+        delimiter_map = delimiter_map or DEFAULT_DELIMITER_MAP
 
         # Convert to delimited format
         delimited_content = multipart_messages_to_delimited_format(
             messages,
-            user_delimiter=next((k for k, v in delimiter_map.items() if v == "user"), "---USER"),
+            user_delimiter=next(
+                (k for k, v in delimiter_map.items() if v == "user"), USER_DELIMITER
+            ),
             assistant_delimiter=next(
                 (k for k, v in delimiter_map.items() if v == "assistant"),
-                "---ASSISTANT",
+                ASSISTANT_DELIMITER,
             ),
         )
 
@@ -162,12 +162,12 @@ class PromptTemplate:
         Returns:
             List of PromptContent with substitutions applied
         """
-        result = []
-        for section in self._parsed_content:
-            result.append(section.apply_substitutions(context))
-        return result
+        # Create a new list with substitutions applied to each section
+        return [section.apply_substitutions(context) for section in self._parsed_content]
 
-    def apply_substitutions_to_multipart(self, context: Dict[str, Any]) -> List[PromptMessageMultipart]:
+    def apply_substitutions_to_multipart(
+        self, context: Dict[str, Any]
+    ) -> List[PromptMessageMultipart]:
         """
         Apply variable substitutions to the template and return PromptMessageMultipart objects.
 
@@ -177,9 +177,11 @@ class PromptTemplate:
         Returns:
             List of PromptMessageMultipart objects with substitutions applied
         """
+        # First create a substituted template
         content_sections = self.apply_substitutions(context)
-        multiparts = []
 
+        # Convert content sections to multipart messages
+        multiparts = []
         for section in content_sections:
             # Handle text content
             content_items = [TextContent(type="text", text=section.text)]
@@ -329,11 +331,7 @@ class PromptTemplateLoader:
         Args:
             delimiter_map: Optional map of delimiters to roles
         """
-        self.delimiter_map = delimiter_map or {
-            "---USER": "user",
-            "---ASSISTANT": "assistant",
-            "---RESOURCE": "resource",
-        }
+        self.delimiter_map = delimiter_map or DEFAULT_DELIMITER_MAP
 
     def load_from_file(self, file_path: Path) -> PromptTemplate:
         """
@@ -360,17 +358,8 @@ class PromptTemplateLoader:
         Returns:
             A PromptTemplate object
         """
-        delimited_content = multipart_messages_to_delimited_format(
-            messages,
-            user_delimiter=next((k for k, v in self.delimiter_map.items() if v == "user"), "---USER"),
-            assistant_delimiter=next(
-                (k for k, v in self.delimiter_map.items() if v == "assistant"),
-                "---ASSISTANT",
-            ),
-        )
-
-        content = "\n".join(delimited_content)
-        return PromptTemplate(content, self.delimiter_map)
+        # Use the class method directly to avoid code duplication
+        return PromptTemplate.from_multipart_messages(messages, self.delimiter_map)
 
     def get_metadata(self, file_path: Path) -> PromptMetadata:
         """
@@ -432,7 +421,9 @@ class PromptTemplateLoader:
 
         # Extract resource paths from all sections that come after RESOURCE delimiters
         resource_paths = []
-        resource_delimiter = next((k for k, v in self.delimiter_map.items() if v == "resource"), "---RESOURCE")
+        resource_delimiter = next(
+            (k for k, v in self.delimiter_map.items() if v == "resource"), RESOURCE_DELIMITER
+        )
         for i, line in enumerate(lines):
             if line.strip() == resource_delimiter:
                 if i + 1 < len(lines) and lines[i + 1].strip():

mcp_agent/mcp/resource_utils.py

@@ -98,7 +98,9 @@ def create_resource_reference(uri: str, mime_type: str) -> "EmbeddedResource":
     return EmbeddedResource(type="resource", resource=resource_contents)
 
 
-def create_embedded_resource(resource_path: str, content: str, mime_type: str, is_binary: bool = False) -> EmbeddedResource:
+def create_embedded_resource(
+    resource_path: str, content: str, mime_type: str, is_binary: bool = False
+) -> EmbeddedResource:
     """Create an embedded resource content object"""
     # Format a valid resource URI string
     resource_uri_str = create_resource_uri(resource_path)

mcp_agent/mcp/sampling.py

@@ -2,21 +2,25 @@
 This simplified implementation directly converts between MCP types and PromptMessageMultipart.
 """
 
+from typing import TYPE_CHECKING
+
 from mcp import ClientSession
-from mcp.types import (
-    CreateMessageRequestParams,
-    CreateMessageResult,
-)
+from mcp.types import CreateMessageRequestParams, CreateMessageResult, TextContent
 
 from mcp_agent.core.agent_types import AgentConfig
+from mcp_agent.llm.sampling_converter import SamplingConverter
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
-from mcp_agent.workflows.llm.sampling_converter import SamplingConverter
+
+if TYPE_CHECKING:
+    from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 logger = get_logger(__name__)
 
 
-def create_sampling_llm(params: CreateMessageRequestParams, model_string: str) -> AugmentedLLMProtocol:
+def create_sampling_llm(
+    params: CreateMessageRequestParams, model_string: str
+) -> AugmentedLLMProtocol:
     """
     Create an LLM instance for sampling without tools support.
     This utility function creates a minimal LLM instance based on the model string.
@@ -29,7 +33,7 @@ def create_sampling_llm(params: CreateMessageRequestParams, model_string: str) -
         An initialized LLM instance ready to use
     """
     from mcp_agent.agents.agent import Agent
-    from mcp_agent.workflows.llm.model_factory import ModelFactory
+    from mcp_agent.llm.model_factory import ModelFactory
 
     app_context = None
     try:
@@ -100,19 +104,24 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
         # Extract request parameters using our converter
         request_params = SamplingConverter.extract_request_params(params)
 
-        # Use the new public apply_prompt method which is cleaner than calling the protected method
-        llm_response = await llm.apply_prompt(conversation, request_params)
-        logger.info(f"Complete sampling request : {llm_response[:50]}...")
+        llm_response: PromptMessageMultipart = await llm.generate(conversation, request_params)
+        logger.info(f"Complete sampling request : {llm_response.first_text()[:50]}...")
 
-        # Create result using our converter
-        return SamplingConverter.create_message_result(response=llm_response, model=model)
+        return CreateMessageResult(
+            role=llm_response.role,
+            content=TextContent(type="text", text=llm_response.first_text()),
+            model=model,
+            stopReason="endTurn",
+        )
     except Exception as e:
         logger.error(f"Error in sampling: {str(e)}")
-        return SamplingConverter.error_result(error_message=f"Error in sampling: {str(e)}", model=model)
+        return SamplingConverter.error_result(
+            error_message=f"Error in sampling: {str(e)}", model=model
+        )
 
 
 def sampling_agent_config(
-    params: CreateMessageRequestParams = None,
+    params: CreateMessageRequestParams | None = None,
 ) -> AgentConfig:
     """
     Build a sampling AgentConfig based on request parameters.
@@ -125,7 +134,7 @@ def sampling_agent_config(
     """
     # Use systemPrompt from params if available, otherwise use default
     instruction = "You are a helpful AI Agent."
-    if params and hasattr(params, "systemPrompt") and params.systemPrompt is not None:
+    if params and params.systemPrompt is not None:
         instruction = params.systemPrompt
 
     return AgentConfig(name="sampling_agent", instruction=instruction, servers=[])

mcp_agent/mcp_server/agent_server.py

@@ -3,8 +3,8 @@
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
 
-# Remove circular import
-from mcp_agent.core.agent_app import AgentApp
+# Import the DirectAgentApp instead of AgentApp
+from mcp_agent.core.direct_agent_app import DirectAgentApp
 
 
 class AgentMCPServer:
@@ -12,14 +12,15 @@ class AgentMCPServer:
 
     def __init__(
         self,
-        agent_app: AgentApp,
+        agent_app: DirectAgentApp,
         server_name: str = "FastAgent-MCP-Server",
         server_description: str = None,
     ) -> None:
         self.agent_app = agent_app
         self.mcp_server = FastMCP(
             name=server_name,
-            instructions=server_description or f"This server provides access to {len(agent_app.agents)} agents",
+            instructions=server_description
+            or f"This server provides access to {len(agent_app._agents)} agents",
         )
         self.setup_tools()
 
@@ -63,7 +64,9 @@ class AgentMCPServer:
 
         self.mcp_server.run(transport=transport)
 
-    async def run_async(self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000) -> None:
+    async def run_async(
+        self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000
+    ) -> None:
         """Run the MCP server asynchronously."""
         if transport == "sse":
             self.mcp_server.settings.host = host