fast-agent-mcp 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

mcp_agent/context.py

@@ -9,6 +9,8 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 from mcp import ServerSession
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -51,7 +53,7 @@ class Context(BaseModel):
     server_registry: Optional[ServerRegistry] = None
     task_registry: Optional[ActivityRegistry] = None
 
-    tracer: Optional[trace.Tracer] = None
+    tracer: trace.Tracer | None = None
 
     model_config = ConfigDict(
         extra="allow",
@@ -63,19 +65,19 @@ async def configure_otel(config: "Settings") -> None:
     """
     Configure OpenTelemetry based on the application config.
     """
-    if not config.otel.enabled:
-        return
-
-    # Check if a provider is already set to avoid re-initialization
-    if trace.get_tracer_provider().__class__.__name__ != "NoOpTracerProvider":
+    if not config.otel or not config.otel.enabled:
         return
 
     # Set up global textmap propagator first
     set_global_textmap(TraceContextTextMapPropagator())
 
     service_name = config.otel.service_name
-    service_instance_id = config.otel.service_instance_id
-    service_version = config.otel.service_version
+    from importlib.metadata import version
+
+    try:
+        app_version = version("fast-agent-mcp")
+    except:  # noqa: E722
+        app_version = "unknown"
 
     # Create resource identifying this service
     resource = Resource.create(
@@ -83,8 +85,7 @@ async def configure_otel(config: "Settings") -> None:
             key: value
             for key, value in {
                 "service.name": service_name,
-                "service.instance.id": service_instance_id,
-                "service.version": service_version,
+                "service.version": app_version,
             }.items()
             if value is not None
         }
@@ -107,6 +108,8 @@ async def configure_otel(config: "Settings") -> None:
 
     # Set as global tracer provider
     trace.set_tracer_provider(tracer_provider)
+    AnthropicInstrumentor().instrument()
+    OpenAIInstrumentor().instrument()
 
 
 async def configure_logger(config: "Settings") -> None:

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":

mcp_agent/core/fastagent.py

@@ -9,9 +9,11 @@ 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
+from opentelemetry import trace
 
 from mcp_agent import config
 from mcp_agent.app import MCPApp
@@ -54,9 +56,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__)
@@ -73,77 +77,97 @@ class FastAgent:
         name: str,
         config_path: str | None = None,
         ignore_unknown_args: bool = False,
+        parse_cli_args: bool = True,  # Add new parameter with default True
     ) -> None:
         """
-        Initialize the DirectFastAgent application.
+        Initialize the fast-agent application.
 
         Args:
             name: Name of the application
             config_path: Optional path to config file
             ignore_unknown_args: Whether to ignore unknown command line arguments
+                                 when parse_cli_args is True.
+            parse_cli_args: If True, parse command line arguments using argparse.
+                            Set to False when embedding FastAgent in another framework
+                            (like FastAPI/Uvicorn) that handles its own arguments.
         """
-        # Setup command line argument parsing
-        parser = argparse.ArgumentParser(description="DirectFastAgent Application")
-        parser.add_argument(
-            "--model",
-            help="Override the default model for all agents",
-        )
-        parser.add_argument(
-            "--agent",
-            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)",
-        )
-        parser.add_argument(
-            "--quiet",
-            action="store_true",
-            help="Disable progress display, tool and message logging for cleaner output",
-        )
-        parser.add_argument(
-            "--version",
-            action="store_true",
-            help="Show version and exit",
-        )
-        parser.add_argument(
-            "--server",
-            action="store_true",
-            help="Run as an MCP server",
-        )
-        parser.add_argument(
-            "--transport",
-            choices=["sse", "stdio"],
-            default="sse",
-            help="Transport protocol to use when running as a server (sse or stdio)",
-        )
-        parser.add_argument(
-            "--port",
-            type=int,
-            default=8000,
-            help="Port to use when running as a server with SSE transport",
-        )
-        parser.add_argument(
-            "--host",
-            default="0.0.0.0",
-            help="Host address to bind to when running as a server with SSE transport",
-        )
-
-        if ignore_unknown_args:
-            known_args, _ = parser.parse_known_args()
-            self.args = known_args
-        else:
-            self.args = parser.parse_args()
+        self.args = argparse.Namespace()  # Initialize args always
+
+        # --- Wrap argument parsing logic ---
+        if parse_cli_args:
+            # Setup command line argument parsing
+            parser = argparse.ArgumentParser(description="DirectFastAgent Application")
+            parser.add_argument(
+                "--model",
+                help="Override the default model for all agents",
+            )
+            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",
+            )
+            parser.add_argument(
+                "-p", "--prompt-file", help="Path to a prompt file to use (either text or JSON)"
+            )
+            parser.add_argument(
+                "--quiet",
+                action="store_true",
+                help="Disable progress display, tool and message logging for cleaner output",
+            )
+            parser.add_argument(
+                "--version",
+                action="store_true",
+                help="Show version and exit",
+            )
+            parser.add_argument(
+                "--server",
+                action="store_true",
+                help="Run as an MCP server",
+            )
+            parser.add_argument(
+                "--transport",
+                choices=["sse", "stdio"],
+                default="sse",
+                help="Transport protocol to use when running as a server (sse or stdio)",
+            )
+            parser.add_argument(
+                "--port",
+                type=int,
+                default=8000,
+                help="Port to use when running as a server with SSE transport",
+            )
+            parser.add_argument(
+                "--host",
+                default="0.0.0.0",
+                help="Host address to bind to when running as a server with SSE transport",
+            )
 
-        # Handle version flag
-        if self.args.version:
-            try:
-                app_version = get_version("fast-agent-mcp")
-            except:  # noqa: E722
-                app_version = "unknown"
-            print(f"fast-agent-mcp v{app_version}")
-            sys.exit(0)
+            if ignore_unknown_args:
+                known_args, _ = parser.parse_known_args()
+                self.args = known_args
+            else:
+                # Use parse_known_args here too, to avoid crashing on uvicorn args etc.
+                # even if ignore_unknown_args is False, we only care about *our* args.
+                known_args, unknown = parser.parse_known_args()
+                self.args = known_args
+                # Optionally, warn about unknown args if not ignoring?
+                # if unknown and not ignore_unknown_args:
+                #     logger.warning(f"Ignoring unknown command line arguments: {unknown}")
+
+            # Handle version flag
+            if self.args.version:
+                try:
+                    app_version = get_version("fast-agent-mcp")
+                except:  # noqa: E722
+                    app_version = "unknown"
+                print(f"fast-agent-mcp v{app_version}")
+                sys.exit(0)
+        # --- End of wrapped logic ---
 
         self.name = name
         self.config_path = config_path
@@ -213,137 +237,175 @@ class FastAgent:
         had_error = False
         await self.app.initialize()
 
-        # Handle quiet mode
-        quiet_mode = hasattr(self, "args") and self.args.quiet
-
-        try:
-            async with self.app.run():
-                # Apply quiet mode if requested
-                if (
-                    quiet_mode
-                    and hasattr(self.app.context, "config")
-                    and hasattr(self.app.context.config, "logger")
-                ):
-                    # Update our app's config directly
-                    self.app.context.config.logger.progress_display = False
-                    self.app.context.config.logger.show_chat = False
-                    self.app.context.config.logger.show_tools = False
-
-                    # Directly disable the progress display singleton
-                    from mcp_agent.progress_display import progress_display
-
-                    progress_display.stop()
-
-                # Pre-flight validation
-                if 0 == len(self.agents):
-                    raise AgentConfigError("No agents defined. Please define at least one agent.")
-                validate_server_references(self.context, self.agents)
-                validate_workflow_references(self.agents)
-
-                # Get a model factory function
-                def model_factory_func(model=None, request_params=None):
-                    return get_model_factory(
-                        self.context,
-                        model=model,
-                        request_params=request_params,
-                        cli_model=self.args.model if hasattr(self, "args") else None,
-                    )
-
-                # Create all agents in dependency order
-                active_agents = await create_agents_in_dependency_order(
-                    self.app,
-                    self.agents,
-                    model_factory_func,
-                )
-
-                # Create a wrapper with all agents for simplified access
-                wrapper = AgentApp(active_agents)
-
-                # Handle command line options that should be processed after agent initialization
-
-                # Handle --server option
-                if hasattr(self, "args") and self.args.server:
-                    try:
-                        # Print info message if not in quiet mode
-                        if not quiet_mode:
-                            print(f"Starting FastAgent '{self.name}' in server mode")
-                            print(f"Transport: {self.args.transport}")
-                            if self.args.transport == "sse":
-                                print(f"Listening on {self.args.host}:{self.args.port}")
-                            print("Press Ctrl+C to stop")
-
-                        # Create the MCP server
-                        from mcp_agent.mcp_server import AgentMCPServer
-
-                        mcp_server = AgentMCPServer(
-                            agent_app=wrapper,
-                            server_name=f"{self.name}-MCP-Server",
-                        )
-
-                        # Run the server directly (this is a blocking call)
-                        await mcp_server.run_async(
-                            transport=self.args.transport, host=self.args.host, port=self.args.port
+        # Handle quiet mode and CLI model override safely
+        # Define these *before* they are used, checking if self.args exists and has the attributes
+        quiet_mode = hasattr(self.args, "quiet") and self.args.quiet
+        cli_model_override = (
+            self.args.model if hasattr(self.args, "model") and self.args.model else None
+        )  # Define cli_model_override here
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(self.name):
+            try:
+                async with self.app.run():
+                    # Apply quiet mode if requested
+                    if (
+                        quiet_mode
+                        and hasattr(self.app.context, "config")
+                        and hasattr(self.app.context.config, "logger")
+                    ):
+                        # Update our app's config directly
+                        self.app.context.config.logger.progress_display = False
+                        self.app.context.config.logger.show_chat = False
+                        self.app.context.config.logger.show_tools = False
+
+                        # Directly disable the progress display singleton
+                        from mcp_agent.progress_display import progress_display
+
+                        progress_display.stop()
+
+                    # Pre-flight validation
+                    if 0 == len(self.agents):
+                        raise AgentConfigError(
+                            "No agents defined. Please define at least one agent."
                         )
-                    except KeyboardInterrupt:
-                        if not quiet_mode:
-                            print("\nServer stopped by user (Ctrl+C)")
-                    except Exception as e:
-                        if not quiet_mode:
-                            print(f"\nServer stopped with error: {e}")
-
-                    # 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:
-                    agent_name = self.args.agent
-                    message = self.args.message
-
-                    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}"
+                    validate_server_references(self.context, self.agents)
+                    validate_workflow_references(self.agents)
+
+                    # Get a model factory function
+                    # Now cli_model_override is guaranteed to be defined
+                    def model_factory_func(model=None, request_params=None):
+                        return get_model_factory(
+                            self.context,
+                            model=model,
+                            request_params=request_params,
+                            cli_model=cli_model_override,  # Use the variable defined above
                         )
-                        raise SystemExit(1)
-
-                    try:
-                        # Get response from the agent
-                        agent = active_agents[agent_name]
-                        response = await agent.send(message)
 
-                        # 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}")
+                    # Create all agents in dependency order
+                    active_agents = await create_agents_in_dependency_order(
+                        self.app,
+                        self.agents,
+                        model_factory_func,
+                    )
 
+                    # Create a wrapper with all agents for simplified access
+                    wrapper = AgentApp(active_agents)
+
+                    # Handle command line options that should be processed after agent initialization
+
+                    # Handle --server option
+                    # Check if parse_cli_args was True before checking self.args.server
+                    if hasattr(self.args, "server") and self.args.server:
+                        try:
+                            # Print info message if not in quiet mode
+                            if not quiet_mode:
+                                print(f"Starting FastAgent '{self.name}' in server mode")
+                                print(f"Transport: {self.args.transport}")
+                                if self.args.transport == "sse":
+                                    print(f"Listening on {self.args.host}:{self.args.port}")
+                                print("Press Ctrl+C to stop")
+
+                            # Create the MCP server
+                            from mcp_agent.mcp_server import AgentMCPServer
+
+                            mcp_server = AgentMCPServer(
+                                agent_app=wrapper,
+                                server_name=f"{self.name}-MCP-Server",
+                            )
+
+                            # Run the server directly (this is a blocking call)
+                            await mcp_server.run_async(
+                                transport=self.args.transport,
+                                host=self.args.host,
+                                port=self.args.port,
+                            )
+                        except KeyboardInterrupt:
+                            if not quiet_mode:
+                                print("\nServer stopped by user (Ctrl+C)")
+                        except Exception as e:
+                            if not quiet_mode:
+                                print(f"\nServer stopped with error: {e}")
+
+                        # Exit after server shutdown
                         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 (
-            ServerConfigError,
-            ProviderKeyError,
-            AgentConfigError,
-            ServerInitializationError,
-            ModelConfigError,
-            CircularDependencyError,
-            PromptExitError,
-        ) as e:
-            had_error = True
-            self._handle_error(e)
-            raise SystemExit(1)
 
-        finally:
-            # Clean up any active agents
-            if active_agents and not had_error:
-                for agent in active_agents.values():
-                    try:
-                        await agent.shutdown()
-                    except Exception:
-                        pass
+                    # Handle direct message sending if  --message is provided
+                    if self.args.message:
+                        agent_name = self.args.agent
+                        message = self.args.message
+
+                        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.send(message)
+
+                            # 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}")
+
+                            raise SystemExit(0)
+                        except Exception as e:
+                            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 (
+                ServerConfigError,
+                ProviderKeyError,
+                AgentConfigError,
+                ServerInitializationError,
+                ModelConfigError,
+                CircularDependencyError,
+                PromptExitError,
+            ) as e:
+                had_error = True
+                self._handle_error(e)
+                raise SystemExit(1)
+
+            finally:
+                # Clean up any active agents
+                if active_agents and not had_error:
+                    for agent in active_agents.values():
+                        try:
+                            await agent.shutdown()
+                        except Exception:
+                            pass
 
     def _handle_error(self, e: Exception, error_type: Optional[str] = None) -> None:
         """

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":

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