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

mcp_agent/core/interactive_prompt.py

@@ -0,0 +1,424 @@
+"""
+Interactive prompt functionality for agents.
+
+This module provides interactive command-line functionality for agents,
+extracted from the original AgentApp implementation to support the new DirectAgentApp.
+
+Usage:
+    prompt = InteractivePrompt()
+    await prompt.prompt_loop(
+        send_func=agent_app.send,
+        default_agent="default_agent",
+        available_agents=["agent1", "agent2"],
+        apply_prompt_func=agent_app.apply_prompt
+    )
+"""
+
+from typing import Dict, List, Optional
+
+from rich import print as rich_print
+from rich.console import Console
+from rich.table import Table
+
+from mcp_agent.core.enhanced_prompt import (
+    get_argument_input,
+    get_enhanced_input,
+    get_selection_input,
+    handle_special_commands,
+)
+from mcp_agent.progress_display import progress_display
+
+
+class InteractivePrompt:
+    """
+    Provides interactive prompt functionality that works with any agent implementation.
+    This is extracted from the original AgentApp implementation to support DirectAgentApp.
+    """
+
+    def __init__(self, agent_types: Optional[Dict[str, str]] = None) -> None:
+        """
+        Initialize the interactive prompt.
+
+        Args:
+            agent_types: Dictionary mapping agent names to their types for display
+        """
+        self.agent_types = agent_types or {}
+
+    async def prompt_loop(
+        self,
+        send_func,
+        default_agent: str,
+        available_agents: List[str],
+        apply_prompt_func=None,
+        list_prompts_func=None,
+        default: str = "",
+    ) -> str:
+        """
+        Start an interactive prompt session.
+
+        Args:
+            send_func: Function to send messages to agents (signature: async (message, agent_name))
+            default_agent: Name of the default agent to use
+            available_agents: List of available agent names
+            apply_prompt_func: Optional function to apply prompts (signature: async (name, args, agent))
+            list_prompts_func: Optional function to list available prompts (signature: async (agent_name))
+            default: Default message to use when user presses enter
+
+        Returns:
+            The result of the interactive session
+        """
+        agent = default_agent
+        if not agent:
+            if available_agents:
+                agent = available_agents[0]
+            else:
+                raise ValueError("No default agent available")
+
+        if agent not in available_agents:
+            raise ValueError(f"No agent named '{agent}'")
+
+        # Create agent_types dictionary if not provided
+        available_agents_set = set(available_agents)
+
+        result = ""
+        while True:
+            with progress_display.paused():
+                # Use the enhanced input method with advanced features
+                user_input = await get_enhanced_input(
+                    agent_name=agent,
+                    default=default,
+                    show_default=(default != ""),
+                    show_stop_hint=True,
+                    multiline=False,  # Default to single-line mode
+                    available_agent_names=available_agents,
+                    agent_types=self.agent_types,  # Pass agent types for display
+                )
+
+                # Handle special commands - pass "True" to enable agent switching
+                command_result = await handle_special_commands(user_input, True)
+
+                # Check if we should switch agents
+                if isinstance(command_result, dict):
+                    if "switch_agent" in command_result:
+                        new_agent = command_result["switch_agent"]
+                        if new_agent in available_agents_set:
+                            agent = new_agent
+                            continue
+                        else:
+                            rich_print(f"[red]Agent '{new_agent}' not found[/red]")
+                            continue
+                    elif "list_prompts" in command_result and list_prompts_func:
+                        # Use the list_prompts_func directly
+                        await self._list_prompts(list_prompts_func, agent)
+                        continue
+                    elif "select_prompt" in command_result and (list_prompts_func and apply_prompt_func):
+                        # Handle prompt selection, using both list_prompts and apply_prompt
+                        prompt_name = command_result.get("prompt_name")
+                        await self._select_prompt(list_prompts_func, apply_prompt_func, agent, prompt_name)
+                        continue
+
+                # Skip further processing if command was handled
+                if command_result:
+                    continue
+
+                if user_input.upper() == "STOP":
+                    return result
+                if user_input == "":
+                    continue
+
+            # Send the message to the agent
+            result = await send_func(user_input, agent)
+
+        return result
+
+    async def _list_prompts(self, list_prompts_func, agent_name) -> None:
+        """
+        List available prompts for an agent.
+
+        Args:
+            list_prompts_func: Function to get available prompts
+            agent_name: Name of the agent
+        """
+        from rich import print as rich_print
+
+        try:
+            # Directly call the list_prompts function for this agent
+            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
+            
+            prompt_servers = await list_prompts_func(agent_name)
+            
+            # Process the returned prompt servers
+            if prompt_servers:
+                found_prompts = False
+                for server_name, prompts_info in prompt_servers.items():
+                    if prompts_info and hasattr(prompts_info, "prompts") and prompts_info.prompts:
+                        rich_print(f"\n[bold cyan]{server_name}:[/bold cyan]")
+                        for prompt in prompts_info.prompts:
+                            rich_print(f"  {prompt.name}")
+                        found_prompts = True
+                    elif isinstance(prompts_info, list) and prompts_info:
+                        rich_print(f"\n[bold cyan]{server_name}:[/bold cyan]")
+                        for prompt in prompts_info:
+                            if isinstance(prompt, dict) and "name" in prompt:
+                                rich_print(f"  {prompt['name']}")
+                            else:
+                                rich_print(f"  {prompt}")
+                        found_prompts = True
+
+                if not found_prompts:
+                    rich_print("[yellow]No prompts available[/yellow]")
+            else:
+                rich_print("[yellow]No prompts available[/yellow]")
+        except Exception as e:
+            import traceback
+            rich_print(f"[red]Error listing prompts: {e}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+
+    async def _select_prompt(self, list_prompts_func, apply_prompt_func, agent_name, requested_name=None) -> None:
+        """
+        Select and apply a prompt.
+
+        Args:
+            list_prompts_func: Function to get available prompts
+            apply_prompt_func: Function to apply prompts
+            agent_name: Name of the agent
+            requested_name: Optional name of the prompt to apply
+        """
+        # We already imported these at the top
+        from rich import print as rich_print
+
+        console = Console()
+
+        try:
+            # Get all available prompts directly from the list_prompts function
+            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
+            prompt_servers = await list_prompts_func(agent_name)
+
+            if not prompt_servers:
+                rich_print("[yellow]No prompts available for this agent[/yellow]")
+                return
+
+            # Process fetched prompts
+            all_prompts = []
+            for server_name, prompts_info in prompt_servers.items():
+                if not prompts_info:
+                    continue
+
+                # Extract prompts
+                prompts = []
+                if hasattr(prompts_info, "prompts"):
+                    prompts = prompts_info.prompts
+                elif isinstance(prompts_info, list):
+                    prompts = prompts_info
+
+                # Process each prompt
+                for prompt in prompts:
+                    # Get basic prompt info
+                    prompt_name = getattr(prompt, "name", "Unknown")
+                    description = getattr(prompt, "description", "No description")
+
+                    # Extract argument information
+                    arg_names = []
+                    required_args = []
+                    optional_args = []
+                    arg_descriptions = {}
+
+                    # Get arguments list
+                    arguments = getattr(prompt, "arguments", None)
+                    if arguments:
+                        for arg in arguments:
+                            name = getattr(arg, "name", None)
+                            if name:
+                                arg_names.append(name)
+
+                                # Store description if available
+                                description = getattr(arg, "description", None)
+                                if description:
+                                    arg_descriptions[name] = description
+
+                                # Check if required
+                                if getattr(arg, "required", False):
+                                    required_args.append(name)
+                                else:
+                                    optional_args.append(name)
+
+                    # Create namespaced version
+                    namespaced_name = f"{server_name}-{prompt_name}"
+
+                    # Add to collection
+                    all_prompts.append(
+                        {
+                            "server": server_name,
+                            "name": prompt_name,
+                            "namespaced_name": namespaced_name,
+                            "description": description,
+                            "arg_count": len(arg_names),
+                            "arg_names": arg_names,
+                            "required_args": required_args,
+                            "optional_args": optional_args,
+                            "arg_descriptions": arg_descriptions,
+                        }
+                    )
+
+            if not all_prompts:
+                rich_print("[yellow]No prompts available for this agent[/yellow]")
+                return
+
+            # Sort prompts by server then name
+            all_prompts.sort(key=lambda p: (p["server"], p["name"]))
+
+            # Handle specifically requested prompt
+            if requested_name:
+                matching_prompts = [
+                    p
+                    for p in all_prompts
+                    if p["name"] == requested_name or p["namespaced_name"] == requested_name
+                ]
+
+                if not matching_prompts:
+                    rich_print(f"[red]Prompt '{requested_name}' not found[/red]")
+                    rich_print("[yellow]Available prompts:[/yellow]")
+                    for p in all_prompts:
+                        rich_print(f"  {p['namespaced_name']}")
+                    return
+
+                # If exactly one match, use it
+                if len(matching_prompts) == 1:
+                    selected_prompt = matching_prompts[0]
+                else:
+                    # Handle multiple matches
+                    rich_print(f"[yellow]Multiple prompts match '{requested_name}':[/yellow]")
+                    for i, p in enumerate(matching_prompts):
+                        rich_print(f"  {i + 1}. {p['namespaced_name']} - {p['description']}")
+
+                    # Get user selection
+                    selection = (
+                        await get_selection_input("Enter prompt number to select: ", default="1")
+                        or ""
+                    )
+
+                    try:
+                        idx = int(selection) - 1
+                        if 0 <= idx < len(matching_prompts):
+                            selected_prompt = matching_prompts[idx]
+                        else:
+                            rich_print("[red]Invalid selection[/red]")
+                            return
+                    except ValueError:
+                        rich_print("[red]Invalid input, please enter a number[/red]")
+                        return
+            else:
+                # Show prompt selection UI
+                table = Table(title="Available MCP Prompts")
+                table.add_column("#", justify="right", style="cyan")
+                table.add_column("Server", style="green")
+                table.add_column("Prompt Name", style="bright_blue")
+                table.add_column("Description")
+                table.add_column("Args", justify="center")
+
+                # Add prompts to table
+                for i, prompt in enumerate(all_prompts):
+                    required_args = prompt["required_args"]
+                    optional_args = prompt["optional_args"]
+
+                    # Format args column
+                    if required_args and optional_args:
+                        args_display = f"[bold]{len(required_args)}[/bold]+{len(optional_args)}"
+                    elif required_args:
+                        args_display = f"[bold]{len(required_args)}[/bold]"
+                    elif optional_args:
+                        args_display = f"{len(optional_args)} opt"
+                    else:
+                        args_display = "0"
+
+                    table.add_row(
+                        str(i + 1),
+                        prompt["server"],
+                        prompt["name"],
+                        prompt["description"] or "No description",
+                        args_display,
+                    )
+
+                console.print(table)
+                prompt_names = [str(i + 1) for i in range(len(all_prompts))]
+
+                # Get user selection
+                selection = await get_selection_input(
+                    "Enter prompt number to select (or press Enter to cancel): ",
+                    options=prompt_names,
+                    allow_cancel=True,
+                )
+
+                # Handle cancellation
+                if not selection or selection.strip() == "":
+                    rich_print("[yellow]Prompt selection cancelled[/yellow]")
+                    return
+
+                try:
+                    idx = int(selection) - 1
+                    if 0 <= idx < len(all_prompts):
+                        selected_prompt = all_prompts[idx]
+                    else:
+                        rich_print("[red]Invalid selection[/red]")
+                        return
+                except ValueError:
+                    rich_print("[red]Invalid input, please enter a number[/red]")
+                    return
+
+            # Get prompt arguments
+            required_args = selected_prompt["required_args"]
+            optional_args = selected_prompt["optional_args"]
+            arg_descriptions = selected_prompt.get("arg_descriptions", {})
+            arg_values = {}
+
+            # Show argument info if any
+            if required_args or optional_args:
+                if required_args and optional_args:
+                    rich_print(
+                        f"\n[bold]Prompt [cyan]{selected_prompt['name']}[/cyan] requires {len(required_args)} arguments and has {len(optional_args)} optional arguments:[/bold]"
+                    )
+                elif required_args:
+                    rich_print(
+                        f"\n[bold]Prompt [cyan]{selected_prompt['name']}[/cyan] requires {len(required_args)} arguments:[/bold]"
+                    )
+                elif optional_args:
+                    rich_print(
+                        f"\n[bold]Prompt [cyan]{selected_prompt['name']}[/cyan] has {len(optional_args)} optional arguments:[/bold]"
+                    )
+
+                # Collect required arguments
+                for arg_name in required_args:
+                    description = arg_descriptions.get(arg_name, "")
+                    arg_value = await get_argument_input(
+                        arg_name=arg_name,
+                        description=description,
+                        required=True,
+                    )
+                    if arg_value is not None:
+                        arg_values[arg_name] = arg_value
+
+                # Collect optional arguments
+                if optional_args:
+                    for arg_name in optional_args:
+                        description = arg_descriptions.get(arg_name, "")
+                        arg_value = await get_argument_input(
+                            arg_name=arg_name,
+                            description=description,
+                            required=False,
+                        )
+                        if arg_value:
+                            arg_values[arg_name] = arg_value
+
+            # Apply the prompt
+            rich_print(
+                f"\n[bold]Applying prompt [cyan]{selected_prompt['namespaced_name']}[/cyan]...[/bold]"
+            )
+
+            # Call apply_prompt function with the prompt name and arguments
+            await apply_prompt_func(selected_prompt["namespaced_name"], arg_values, agent_name)
+
+        except Exception as e:
+            import traceback
+
+            rich_print(f"[red]Error selecting or applying prompt: {e}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")

mcp_agent/core/mcp_content.py

@@ -10,12 +10,14 @@ from pathlib import Path
 from typing import Any, List, Literal, Optional, Union
 
 from mcp.types import (
+    Annotations,
     BlobResourceContents,
     EmbeddedResource,
     ImageContent,
     TextContent,
     TextResourceContents,
 )
+from pydantic import AnyUrl
 
 from mcp_agent.mcp.mime_utils import (
     guess_mime_type,
@@ -27,7 +29,7 @@ from mcp_agent.mcp.mime_utils import (
 def MCPText(
     text: str,
     role: Literal["user", "assistant"] = "user",
-    annotations: Optional[dict] = None,
+    annotations: Annotations = None,
 ) -> dict:
     """
     Create a message with text content.
@@ -47,11 +49,11 @@ def MCPText(
 
 
 def MCPImage(
-    path: Union[str, Path] = None,
-    data: bytes = None,
+    path: str | Path | None = None,
+    data: bytes | None = None,
     mime_type: Optional[str] = None,
     role: Literal["user", "assistant"] = "user",
-    annotations: Optional[dict] = None,
+    annotations: Annotations | None = None,
 ) -> dict:
     """
     Create a message with image content.
@@ -86,7 +88,9 @@ def MCPImage(
 
     return {
         "role": role,
-        "content": ImageContent(type="image", data=b64_data, mimeType=mime_type, annotations=annotations),
+        "content": ImageContent(
+            type="image", data=b64_data, mimeType=mime_type, annotations=annotations
+        ),
     }
 
 
@@ -94,7 +98,7 @@ def MCPFile(
     path: Union[str, Path],
     mime_type: Optional[str] = None,
     role: Literal["user", "assistant"] = "user",
-    annotations: Optional[dict] = None,
+    annotations: Annotations | None = None,
 ) -> dict:
     """
     Create a message with an embedded resource from a file.
@@ -122,17 +126,19 @@ def MCPFile(
         binary_data = path.read_bytes()
         b64_data = base64.b64encode(binary_data).decode("ascii")
 
-        resource = BlobResourceContents(uri=uri, blob=b64_data, mimeType=mime_type)
+        resource = BlobResourceContents(uri=AnyUrl(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)
+            resource = TextResourceContents(uri=AnyUrl(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")
+            resource = BlobResourceContents(
+                uri=AnyUrl(uri), blob=b64_data, mimeType=mime_type or "application/octet-stream"
+            )
 
     return {
         "role": role,
@@ -140,7 +146,9 @@ def MCPFile(
     }
 
 
-def MCPPrompt(*content_items, role: Literal["user", "assistant"] = "user") -> List[dict]:
+def MCPPrompt(
+    *content_items: Union[dict, str, Path, bytes], role: Literal["user", "assistant"] = "user"
+) -> List[dict]:
     """
     Create one or more prompt messages with various content types.
 
@@ -164,7 +172,7 @@ def MCPPrompt(*content_items, role: Literal["user", "assistant"] = "user") -> Li
         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():
+        elif isinstance(item, str):
             # Simple text content (that's not a file path)
             result.append(MCPText(item, role=role))
         elif isinstance(item, Path) or isinstance(item, str):

mcp_agent/core/prompt.py

@@ -54,10 +54,14 @@ class Prompt:
             A PromptMessageMultipart with assistant role and the specified content
         """
         messages = Assistant(*content_items)
-        return PromptMessageMultipart(role="assistant", content=[msg["content"] for msg in messages])
+        return PromptMessageMultipart(
+            role="assistant", content=[msg["content"] for msg in messages]
+        )
 
     @classmethod
-    def message(cls, *content_items, role: Literal["user", "assistant"] = "user") -> PromptMessageMultipart:
+    def message(
+        cls, *content_items, role: Literal["user", "assistant"] = "user"
+    ) -> PromptMessageMultipart:
         """
         Create a PromptMessageMultipart with the specified role and content items.
 

mcp_agent/core/validation.py

@@ -10,7 +10,7 @@ from mcp_agent.core.exceptions import (
     CircularDependencyError,
     ServerConfigError,
 )
-from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
+from mcp_agent.llm.augmented_llm import AugmentedLLM
 
 
 def validate_server_references(context, agents: Dict[str, Dict[str, Any]]) -> None:
@@ -56,7 +56,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
         if agent_type == AgentType.PARALLEL.value:
             # Check fan_in exists
             fan_in = agent_data["fan_in"]
-            if fan_in not in available_components:
+            if fan_in and fan_in not in available_components:
                 raise AgentConfigError(
                     f"Parallel workflow '{name}' references non-existent fan_in component: {fan_in}"
                 )
@@ -106,7 +106,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
 
         elif agent_type == AgentType.ROUTER.value:
             # Check all referenced agents exist
-            router_agents = agent_data["agents"]
+            router_agents = agent_data["router_agents"]
             missing = [a for a in router_agents if a not in available_components]
             if missing:
                 raise AgentConfigError(
@@ -187,7 +187,7 @@ def get_dependencies(
             deps.extend(get_dependencies(fan_out, agents, visited, path, agent_type))
     elif config["type"] == AgentType.CHAIN.value:
         # Get dependencies from sequence agents
-        sequence = config.get("sequence", config.get("agents", []))
+        sequence = config.get("sequence", config.get("router_agents", []))
         for agent_name in sequence:
             deps.extend(get_dependencies(agent_name, agents, visited, path, agent_type))
 
@@ -199,23 +199,96 @@ def get_dependencies(
     return deps
 
 
-def get_parallel_dependencies(
-    name: str, agents: Dict[str, Dict[str, Any]], visited: set, path: set
-) -> List[str]:
+def get_dependencies_groups(
+    agents_dict: Dict[str, Dict[str, Any]], allow_cycles: bool = False
+) -> List[List[str]]:
     """
-    Get dependencies for a parallel agent in topological order.
-    Legacy function that calls the more general get_dependencies.
+    Get dependencies between agents and group them into dependency layers.
+    Each layer can be initialized in parallel.
 
     Args:
-        name: Name of the parallel agent
-        agents: Dictionary of agent configurations
-        visited: Set of already visited agents
-        path: Current path for cycle detection
+        agents_dict: Dictionary of agent configurations
+        allow_cycles: Whether to allow cyclic dependencies
 
     Returns:
-        List of agent names in dependency order
+        List of lists, where each inner list is a group of agents that can be initialized together
 
     Raises:
-        CircularDependencyError: If circular dependency detected
+        CircularDependencyError: If circular dependency detected and allow_cycles is False
     """
-    return get_dependencies(name, agents, visited, path, AgentType.PARALLEL)
+    # Get all agent names
+    agent_names = list(agents_dict.keys())
+
+    # Dictionary to store dependencies for each agent
+    dependencies = {name: set() for name in agent_names}
+
+    # Build the dependency graph
+    for name, agent_data in agents_dict.items():
+        agent_type = agent_data["type"]
+
+        if agent_type == AgentType.PARALLEL.value:
+            # Parallel agents depend on their fan-out and fan-in agents
+            dependencies[name].update(agent_data.get("parallel_agents", []))
+        elif agent_type == AgentType.CHAIN.value:
+            # Chain agents depend on the agents in their sequence
+            dependencies[name].update(agent_data.get("chain_agents", []))
+        elif agent_type == AgentType.ROUTER.value:
+            # Router agents depend on the agents they route to
+            dependencies[name].update(agent_data.get("router_agents", []))
+        elif agent_type == AgentType.ORCHESTRATOR.value:
+            # Orchestrator agents depend on their child agents
+            dependencies[name].update(agent_data.get("child_agents", []))
+        elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
+            # Evaluator-Optimizer agents depend on their evaluation and optimization agents
+            dependencies[name].update(agent_data.get("eval_optimizer_agents", []))
+
+    # Check for cycles if not allowed
+    if not allow_cycles:
+        visited = set()
+        path = set()
+
+        def visit(node) -> None:
+            if node in path:
+                path_str = " -> ".join(path) + " -> " + node
+                raise CircularDependencyError(f"Circular dependency detected: {path_str}")
+            if node in visited:
+                return
+
+            path.add(node)
+            for dep in dependencies[node]:
+                if dep in agent_names:  # Skip dependencies to non-existent agents
+                    visit(dep)
+            path.remove(node)
+            visited.add(node)
+
+        # Check each node
+        for name in agent_names:
+            if name not in visited:
+                visit(name)
+
+    # Group agents by dependency level
+    result = []
+    remaining = set(agent_names)
+
+    while remaining:
+        # Find all agents that have no remaining dependencies
+        current_level = set()
+        for name in remaining:
+            if not dependencies[name] & remaining:  # If no dependencies in remaining agents
+                current_level.add(name)
+
+        if not current_level:
+            if allow_cycles:
+                # If cycles are allowed, just add one remaining node to break the cycle
+                current_level.add(next(iter(remaining)))
+            else:
+                # This should not happen if we checked for cycles
+                raise CircularDependencyError("Unresolvable dependency cycle detected")
+
+        # Add the current level to the result
+        result.append(list(current_level))
+
+        # Remove current level from remaining
+        remaining -= current_level
+
+    return result