fast-agent-mcp 0.0.11__tar.gz → 0.0.13__tar.gz

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/.gitignore

@@ -179,3 +179,4 @@ examples/**/*.jsonl
 mcp_agent.config.yaml
 mcp_agent.secrets.yaml
 fastagent.secrets.yaml
+CLAUDE.md

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.0.11
+Version: 0.0.13
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -217,6 +217,7 @@ Requires-Dist: numpy>=2.2.1
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
+Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyyaml>=6.0.2
@@ -268,9 +269,16 @@ Other bootstrap examples include a Researcher (with Evaluator-Optimizer workflow
 
 > Windows Users - there are a couple of configuration changes needed for the Filesystem and Docker MCP Servers - necessary changes are detailed within the configuration files.
 
+## Agent Development
+
+FastAgent lets you interact with Agents during a workflow, enabling "warm-up" and diagnostic prompting to improve behaviour and refine prompts.
+
+## MCP Server Development
+
 ### llmindset.co.uk fork:
 
 - "FastAgent" style prototyping, with per-agent models
+- Api keys through Environment Variables
 - Warm-up / Post-Workflow Agent Interactions
 - Quick Setup
 - Interactive Prompt Mode

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/README.md

@@ -32,9 +32,16 @@ Other bootstrap examples include a Researcher (with Evaluator-Optimizer workflow
 
 > Windows Users - there are a couple of configuration changes needed for the Filesystem and Docker MCP Servers - necessary changes are detailed within the configuration files.
 
+## Agent Development
+
+FastAgent lets you interact with Agents during a workflow, enabling "warm-up" and diagnostic prompting to improve behaviour and refine prompts.
+
+## MCP Server Development
+
 ### llmindset.co.uk fork:
 
 - "FastAgent" style prototyping, with per-agent models
+- Api keys through Environment Variables
 - Warm-up / Post-Workflow Agent Interactions
 - Quick Setup
 - Interactive Prompt Mode

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.0.11"
+version = "0.0.13"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -29,6 +29,7 @@ dependencies = [
     "scikit-learn>=1.6.0",
     "anthropic>=0.42.0",
     "openai>=1.63.2",
+    "prompt-toolkit>=3.0.50",
 ]
 
 [project.optional-dependencies]

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/src/mcp_agent/agents/agent.py

@@ -11,6 +11,7 @@ from mcp.types import (
     Tool,
 )
 
+from mcp_agent.core.exceptions import PromptExitError
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 from mcp_agent.workflows.llm.augmented_llm import RequestParams
 from mcp_agent.human_input.types import (
@@ -24,6 +25,7 @@ from mcp_agent.logging.logger import get_logger
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
+import traceback
 
 logger = get_logger(__name__)
 
@@ -148,10 +150,7 @@ class Agent(MCPAggregator):
         """
         await super().close()
 
-    async def request_human_input(
-        self,
-        request: HumanInputRequest,
-    ) -> str:
+    async def request_human_input(self, request: HumanInputRequest) -> str:
         """
         Request input from a human user. Pauses the workflow until input is received.
 
@@ -170,14 +169,23 @@ class Agent(MCPAggregator):
         # Generate a unique ID for this request to avoid signal collisions
         request_id = f"{HUMAN_INPUT_SIGNAL_NAME}_{self.name}_{uuid.uuid4()}"
         request.request_id = request_id
-
+        # Use metadata as a dictionary to pass agent name
+        request.metadata = {"agent_name": self.name}
         self.logger.debug("Requesting human input:", data=request)
 
         async def call_callback_and_signal():
             try:
                 user_input = await self.human_input_callback(request)
+
                 self.logger.debug("Received human input:", data=user_input)
                 await self.executor.signal(signal_name=request_id, payload=user_input)
+            except PromptExitError as e:
+                # Propagate the exit error through the signal system
+                self.logger.info("User requested to exit session")
+                await self.executor.signal(
+                    signal_name=request_id,
+                    payload={"exit_requested": True, "error": str(e)},
+                )
             except Exception as e:
                 await self.executor.signal(
                     request_id, payload=f"Error getting human input: {str(e)}"
@@ -197,6 +205,10 @@ class Agent(MCPAggregator):
             signal_type=HumanInputResponse,  # TODO: saqadri - should this be HumanInputResponse?
         )
 
+        if isinstance(result, dict) and result.get("exit_requested", False):
+            raise PromptExitError(
+                result.get("error", "User requested to exit FastAgent session")
+            )
         self.logger.debug("Received human input signal", data=result)
         return result
 
@@ -253,13 +265,39 @@ class Agent(MCPAggregator):
     ) -> CallToolResult:
         # Handle human input request
         try:
-            request = HumanInputRequest(**arguments.get("request"))
-            result: HumanInputResponse = await self.request_human_input(request=request)
+            # Make sure arguments is not None
+            if arguments is None:
+                arguments = {}
+
+            # Extract request data
+            request_data = arguments.get("request")
+
+            # Handle both string and dict request formats
+            if isinstance(request_data, str):
+                request = HumanInputRequest(prompt=request_data)
+            elif isinstance(request_data, dict):
+                request = HumanInputRequest(**request_data)
+            else:
+                # Fallback for invalid or missing request data
+                request = HumanInputRequest(prompt="Please provide input:")
+
+            result = await self.request_human_input(request=request)
+
+            # Use response attribute if available, otherwise use the result directly
+            response_text = (
+                result.response
+                if isinstance(result, HumanInputResponse)
+                else str(result)
+            )
+
             return CallToolResult(
                 content=[
-                    TextContent(type="text", text=f"Human response: {result.response}")
+                    TextContent(type="text", text=f"Human response: {response_text}")
                 ]
             )
+
+        except PromptExitError:
+            raise
         except TimeoutError as e:
             return CallToolResult(
                 isError=True,
@@ -271,6 +309,8 @@ class Agent(MCPAggregator):
                 ],
             )
         except Exception as e:
+            print(f"Error in _call_human_input_tool: {traceback.format_exc()}")
+
             return CallToolResult(
                 isError=True,
                 content=[

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/src/mcp_agent/cli/commands/bootstrap.py

@@ -26,6 +26,7 @@ EXAMPLE_TYPES = {
             "orchestrator.py",
             "parallel.py",
             "router.py",
+            "fastagent.config.yaml",
         ],
         "create_subdir": False,
     },
@@ -33,11 +34,7 @@ EXAMPLE_TYPES = {
         "description": "Research agent example with additional evaluation/optimization\n"
         "example. Uses Brave Search and Docker MCP Servers.\n"
         "Creates examples in a 'researcher' subdirectory.",
-        "files": [
-            "researcher.py",
-            "researcher-eval.py",
-            "mcp_agent.secrets.yaml.example",
-        ],
+        "files": ["researcher.py", "researcher-eval.py", "fastagent.config.yaml"],
         "create_subdir": True,
     },
     "data-analysis": {

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/src/mcp_agent/cli/commands/setup.py

@@ -119,7 +119,7 @@ fast = FastAgent("FastAgent Example")
 
 
 # Define the agent
-@fast.agent(servers=["fetch"])
+@fast.agent(instruction="You are a helpful AI Agent", servers=["fetch"])
 async def main():
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/src/mcp_agent/cli/main.py

@@ -32,7 +32,7 @@ def show_welcome():
 
     table.add_row("setup", "Set up a new agent project with configuration files")
     table.add_row(
-        "bootstrap", "Create example applications (decorator, researcher, etc.)"
+        "bootstrap", "Create example applications (workflow, researcher, etc.)"
     )
     # table.add_row("config", "Manage agent configuration settings")
 
@@ -40,11 +40,11 @@ def show_welcome():
 
     console.print("\n[bold]Getting Started:[/bold]")
     console.print("1. Set up a new project:")
-    console.print("   mcp-agent setup")
-    console.print("\n2. Try an example:")
-    console.print("   mcp-agent bootstrap create decorator")
+    console.print("   fastagent setup")
+    console.print("\n2. Try an example workflow:")
+    console.print("   fastagent bootstrap create workflow")
     console.print("\nUse --help with any command for more information")
-    console.print("Example: mcp-agent bootstrap --help")
+    console.print("Example: fastagent bootstrap --help")
 
 
 @app.callback(invoke_without_command=True)
@@ -56,7 +56,7 @@ def main(
         True, "--color/--no-color", help="Enable/disable color output"
     ),
 ):
-    """MCP Agent CLI - Build effective agents using Model Context Protocol (MCP).
+    """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
 
     Use --help with any command for detailed usage information.
     """

fast_agent_mcp-0.0.13/src/mcp_agent/core/enhanced_prompt.py

@@ -0,0 +1,358 @@
+"""
+Enhanced prompt functionality with advanced prompt_toolkit features.
+"""
+
+from typing import List
+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.lexers import PygmentsLexer
+from prompt_toolkit.filters import Condition
+from pygments.lexers.python import PythonLexer
+from rich import print as rich_print
+
+from mcp_agent.core.exceptions import PromptExitError
+
+# Map of agent names to their history
+agent_histories = {}
+
+# Store available agents for auto-completion
+available_agents = set()
+
+# Keep track of multi-line mode state
+in_multiline_mode = False
+
+# Track which agents have already shown welcome messages
+agent_messages_shown = set()
+
+
+class AgentCompleter(Completer):
+    """Provide completion for agent names and common commands."""
+
+    def __init__(
+        self,
+        agents: List[str],
+        commands: List[str] = None,
+        agent_types: dict = None,
+        is_human_input: bool = False,
+    ):
+        self.agents = agents
+        # Map commands to their descriptions for better completion hints
+        self.commands = {
+            "help": "Show available commands",
+            "clear": "Clear the screen",
+            "agents": "List available agents",
+            "STOP": "Stop this prompting session and move to next workflow step",
+            "EXIT": "Exit FastAgent, terminating any running workflows",
+            **(commands or {}),  # Allow custom commands to be passed in
+        }
+        if is_human_input:
+            self.commands.pop("agents")
+        self.agent_types = agent_types or {}
+
+    def get_completions(self, document, complete_event):
+        """Synchronous completions method - this is what prompt_toolkit expects by default"""
+        text = document.text_before_cursor.lower()
+
+        # Complete commands
+        if text.startswith("/"):
+            cmd = text[1:]
+            for command, description in self.commands.items():
+                if command.lower().startswith(cmd):
+                    yield Completion(
+                        command,
+                        start_position=-len(cmd),
+                        display=command,
+                        display_meta=description,
+                    )
+
+        # Complete agent names for agent-related commands
+        elif text.startswith("@"):
+            agent_name = text[1:]
+            for agent in self.agents:
+                if agent.lower().startswith(agent_name.lower()):
+                    # Get agent type or default to "Agent"
+                    agent_type = self.agent_types.get(agent, "Agent")
+                    yield Completion(
+                        agent,
+                        start_position=-len(agent_name),
+                        display=agent,
+                        display_meta=agent_type,
+                        style="bg:ansiblack fg:ansiblue",
+                    )
+
+
+def create_keybindings(on_toggle_multiline=None, app=None):
+    """Create custom key bindings."""
+    kb = KeyBindings()
+
+    @kb.add("c-m", filter=Condition(lambda: not in_multiline_mode))
+    def _(event):
+        """Enter: accept input when not in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-m", filter=Condition(lambda: in_multiline_mode))
+    def _(event):
+        """Enter: insert newline when in multiline mode."""
+        event.current_buffer.insert_text("\n")
+
+    # Use c-j (Ctrl+J) as an alternative to represent Ctrl+Enter in multiline mode
+    @kb.add("c-j", filter=Condition(lambda: in_multiline_mode))
+    def _(event):
+        """Ctrl+J (equivalent to Ctrl+Enter): Submit in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-t")
+    def _(event):
+        """Ctrl+T: Toggle multiline mode."""
+        global in_multiline_mode
+        in_multiline_mode = not in_multiline_mode
+
+        # Force redraw the app to update toolbar
+        if event.app:
+            event.app.invalidate()
+        elif app:
+            app.invalidate()
+
+        # Call the toggle callback if provided
+        if on_toggle_multiline:
+            on_toggle_multiline(in_multiline_mode)
+
+        # Instead of printing, we'll just update the toolbar
+        # The toolbar will show the current mode
+
+    @kb.add("c-l")
+    def _(event):
+        """Ctrl+L: Clear the input buffer."""
+        event.current_buffer.text = ""
+
+    return kb
+
+
+async def get_enhanced_input(
+    agent_name: str,
+    default: str = "",
+    show_default: bool = False,
+    show_stop_hint: bool = False,
+    multiline: bool = False,
+    available_agent_names: List[str] = None,
+    syntax: str = None,
+    agent_types: dict = None,
+    is_human_input: bool = False,
+    toolbar_color: str = "ansiblue",
+) -> str:
+    """
+    Enhanced input with advanced prompt_toolkit features.
+
+    Args:
+        agent_name: Name of the agent (used for prompt and history)
+        default: Default value if user presses enter
+        show_default: Whether to show the default value in the prompt
+        show_stop_hint: Whether to show the STOP hint
+        multiline: Start in multiline mode
+        available_agent_names: List of agent names for auto-completion
+        syntax: Syntax highlighting (e.g., 'python', 'sql')
+        agent_types: Dictionary mapping agent names to their types for display
+        is_human_input: Whether this is a human input request (disables agent selection features)
+        toolbar_color: Color to use for the agent name in the toolbar (default: "ansiblue")
+
+    Returns:
+        User input string
+    """
+    global in_multiline_mode, available_agents
+
+    # Update global state
+    in_multiline_mode = multiline
+    if available_agent_names:
+        available_agents = set(available_agent_names)
+
+    # Get or create history object for this agent
+    if agent_name not in agent_histories:
+        agent_histories[agent_name] = InMemoryHistory()
+
+    # Define callback for multiline toggle
+    def on_multiline_toggle(enabled):
+        nonlocal session
+        if hasattr(session, "app") and session.app:
+            session.app.invalidate()
+
+    # Define toolbar function that will update dynamically
+    def get_toolbar():
+        if in_multiline_mode:
+            mode_style = "ansired"  # More noticeable for multiline mode
+            mode_text = "MULTILINE"
+            toggle_text = "Normal Editing"
+        else:
+            mode_style = "ansigreen"
+            mode_text = "NORMAL"
+            toggle_text = "Multiline Editing"
+
+        shortcuts = [
+            ("Ctrl+T", toggle_text),
+            ("Ctrl+L", "Clear"),
+            ("↑/↓", "History"),
+        ]
+
+        newline = (
+            "Ctrl+<Enter>:Submit" if in_multiline_mode else "<Enter>:Submit"
+        )
+
+        # Only show relevant shortcuts based on mode
+        shortcuts = [(k, v) for k, v in shortcuts if v]
+
+        shortcut_text = " | ".join(f"{key}:{action}" for key, action in shortcuts)
+        return HTML(
+            f" <{toolbar_color}> {agent_name} </{toolbar_color}> | <b>Mode:</b> <{mode_style}> {mode_text} </{mode_style}> {newline} | {shortcut_text}"
+        )
+
+    # Create session with history and completions
+    session = PromptSession(
+        history=agent_histories[agent_name],
+        completer=AgentCompleter(
+            agents=list(available_agents) if available_agents else [],
+            agent_types=agent_types or {},
+            is_human_input=is_human_input,
+        ),
+        complete_while_typing=True,
+        lexer=PygmentsLexer(PythonLexer) if syntax == "python" else None,
+        multiline=Condition(lambda: in_multiline_mode),
+        complete_in_thread=True,
+        mouse_support=False,
+        bottom_toolbar=get_toolbar,  # Pass the function here
+    )
+
+    # Create key bindings with a reference to the app
+    bindings = create_keybindings(
+        on_toggle_multiline=on_multiline_toggle, app=session.app
+    )
+    session.app.key_bindings = bindings
+
+    # Create formatted prompt text
+    prompt_text = f"<ansicyan>{agent_name}</ansicyan> > "
+
+    # Add default value display if requested
+    if show_default and default and default != "STOP":
+        prompt_text = f"{prompt_text} [<ansigreen>{default}</ansigreen>] "
+
+    # Only show hints at startup if requested
+    if show_stop_hint:
+        if default == "STOP":
+            rich_print("[yellow]Press <ENTER> to finish.[/yellow]")
+        else:
+            rich_print("Enter a prompt, or [red]STOP[/red] to finish")
+            if default:
+                rich_print(
+                    f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
+                )
+
+    # Mention available features but only on first usage for this agent
+    if agent_name not in agent_messages_shown:
+        if is_human_input:
+            rich_print(
+                "[dim]Tip: Type /help for commands. Ctrl+T toggles multiline mode. Ctrl+Enter to submit in multiline mode.[/dim]"
+            )
+        else:
+            rich_print(
+                "[dim]Tip: Type /help for commands, @Agent to switch agent. Ctrl+T toggles multiline mode. [/dim]"
+            )
+        agent_messages_shown.add(agent_name)
+
+    # Process special commands
+    def pre_process_input(text):
+        # Command processing
+        if text and text.startswith("/"):
+            cmd = text[1:].strip().lower()
+            if cmd == "help":
+                return "HELP"
+            elif cmd == "clear":
+                return "CLEAR"
+            elif cmd == "agents":
+                return "LIST_AGENTS"
+            elif cmd == "exit":
+                return "EXIT"
+            elif cmd == "stop":
+                return "STOP"
+
+        # Agent switching
+        if text and text.startswith("@"):
+            return f"SWITCH:{text[1:].strip()}"
+
+        return text
+
+    # Get the input - using async version
+    try:
+        result = await session.prompt_async(HTML(prompt_text), default=default)
+        return pre_process_input(result)
+    except KeyboardInterrupt:
+        # Handle Ctrl+C gracefully
+        return "STOP"
+    except EOFError:
+        # Handle Ctrl+D gracefully
+        return "STOP"
+    except Exception as e:
+        # Log and gracefully handle other exceptions
+        print(f"\nInput error: {type(e).__name__}: {e}")
+        return "STOP"
+
+
+async def handle_special_commands(command, agent_app=None):
+    """Handle special input commands."""
+    # Quick guard for empty or None commands
+    if not command:
+        return False
+
+    # Check for special commands
+    if command == "HELP":
+        rich_print("\n[bold]Available Commands:[/bold]")
+        rich_print("  /help          - Show this help")
+        rich_print("  /clear         - Clear screen")
+        rich_print("  /agents        - List available agents")
+        rich_print("  @agent_name    - Switch to agent")
+        rich_print("  STOP           - Return control back to the workflow")
+        rich_print(
+            "  EXIT           - Exit FastAgent, terminating any running workflows"
+        )
+        rich_print("\n[bold]Keyboard Shortcuts:[/bold]")
+        rich_print(
+            "  Enter          - Submit (normal mode) / New line (multiline mode)"
+        )
+        rich_print("  Ctrl+Enter      - Always submit (even in multiline mode)")
+        rich_print("  Ctrl+T         - Toggle multiline mode")
+        rich_print("  Ctrl+L         - Clear input")
+        rich_print("  Up/Down        - Navigate history")
+        return True
+
+    elif command == "CLEAR":
+        # Clear screen (ANSI escape sequence)
+        print("\033c", end="")
+        return True
+
+    elif command == "EXIT":
+        raise PromptExitError("User requested to exit FastAgent session")
+
+    elif command == "LIST_AGENTS":
+        if available_agents:
+            rich_print("\n[bold]Available Agents:[/bold]")
+            for agent in sorted(available_agents):
+                rich_print(f"  @{agent}")
+        else:
+            rich_print("[yellow]No agents available[/yellow]")
+        return True
+
+    elif isinstance(command, str) and command.startswith("SWITCH:"):
+        agent_name = command.split(":", 1)[1]
+        if agent_name in available_agents:
+            if agent_app:
+                rich_print(f"[green]Switching to agent: {agent_name}[/green]")
+                return {"switch_agent": agent_name}
+            else:
+                rich_print(
+                    "[yellow]Agent switching not available in this context[/yellow]"
+                )
+        else:
+            rich_print(f"[red]Unknown agent: {agent_name}[/red]")
+        return True
+
+    return False

{fast_agent_mcp-0.0.11 → fast_agent_mcp-0.0.13}/src/mcp_agent/core/exceptions.py

@@ -45,3 +45,20 @@ class ServerInitializationError(FastAgentError):
 
     def __init__(self, message: str, details: str = ""):
         super().__init__(message, details)
+
+
+class ModelConfigError(FastAgentError):
+    """Raised when there are issues with LLM model configuration
+    Example: Unknown model name in model specification string
+    """
+
+    def __init__(self, message: str, details: str = ""):
+        super().__init__(message, details)
+
+
+class PromptExitError(FastAgentError):
+    """Raised from enhanced_prompt when the user requests hard exits"""
+
+    # TODO an exception for flow control :(
+    def __init__(self, message: str, details: str = ""):
+        super().__init__(message, details)