fast-agent-mcp 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

mcp_agent/core/fastagent.py

@@ -13,6 +13,7 @@ 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
@@ -76,81 +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",
-            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",
-        )
-
-        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
@@ -220,164 +237,178 @@ 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  --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}"
+                    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}")
-
-                        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)
+                    # Create all agents in dependency order
+                    active_agents = await create_agents_in_dependency_order(
+                        self.app,
+                        self.agents,
+                        model_factory_func,
                     )
-                    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()}")
 
+                    # 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:
+                                import traceback
+
+                                traceback.print_exc()
+                                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 hasattr(self.args, "message") 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}"
+                            )
+                            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 hasattr(self.args, "prompt_file") and 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/executor/executor.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextvars
 import functools
 from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
@@ -206,13 +207,13 @@ class AsyncioExecutor(Executor):
                 else:
                     # Execute the callable and await if it returns a coroutine
                     loop = asyncio.get_running_loop()
-
+                    ctx = contextvars.copy_context()
                     # If kwargs are provided, wrap the function with partial
                     if kwargs:
                         wrapped_task = functools.partial(task, **kwargs)
-                        result = await loop.run_in_executor(None, wrapped_task)
+                        result = await loop.run_in_executor(None, lambda: ctx.run(wrapped_task))
                     else:
-                        result = await loop.run_in_executor(None, task)
+                        result = await loop.run_in_executor(None, lambda: ctx.run(task))
 
                     # Handle case where the sync function returns a coroutine
                     if asyncio.iscoroutine(result):
@@ -234,12 +235,10 @@ class AsyncioExecutor(Executor):
         *tasks: Callable[..., R] | Coroutine[Any, Any, R],
         **kwargs: Any,
     ) -> List[R | BaseException]:
-        # TODO: saqadri - validate if async with self.execution_context() is needed here
-        async with self.execution_context():
-            return await asyncio.gather(
-                *(self._execute_task(task, **kwargs) for task in tasks),
-                return_exceptions=True,
-            )
+        return await asyncio.gather(
+            *(self._execute_task(task, **kwargs) for task in tasks),
+            return_exceptions=True,
+        )
 
     async def execute_streaming(
         self,

mcp_agent/llm/augmented_llm.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from typing import (
     TYPE_CHECKING,
     Any,
+    Dict,
     Generic,
     List,
     Optional,
@@ -59,7 +60,36 @@ if TYPE_CHECKING:
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
 
 
-class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]):
+def deep_merge(dict1: Dict[Any, Any], dict2: Dict[Any, Any]) -> Dict[Any, Any]:
+    """
+    Recursively merges `dict2` into `dict1` in place.
+
+    If a key exists in both dictionaries and their values are dictionaries,
+    the function merges them recursively. Otherwise, the value from `dict2`
+    overwrites or is added to `dict1`.
+
+    Args:
+        dict1 (Dict): The dictionary to be updated.
+        dict2 (Dict): The dictionary to merge into `dict1`.
+
+    Returns:
+        Dict: The updated `dict1`.
+    """
+    for key in dict2:
+        if (
+            key in dict1
+            and isinstance(dict1[key], dict)
+            and isinstance(dict2[key], dict)
+        ):
+            deep_merge(dict1[key], dict2[key])
+        else:
+            dict1[key] = dict2[key]
+    return dict1
+
+
+class AugmentedLLM(
+    ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]
+):
     # Common parameter names used across providers
     PARAM_MESSAGES = "messages"
     PARAM_MODEL = "model"
@@ -171,6 +201,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # We never expect this for structured() calls - this is for interactive use - developers
         # can do this programatically
         # TODO -- create a "fast-agent" control role rather than magic strings
+
         if multipart_messages[-1].first_text().startswith("***SAVE_HISTORY"):
             parts: list[str] = multipart_messages[-1].first_text().split(" ", 1)
             filename: str = (
@@ -220,6 +251,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         request_params: RequestParams | None = None,
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """Return a structured response from the LLM using the provided messages."""
+
         self._precall(multipart_messages)
         result, assistant_response = await self._apply_prompt_provider_specific_structured(
             multipart_messages, model, request_params
@@ -355,8 +387,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
     ) -> RequestParams:
         """Merge default and provided request parameters"""
 
-        merged = default_params.model_dump()
-        merged.update(provided_params.model_dump(exclude_unset=True))
+        merged = deep_merge(
+            default_params.model_dump(),
+            provided_params.model_dump(exclude_unset=True),
+        )
         final_params = RequestParams(**merged)
 
         return final_params

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -79,7 +79,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             maxTokens=4096,  # default haiku3
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -95,7 +95,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             model=chosen_model,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 
@@ -222,7 +222,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                         method="tools/call",
                         params=CallToolRequestParams(
                             name=tool_call.function.name,
-                            arguments={} if not tool_call.function.arguments or tool_call.function.arguments.strip() == '' else 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)