fast-agent-mcp 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mcp_agent/core/enhanced_prompt.py

@@ -2,13 +2,13 @@
 Enhanced prompt functionality with advanced prompt_toolkit features.
 """
 
-from typing import List
+from typing import List, Optional
 from importlib.metadata import version
 from prompt_toolkit import PromptSession
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.completion import Completer, Completion, WordCompleter
 from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.filters import Condition
 from prompt_toolkit.styles import Style
@@ -330,6 +330,110 @@ async def get_enhanced_input(
         # Log and gracefully handle other exceptions
         print(f"\nInput error: {type(e).__name__}: {e}")
         return "STOP"
+    finally:
+        # Ensure the prompt session is properly cleaned up
+        # This is especially important on Windows to prevent resource leaks
+        if session.app.is_running:
+            session.app.exit()
+
+
+async def get_selection_input(
+    prompt_text: str,
+    options: List[str] = None,
+    default: str = None,
+    allow_cancel: bool = True,
+    complete_options: bool = True,
+) -> Optional[str]:
+    """
+    Display a selection prompt and return the user's selection.
+
+    Args:
+        prompt_text: Text to display as the prompt
+        options: List of valid options (for auto-completion)
+        default: Default value if user presses enter
+        allow_cancel: Whether to allow cancellation with empty input
+        complete_options: Whether to use the options for auto-completion
+
+    Returns:
+        Selected value, or None if cancelled
+    """
+    try:
+        # Initialize completer if options provided and completion requested
+        completer = WordCompleter(options) if options and complete_options else None
+
+        # Create prompt session
+        prompt_session = PromptSession(completer=completer)
+
+        try:
+            # Get user input
+            selection = await prompt_session.prompt_async(
+                prompt_text, default=default or ""
+            )
+
+            # Handle cancellation
+            if allow_cancel and not selection.strip():
+                return None
+
+            return selection
+        finally:
+            # Ensure prompt session cleanup
+            if prompt_session.app.is_running:
+                prompt_session.app.exit()
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as e:
+        rich_print(f"\n[red]Error getting selection: {e}[/red]")
+        return None
+
+
+async def get_argument_input(
+    arg_name: str,
+    description: str = None,
+    required: bool = True,
+) -> Optional[str]:
+    """
+    Prompt for an argument value with formatting and help text.
+
+    Args:
+        arg_name: Name of the argument
+        description: Optional description of the argument
+        required: Whether this argument is required
+
+    Returns:
+        Input value, or None if cancelled/skipped
+    """
+    # Format the prompt differently based on whether it's required
+    required_text = "(required)" if required else "(optional, press Enter to skip)"
+
+    # Show description if available
+    if description:
+        rich_print(f"  [dim]{arg_name}: {description}[/dim]")
+
+    prompt_text = HTML(
+        f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> {required_text}: "
+    )
+
+    # Create prompt session
+    prompt_session = PromptSession()
+
+    try:
+        # Get user input
+        arg_value = await prompt_session.prompt_async(prompt_text)
+
+        # For optional arguments, empty input means skip
+        if not required and not arg_value:
+            return None
+
+        return arg_value
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as e:
+        rich_print(f"\n[red]Error getting input: {e}[/red]")
+        return None
+    finally:
+        # Ensure prompt session cleanup
+        if prompt_session.app.is_running:
+            prompt_session.app.exit()
 
 
 async def handle_special_commands(command, agent_app=None):
@@ -408,24 +512,6 @@ async def handle_special_commands(command, agent_app=None):
             )
             return True
 
-    elif command == "SELECT_PROMPT" or (
-        isinstance(command, str) and command.startswith("SELECT_PROMPT:")
-    ):
-        # Handle prompt selection UI (previously named "list_prompts" action)
-        if agent_app:
-            # If it's a specific prompt, extract the name
-            prompt_name = None
-            if isinstance(command, str) and command.startswith("SELECT_PROMPT:"):
-                prompt_name = command.split(":", 1)[1].strip()
-
-            # Return a dictionary with a select_prompt action to be handled by the caller
-            return {"select_prompt": True, "prompt_name": prompt_name}
-        else:
-            rich_print(
-                "[yellow]Prompt selection is not available outside of an agent context[/yellow]"
-            )
-            return True
-
     elif isinstance(command, str) and command.startswith("SWITCH:"):
         agent_name = command.split(":", 1)[1]
         if agent_name in available_agents:

mcp_agent/core/factory.py

@@ -34,10 +34,7 @@ T = TypeVar("T")  # For the wrapper classes
 
 
 def create_proxy(
-    app: MCPApp,
-    name: str, 
-    instance: AgentOrWorkflow, 
-    agent_type: str
+    app: MCPApp, name: str, instance: AgentOrWorkflow, agent_type: str
 ) -> BaseAgentProxy:
     """Create appropriate proxy type based on agent type and validate instance type
 
@@ -61,9 +58,7 @@ def create_proxy(
         log_agent_load(app, name)
     if agent_type == AgentType.BASIC.value:
         if not isinstance(instance, Agent):
-            raise TypeError(
-                f"Expected Agent instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected Agent instance for {name}, got {type(instance)}")
         return LLMAgentProxy(app, name, instance)
     elif agent_type == AgentType.ORCHESTRATOR.value:
         if not isinstance(instance, Orchestrator):
@@ -177,42 +172,18 @@ async def create_agents_by_type(
             if agent_type == AgentType.BASIC:
                 # Get the agent name for special handling
                 agent_name = agent_data["config"].name
+                agent = Agent(config=config, context=app_instance.context)
 
-                # Check if this is an agent that should use the PassthroughLLM
-                if agent_name.endswith("_fan_in") or agent_name.startswith(
-                    "passthrough"
-                ):
-                    # Import here to avoid circular imports
-                    from mcp_agent.workflows.llm.augmented_llm import PassthroughLLM
-
-                    # Create basic agent with configuration
-                    agent = Agent(config=config, context=app_instance.context)
-
-                    # Set up a PassthroughLLM directly
-                    async with agent:
-                        agent._llm = PassthroughLLM(
-                            name=f"{config.name}_llm",
-                            context=app_instance.context,
-                            agent=agent,
-                            default_request_params=config.default_request_params,
-                        )
-
-                    # Store the agent
-                    instance = agent
-                else:
-                    # Standard basic agent with LLM
-                    agent = Agent(config=config, context=app_instance.context)
-
-                    # Set up LLM with proper configuration
-                    async with agent:
-                        llm_factory = model_factory_func(
-                            model=config.model,
-                            request_params=config.default_request_params,
-                        )
-                        agent._llm = await agent.attach_llm(llm_factory)
+                # Set up LLM with proper configuration
+                async with agent:
+                    llm_factory = model_factory_func(
+                        model=config.model,
+                        request_params=config.default_request_params,
+                    )
+                    agent._llm = await agent.attach_llm(llm_factory)
 
-                    # Store the agent
-                    instance = agent
+                # Store the agent
+                instance = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
                 # Get base params configured with model settings
@@ -276,12 +247,8 @@ async def create_agents_by_type(
 
             elif agent_type == AgentType.EVALUATOR_OPTIMIZER:
                 # Get the referenced agents - unwrap from proxies
-                generator = unwrap_proxy(
-                    active_agents[agent_data["generator"]]
-                )
-                evaluator = unwrap_proxy(
-                    active_agents[agent_data["evaluator"]]
-                )
+                generator = unwrap_proxy(active_agents[agent_data["generator"]])
+                evaluator = unwrap_proxy(active_agents[agent_data["evaluator"]])
 
                 if not generator or not evaluator:
                     raise ValueError(
@@ -294,7 +261,9 @@ async def create_agents_by_type(
                 optimizer_model = None
                 if isinstance(generator, Agent):
                     optimizer_model = generator.config.model
-                elif hasattr(generator, '_sequence') and hasattr(generator, '_agent_proxies'):
+                elif hasattr(generator, "_sequence") and hasattr(
+                    generator, "_agent_proxies"
+                ):
                     # For ChainProxy, use the config model directly
                     optimizer_model = config.model
 
@@ -311,9 +280,7 @@ async def create_agents_by_type(
 
             elif agent_type == AgentType.ROUTER:
                 # Get the router's agents - unwrap proxies
-                router_agents = get_agent_instances(
-                    agent_data["agents"], active_agents
-                )
+                router_agents = get_agent_instances(agent_data["agents"], active_agents)
 
                 # Create the router with proper configuration
                 llm_factory = model_factory_func(
@@ -376,20 +343,15 @@ async def create_agents_by_type(
                     "continue_with_final", True
                 )
                 # Set cumulative behavior from configuration
-                instance._cumulative = agent_data.get(
-                    "cumulative", False
-                )
+                instance._cumulative = agent_data.get("cumulative", False)
 
             elif agent_type == AgentType.PARALLEL:
-                # Get fan-out agents (could be basic agents or other parallels)
                 fan_out_agents = get_agent_instances(
                     agent_data["fan_out"], active_agents
                 )
 
                 # Get fan-in agent - unwrap proxy
-                fan_in_agent = unwrap_proxy(
-                    active_agents[agent_data["fan_in"]]
-                )
+                fan_in_agent = unwrap_proxy(active_agents[agent_data["fan_in"]])
 
                 # Create the parallel workflow
                 llm_factory = model_factory_func(config.model)
@@ -416,7 +378,7 @@ async def create_agents_by_type(
 
 
 async def create_basic_agents(
-    app_instance: MCPApp, 
+    app_instance: MCPApp,
     agents_dict: Dict[str, Dict[str, Any]],
     model_factory_func: Callable,
 ) -> ProxyDict:
@@ -432,17 +394,17 @@ async def create_basic_agents(
         Dictionary of initialized basic agents wrapped in appropriate proxies
     """
     return await create_agents_by_type(
-        app_instance, 
-        agents_dict, 
-        AgentType.BASIC, 
-        model_factory_func=model_factory_func
+        app_instance,
+        agents_dict,
+        AgentType.BASIC,
+        model_factory_func=model_factory_func,
     )
 
 
 async def create_agents_in_dependency_order(
-    app_instance: MCPApp, 
+    app_instance: MCPApp,
     agents_dict: Dict[str, Dict[str, Any]],
-    active_agents: ProxyDict, 
+    active_agents: ProxyDict,
     agent_type: AgentType,
     model_factory_func: Callable,
 ) -> ProxyDict:
@@ -498,4 +460,4 @@ async def create_agents_in_dependency_order(
                     if agent_name in agent_result:
                         result_agents[agent_name] = agent_result[agent_name]
 
-    return result_agents
+    return result_agents

mcp_agent/core/fastagent.py

@@ -70,7 +70,12 @@ class FastAgent(ContextDependent):
     Provides a simplified way to create and manage agents using decorators.
     """
 
-    def __init__(self, name: str, config_path: Optional[str] = None):
+    def __init__(
+        self,
+        name: str,
+        config_path: Optional[str] = None,
+        ignore_unknown_args: bool = False,
+    ):
         """
         Initialize the decorator interface.
 
@@ -101,7 +106,12 @@ class FastAgent(ContextDependent):
             action="store_true",
             help="Disable progress display, tool and message logging for cleaner output",
         )
-        self.args = parser.parse_args()
+
+        if ignore_unknown_args:
+            known_args, _ = parser.parse_known_args()
+            self.args = known_args
+        else:
+            self.args = parser.parse_args()
 
         # Quiet mode will be handled in _load_config()
 
@@ -372,7 +382,7 @@ class FastAgent(ContextDependent):
 
                 # Create wrapper with all agents
                 wrapper = AgentApp(agent_app, active_agents)
-                
+
                 # Store reference to AgentApp in MCPApp for proxies to access
                 agent_app._agent_app = wrapper
 

mcp_agent/core/mcp_content.py

@@ -0,0 +1,222 @@
+"""
+Helper functions for creating MCP content types with minimal code.
+
+This module provides simple functions to create TextContent, ImageContent,
+EmbeddedResource, and other MCP content types with minimal boilerplate.
+"""
+
+import base64
+from pathlib import Path
+from typing import Literal, Optional, Union, List, Any
+
+from mcp.types import (
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    TextResourceContents,
+    BlobResourceContents,
+)
+
+from mcp_agent.mcp.mime_utils import (
+    guess_mime_type,
+    is_binary_content,
+    is_image_mime_type,
+)
+
+
+def MCPText(
+    text: str,
+    role: Literal["user", "assistant"] = "user",
+    annotations: Optional[dict] = None,
+) -> dict:
+    """
+    Create a message with text content.
+
+    Args:
+        text: The text content
+        role: Role of the message, defaults to "user"
+        annotations: Optional annotations
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    return {
+        "role": role,
+        "content": TextContent(type="text", text=text, annotations=annotations),
+    }
+
+
+def MCPImage(
+    path: Union[str, Path] = None,
+    data: bytes = None,
+    mime_type: Optional[str] = None,
+    role: Literal["user", "assistant"] = "user",
+    annotations: Optional[dict] = None,
+) -> dict:
+    """
+    Create a message with image content.
+
+    Args:
+        path: Path to the image file
+        data: Raw image data bytes (alternative to path)
+        mime_type: Optional mime type, will be guessed from path if not provided
+        role: Role of the message, defaults to "user"
+        annotations: Optional annotations
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    if path is None and data is None:
+        raise ValueError("Either path or data must be provided")
+
+    if path is not None and data is not None:
+        raise ValueError("Only one of path or data can be provided")
+
+    if path is not None:
+        path = Path(path)
+        if not mime_type:
+            mime_type = guess_mime_type(str(path))
+        with open(path, "rb") as f:
+            data = f.read()
+
+    if not mime_type:
+        mime_type = "image/png"  # Default
+
+    b64_data = base64.b64encode(data).decode("ascii")
+
+    return {
+        "role": role,
+        "content": ImageContent(
+            type="image", data=b64_data, mimeType=mime_type, annotations=annotations
+        ),
+    }
+
+
+def MCPFile(
+    path: Union[str, Path],
+    mime_type: Optional[str] = None,
+    role: Literal["user", "assistant"] = "user",
+    annotations: Optional[dict] = None,
+) -> dict:
+    """
+    Create a message with an embedded resource from a file.
+
+    Args:
+        path: Path to the resource file
+        mime_type: Optional mime type, will be guessed from path if not provided
+        role: Role of the message, defaults to "user"
+        annotations: Optional annotations
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    path = Path(path)
+    uri = f"file://{path.absolute()}"
+
+    if not mime_type:
+        mime_type = guess_mime_type(str(path))
+
+    # Determine if this is text or binary content
+    is_binary = is_binary_content(mime_type)
+
+    if is_binary:
+        # Read as binary
+        binary_data = path.read_bytes()
+        b64_data = base64.b64encode(binary_data).decode("ascii")
+
+        resource = BlobResourceContents(uri=uri, blob=b64_data, mimeType=mime_type)
+    else:
+        # Read as text
+        try:
+            text_data = path.read_text(encoding="utf-8")
+            resource = TextResourceContents(uri=uri, text=text_data, mimeType=mime_type)
+        except UnicodeDecodeError:
+            # Fallback to binary if text read fails
+            binary_data = path.read_bytes()
+            b64_data = base64.b64encode(binary_data).decode("ascii")
+            resource = BlobResourceContents(
+                uri=uri, blob=b64_data, mimeType=mime_type or "application/octet-stream"
+            )
+
+    return {
+        "role": role,
+        "content": EmbeddedResource(
+            type="resource", resource=resource, annotations=annotations
+        ),
+    }
+
+
+
+def MCPPrompt(
+    *content_items, role: Literal["user", "assistant"] = "user"
+) -> List[dict]:
+    """
+    Create one or more prompt messages with various content types.
+
+    This function intelligently creates different content types:
+    - Strings become TextContent 
+    - File paths with image mime types become ImageContent
+    - File paths with text mime types or other mime types become EmbeddedResource
+    - Dicts with role and content are passed through unchanged
+    - Raw bytes become ImageContent
+
+    Args:
+        *content_items: Content items of various types
+        role: Role for all items (user or assistant)
+
+    Returns:
+        List of messages that can be used in a prompt
+    """
+    result = []
+
+    for item in content_items:
+        if isinstance(item, dict) and "role" in item and "content" in item:
+            # Already a fully formed message
+            result.append(item)
+        elif isinstance(item, str) and not Path(item).exists():
+            # Simple text content (that's not a file path)
+            result.append(MCPText(item, role=role))
+        elif isinstance(item, Path) or isinstance(item, str):
+            # File path - determine the content type based on mime type
+            path_str = str(item)
+            mime_type = guess_mime_type(path_str)
+            
+            if is_image_mime_type(mime_type):
+                # Image files (except SVG which is handled as text)
+                result.append(MCPImage(path=item, role=role))
+            else:
+                # All other file types (text documents, PDFs, SVGs, etc.)
+                result.append(MCPFile(path=item, role=role))
+        elif isinstance(item, bytes):
+            # Raw binary data, assume image
+            result.append(MCPImage(data=item, role=role))
+        else:
+            # Try to convert to string
+            result.append(MCPText(str(item), role=role))
+
+    return result
+
+
+def User(*content_items) -> List[dict]:
+    """Create user message(s) with various content types."""
+    return MCPPrompt(*content_items, role="user")
+
+
+def Assistant(*content_items) -> List[dict]:
+    """Create assistant message(s) with various content types."""
+    return MCPPrompt(*content_items, role="assistant")
+
+
+def create_message(content: Any, role: Literal["user", "assistant"] = "user") -> dict:
+    """
+    Create a single prompt message from content of various types.
+
+    Args:
+        content: Content of various types (str, Path, bytes, etc.)
+        role: Role of the message
+
+    Returns:
+        A dictionary with role and content that can be used in a prompt
+    """
+    messages = MCPPrompt(content, role=role)
+    return messages[0] if messages else {}