fast-agent-mcp 0.2.17__tar.gz → 0.2.18__tar.gz

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/.gitignore

@@ -194,3 +194,4 @@ tests/e2e/workflow/weather_location.txt
 tests/integration/prompt-state/multipart.json
 tests/integration/prompt-state/history.json
 !tests/integration/api/fastagent.secrets.yaml
+fastagent.jsonl

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.17
+Version: 0.2.18
 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
@@ -259,7 +259,8 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP]
+> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/README.md

@@ -18,7 +18,8 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP]
+> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 

fast_agent_mcp-0.2.18/examples/mcp/vision-examples/example1.py

@@ -0,0 +1,27 @@
+import asyncio
+from pathlib import Path
+
+from mcp_agent.core.fastagent import FastAgent
+from mcp_agent.core.prompt import Prompt
+
+# Create the application
+fast = FastAgent("fast-agent example")
+
+
+# Define the agent
+@fast.agent(instruction="You are a helpful AI Agent", servers=["filesystem"])
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent.default.generate(
+            [
+                Prompt.user(
+                    Path("cat.png"), "Write a report on the content of the image to 'report.md'"
+                )
+            ]
+        )
+        await agent.interactive()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fast_agent_mcp-0.2.18/examples/mcp/vision-examples/example2.py

@@ -0,0 +1,18 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("fast-agent example")
+
+
+# Define the agent
+@fast.agent(instruction="You are a helpful AI Agent", servers=["filesystem"])
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent.interactive()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fast_agent_mcp-0.2.18/examples/mcp/vision-examples/example3.py

@@ -0,0 +1,20 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("fast-agent example")
+
+
+# Define the agent
+@fast.agent(instruction="You are a helpful AI Agent", servers=["webcam", "hfspace"])
+async def main():
+    async with fast.run() as agent:
+        await agent.interactive(
+            default_prompt="take an image with the webcam, describe it to flux to "
+            "reproduce it and then judge the quality of the result"
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fast_agent_mcp-0.2.18/examples/mcp/vision-examples/fastagent.config.yaml

@@ -0,0 +1,47 @@
+# FastAgent Configuration File
+
+# Default Model Configuration:
+# 
+# Takes format:
+#   <provider>.<model_string>.<reasoning_effort?> (e.g. anthropic.claude-3-5-sonnet-20241022 or openai.o3-mini.low)
+# Accepts aliases for Anthropic Models: haiku, haiku3, sonnet, sonnet35, opus, opus3
+# and OpenAI Models: gpt-4.1, gpt-4.1-mini, o1, o1-mini, o3-mini
+#
+# If not specified, defaults to "haiku". 
+# Can be overriden with a command line switch --model=<model>, or within the Agent constructor.
+
+default_model: haiku
+
+# Logging and Console Configuration:
+logger:
+    # level: "debug" | "info" | "warning" | "error"
+    # type: "none" | "console" | "file" | "http"
+    # path: "/path/to/logfile.jsonl"
+
+    
+    # Switch the progress display on or off
+    progress_display: true
+
+    # Show chat User/Assistant messages on the console
+    show_chat: true
+    # Show tool calls on the console
+    show_tools: true
+    # Truncate long tool responses on the console 
+    truncate_tools: true
+
+# MCP Servers
+mcp:
+    servers:
+        fetch:
+            command: "uvx"
+            args: ["mcp-server-fetch"]
+        filesystem:
+            command: "npx"
+            args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
+        webcam: 
+            command: "npx"
+            args: ["-y","@llmindset/mcp-webcam"]
+        hfspace:
+            command: "npx"
+            args: ["-y","@llmindset/mcp-hfspace"]
+

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.17"
+version = "0.2.18"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

fast_agent_mcp-0.2.18/src/mcp_agent/cli/commands/go.py

@@ -0,0 +1,133 @@
+"""Run an interactive agent directly from the command line."""
+
+import asyncio
+import sys
+from typing import List, Optional
+
+import typer
+
+from mcp_agent.core.fastagent import FastAgent
+
+app = typer.Typer(
+    help="Run an interactive agent directly from the command line without creating an agent.py file"
+)
+
+async def _run_agent(
+    name: str = "FastAgent CLI",
+    instruction: str = "You are a helpful AI Agent.",
+    config_path: Optional[str] = None,
+    server_list: Optional[List[str]] = None,
+    model: Optional[str] = None,
+) -> None:
+    """Async implementation to run an interactive agent."""
+
+    # Create the FastAgent instance with CLI arg parsing enabled
+    # It will automatically parse args like --model, --quiet, etc.
+    fast_kwargs = {
+        "name": name,
+        "config_path": config_path,
+        "ignore_unknown_args": True,
+    }
+    
+    fast = FastAgent(**fast_kwargs)
+
+    # Define the agent with specified parameters
+    agent_kwargs = {"instruction": instruction}
+    if server_list:
+        agent_kwargs["servers"] = server_list
+    if model:
+        agent_kwargs["model"] = model
+    
+    @fast.agent(**agent_kwargs)
+    async def cli_agent():
+        async with fast.run() as agent:
+            await agent.interactive()
+
+    # Run the agent
+    await cli_agent()
+
+def run_async_agent(
+    name: str, 
+    instruction: str, 
+    config_path: Optional[str] = None, 
+    servers: Optional[str] = None,
+    model: Optional[str] = None
+):
+    """Run the async agent function with proper loop handling."""
+    server_list = servers.split(',') if servers else None
+    
+    # Check if we're already in an event loop
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # We're inside a running event loop, so we can't use asyncio.run
+            # Instead, create a new loop
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+    except RuntimeError:
+        # No event loop exists, so we'll create one
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    
+    try:
+        loop.run_until_complete(_run_agent(
+            name=name, 
+            instruction=instruction, 
+            config_path=config_path, 
+            server_list=server_list,
+            model=model
+        ))
+    finally:
+        try:
+            # Clean up the loop
+            tasks = asyncio.all_tasks(loop)
+            for task in tasks:
+                task.cancel()
+            
+            # Run the event loop until all tasks are done
+            if sys.version_info >= (3, 7):
+                loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+            loop.run_until_complete(loop.shutdown_asyncgens())
+            loop.close()
+        except Exception:
+            pass
+
+@app.callback(invoke_without_command=True)
+def go(
+    ctx: typer.Context,
+    name: str = typer.Option("FastAgent CLI", "--name", help="Name for the agent"),
+    instruction: str = typer.Option(
+        "You are a helpful AI Agent.", "--instruction", "-i", help="Instruction for the agent"
+    ),
+    config_path: Optional[str] = typer.Option(
+        None, "--config-path", "-c", help="Path to config file"
+    ),
+    servers: Optional[str] = typer.Option(
+        None, "--servers", help="Comma-separated list of server names to enable from config"
+    ),
+    model: Optional[str] = typer.Option(
+        None, "--model", help="Override the default model (e.g., haiku, sonnet, gpt-4)"
+    ),
+) -> None:
+    """
+    Run an interactive agent directly from the command line.
+
+    Example:
+        fast-agent go --model=haiku --instruction="You are a coding assistant" --servers=fetch,filesystem
+
+    This will start an interactive session with the agent, using the specified model
+    and instruction. It will use the default configuration from fastagent.config.yaml
+    unless --config-path is specified.
+
+    Common options:
+        --model: Override the default model (e.g., --model=haiku)
+        --quiet: Disable progress display and logging
+        --servers: Comma-separated list of server names to enable from config
+    """
+    run_async_agent(
+        name=name, 
+        instruction=instruction, 
+        config_path=config_path, 
+        servers=servers,
+        model=model
+    )

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/cli/commands/setup.py

@@ -221,7 +221,7 @@ def init(
         if "fastagent.secrets.yaml" in created:
             console.print("\n[yellow]Important:[/yellow] Remember to:")
             console.print(
-                "1. Add your API keys to fastagent.secrets.yaml or set OPENAI_API_KEY and ANTHROPIC_API_KEY environment variables"
+                "1. Add your API keys to fastagent.secrets.yaml, or set environment variables. Use [cyan]fast-agent check[/cyan] to verify."
             )
             console.print(
                 "2. Keep fastagent.secrets.yaml secure and never commit it to version control"

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/cli/main.py

@@ -4,7 +4,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from mcp_agent.cli.commands import check_config, quickstart, setup
+from mcp_agent.cli.commands import check_config, go, quickstart, setup
 from mcp_agent.cli.terminal import Application
 
 app = typer.Typer(
@@ -13,6 +13,7 @@ app = typer.Typer(
 )
 
 # Subcommands
+app.add_typer(go.app, name="go", help="Run an interactive agent directly from the command line")
 app.add_typer(setup.app, name="setup", help="Set up a new agent project")
 app.add_typer(check_config.app, name="check", help="Show or diagnose fast-agent configuration")
 app.add_typer(quickstart.app, name="bootstrap", help="Create example applications")
@@ -39,14 +40,15 @@ def show_welcome() -> None:
     table.add_column("Command", style="green")
     table.add_column("Description")
 
-    table.add_row("setup", "Create a new agent and configuration files")
+    table.add_row("[bold]go[/bold]", "Start an interactive session with an agent")
+    table.add_row("setup", "Create a new agent template and configuration files")
     table.add_row("check", "Show or diagnose fast-agent configuration")
     table.add_row("quickstart", "Create example applications (workflow, researcher, etc.)")
 
     console.print(table)
 
     console.print(
-        "\n[italic]get started with:[/italic] [cyan]fast-agent[/cyan] [green]setup[/green]"
+        "\n[italic]get started with:[/italic] [bold][cyan]fast-agent[/cyan][/bold] [green]setup[/green]"
     )
 
 

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/core/enhanced_prompt.py

@@ -289,14 +289,19 @@ async def get_enhanced_input(
                 # Return a dictionary with select_prompt action instead of a string
                 # This way it will match what the command handler expects
                 return {"select_prompt": True, "prompt_name": None}
-            elif cmd == "prompt" and len(cmd_parts) > 1:
-                # Direct prompt selection with name or number
-                prompt_arg = cmd_parts[1].strip()
-                # Check if it's a number (use as index) or a name (use directly)
-                if prompt_arg.isdigit():
-                    return {"select_prompt": True, "prompt_index": int(prompt_arg)}
+            elif cmd == "prompt":
+                # Handle /prompt with no arguments the same way as /prompts
+                if len(cmd_parts) > 1:
+                    # Direct prompt selection with name or number
+                    prompt_arg = cmd_parts[1].strip()
+                    # Check if it's a number (use as index) or a name (use directly)
+                    if prompt_arg.isdigit():
+                        return {"select_prompt": True, "prompt_index": int(prompt_arg)}
+                    else:
+                        return f"SELECT_PROMPT:{prompt_arg}"
                 else:
-                    return f"SELECT_PROMPT:{prompt_arg}"
+                    # If /prompt is used without arguments, treat it the same as /prompts
+                    return {"select_prompt": True, "prompt_name": None}
             elif cmd == "exit":
                 return "EXIT"
             elif cmd.lower() == "stop":

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/core/fastagent.py

@@ -9,7 +9,8 @@ import asyncio
 import sys
 from contextlib import asynccontextmanager
 from importlib.metadata import version as get_version
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypeVar
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, TypeVar
 
 import yaml
 
@@ -54,9 +55,11 @@ from mcp_agent.core.validation import (
     validate_workflow_references,
 )
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
 
 if TYPE_CHECKING:
     from mcp_agent.agents.agent import Agent
+    from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 F = TypeVar("F", bound=Callable[..., Any])  # For decorated functions
 logger = get_logger(__name__)
@@ -90,12 +93,16 @@ class FastAgent:
         )
         parser.add_argument(
             "--agent",
+            default="default",
             help="Specify the agent to send a message to (used with --message)",
         )
         parser.add_argument(
             "-m",
             "--message",
-            help="Message to send to the specified agent (requires --agent)",
+            help="Message to send to the specified agent",
+        )
+        parser.add_argument(
+            "-p", "--prompt-file", help="Path to a prompt file to use (either text or JSON)"
         )
         parser.add_argument(
             "--quiet",
@@ -294,8 +301,8 @@ class FastAgent:
                     # Exit after server shutdown
                     raise SystemExit(0)
 
-                # Handle direct message sending if --agent and --message are provided
-                if hasattr(self, "args") and self.args.agent and self.args.message:
+                # Handle direct message sending if  --message is provided
+                if self.args.message:
                     agent_name = self.args.agent
                     message = self.args.message
 
@@ -321,6 +328,33 @@ class FastAgent:
                         print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
                         raise SystemExit(1)
 
+                if self.args.prompt_file:
+                    agent_name = self.args.agent
+                    prompt: List[PromptMessageMultipart] = load_prompt_multipart(
+                        Path(self.args.prompt_file)
+                    )
+                    if agent_name not in active_agents:
+                        available_agents = ", ".join(active_agents.keys())
+                        print(
+                            f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}"
+                        )
+                        raise SystemExit(1)
+
+                    try:
+                        # Get response from the agent
+                        agent = active_agents[agent_name]
+                        response = await agent.generate(prompt)
+
+                        # In quiet mode, just print the raw response
+                        # The chat display should already be turned off by the configuration
+                        if self.args.quiet:
+                            print(f"{response.last_text()}")
+
+                        raise SystemExit(0)
+                    except Exception as e:
+                        print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
+                        raise SystemExit(1)
+
                 yield wrapper
 
         except (

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/core/interactive_prompt.py

@@ -153,8 +153,12 @@ class InteractivePrompt:
                             )
                         continue
 
-                # Skip further processing if command was handled
-                if command_result:
+                # Skip further processing if:
+                # 1. The command was handled (command_result is truthy)
+                # 2. The original input was a dictionary (special command like /prompt)
+                # 3. The command result itself is a dictionary (special command handling result)
+                # This fixes the issue where /prompt without arguments gets sent to the LLM
+                if command_result or isinstance(user_input, dict) or isinstance(command_result, dict):
                     continue
 
                 if user_input.upper() == "STOP":

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/core/validation.py

@@ -231,6 +231,12 @@ def get_dependencies_groups(
         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", []))
+            # Also add explicit fan_out dependencies if present
+            if "fan_out" in agent_data:
+                dependencies[name].update(agent_data["fan_out"])
+            # Add explicit fan_in dependency if present
+            if "fan_in" in agent_data and agent_data["fan_in"]:
+                dependencies[name].add(agent_data["fan_in"])
         elif agent_type == AgentType.CHAIN.value:
             # Chain agents depend on the agents in their sequence
             dependencies[name].update(agent_data.get("sequence", []))
@@ -241,7 +247,12 @@ def get_dependencies_groups(
             # 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
+            # Evaluator-Optimizer agents depend on their evaluator and generator agents
+            if "evaluator" in agent_data:
+                dependencies[name].add(agent_data["evaluator"])
+            if "generator" in agent_data:
+                dependencies[name].add(agent_data["generator"])
+            # For backward compatibility - also check eval_optimizer_agents if present
             dependencies[name].update(agent_data.get("eval_optimizer_agents", []))
 
     # Check for cycles if not allowed

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -347,10 +347,11 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
         request_params = self.get_request_params(request_params)
 
+        # TODO - convert this to use Tool Calling convention for Anthropic Structured outputs
         multipart_messages[-1].add_text(
             """YOU MUST RESPOND IN THE FOLLOWING FORMAT:
             {schema}
-            RESPOND ONLY WITH THE JSON, NO PREAMBLE OR CODE FENCES """.format(
+            RESPOND ONLY WITH THE JSON, NO PREAMBLE, CODE FENCES OR 'properties' ARE PERMISSABLE """.format(
                 schema=model.model_json_schema()
             )
         )

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -8,9 +8,7 @@ DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type mo
 
 class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__(
-            *args, provider=Provider.DEEPSEEK, **kwargs
-        )  # Properly pass args and kwargs to parent
+        super().__init__(*args, provider=Provider.DEEPSEEK, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Deepseek-specific default parameters"""

{fast_agent_mcp-0.2.17 → fast_agent_mcp-0.2.18}/src/mcp_agent/llm/providers/augmented_llm_openai.py

@@ -222,7 +222,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                         method="tools/call",
                         params=CallToolRequestParams(
                             name=tool_call.function.name,
-                            arguments=from_json(tool_call.function.arguments, allow_partial=True),
+                            arguments={} if not tool_call.function.arguments or tool_call.function.arguments.strip() == '' else from_json(tool_call.function.arguments, allow_partial=True),
                         ),
                     )
                     result = await self.call_tool(tool_call_request, tool_call.id)