fast-agent-mcp 0.0.9__py3-none-any.whl → 0.0.12__py3-none-any.whl

mcp_agent/resources/examples/workflows/evaluator.py

@@ -11,7 +11,7 @@ fast = FastAgent("Evaluator-Optimizer")
 
 # Define optimizer agent
 @fast.agent(
-    name="optimizer",
+    name="generator",
     instruction="""You are a career coach specializing in cover letter writing.
     You are tasked with generating a compelling cover letter given the job posting,
     candidate details, and company information. Tailor the response to the company and job requirements.
@@ -38,12 +38,13 @@ fast = FastAgent("Evaluator-Optimizer")
     Summarize your evaluation as a structured response with:
     - Overall quality rating.
     - Specific feedback and areas for improvement.""",
-    model="sonnet",
+    # instructor doesn't seem to work for sonnet37
+    # model="sonnet35",
 )
 # Define the evaluator-optimizer workflow
 @fast.evaluator_optimizer(
     name="cover_letter_writer",
-    optimizer="optimizer",  # Reference to optimizer agent
+    generator="generator",  # Reference to optimizer agent
     evaluator="evaluator",  # Reference to evaluator agent
     min_rating="EXCELLENT",  # Strive for excellence
     max_refinements=3,  # Maximum iterations
@@ -70,6 +71,8 @@ async def main():
             f"Company information: {company_information}",
         )
 
+        await agent()
+
 
 if __name__ == "__main__":
     asyncio.run(main())

mcp_agent/resources/examples/workflows/fastagent.py

@@ -0,0 +1,22 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+agent_app = FastAgent("FastAgent Example")
+# Uncomment the below to disable human input callback tool
+# agent_app.app._human_input_callback = None
+
+
+# Define the agent
+@agent_app.agent(
+    instruction="You are a helpful AI Agent",
+    servers=[],
+)
+async def main():
+    # use the --model= command line switch to specify model
+    async with agent_app.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -24,7 +24,7 @@ fast = FastAgent("Orchestrator-Workers")
             the closest match to a user's request, make the appropriate tool calls, 
             and return the URI and CONTENTS of the closest match.""",
     servers=["fetch", "filesystem"],
-    model="gpt-4o-mini",
+    model="gpt-4o",
 )
 @fast.agent(
     name="writer",

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -66,18 +66,19 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
 
     def __init__(
         self,
-        optimizer: Agent | AugmentedLLM,
+        generator: Agent | AugmentedLLM,
         evaluator: str | Agent | AugmentedLLM,
         min_rating: QualityRating = QualityRating.GOOD,
         max_refinements: int = 3,
-        llm_factory: Callable[[Agent], AugmentedLLM] | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
+        llm_factory: Callable[[Agent], AugmentedLLM]
+        | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
         context: Optional["Context"] = None,
     ):
         """
         Initialize the evaluator-optimizer workflow.
 
         Args:
-            optimizer: The agent/LLM/workflow that generates responses. Can be:
+            generator: The agent/LLM/workflow that generates responses. Can be:
                      - An Agent that will be converted to an AugmentedLLM
                      - An AugmentedLLM instance
                      - An Orchestrator/Router/ParallelLLM workflow
@@ -90,38 +91,38 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         super().__init__(context=context)
 
         # Set up the optimizer
-        self.name = optimizer.name
+        self.name = generator.name
         self.llm_factory = llm_factory
-        self.optimizer = optimizer
+        self.generator = generator
         self.evaluator = evaluator
 
         # TODO: Remove legacy - optimizer should always be an AugmentedLLM, no conversion needed
-        if isinstance(optimizer, Agent):
+        if isinstance(generator, Agent):
             if not llm_factory:
                 raise ValueError("llm_factory is required when using an Agent")
 
             # Only create new LLM if agent doesn't have one
-            if hasattr(optimizer, "_llm") and optimizer._llm:
-                self.optimizer_llm = optimizer._llm
+            if hasattr(generator, "_llm") and generator._llm:
+                self.generator_llm = generator._llm
             else:
-                self.optimizer_llm = llm_factory(agent=optimizer)
-            
-            self.aggregator = optimizer
+                self.generator_llm = llm_factory(agent=generator)
+
+            self.aggregator = generator
             self.instruction = (
-                optimizer.instruction
-                if isinstance(optimizer.instruction, str)
+                generator.instruction
+                if isinstance(generator.instruction, str)
                 else None
             )
 
-        elif isinstance(optimizer, AugmentedLLM):
-            self.optimizer_llm = optimizer
-            self.aggregator = optimizer.aggregator
-            self.instruction = optimizer.instruction
+        elif isinstance(generator, AugmentedLLM):
+            self.generator_llm = generator
+            self.aggregator = generator.aggregator
+            self.instruction = generator.instruction
 
         else:
-            raise ValueError(f"Unsupported optimizer type: {type(optimizer)}")
+            raise ValueError(f"Unsupported optimizer type: {type(generator)}")
 
-        self.history = self.optimizer_llm.history
+        self.history = self.generator_llm.history
 
         # Set up the evaluator
         if isinstance(evaluator, AugmentedLLM):
@@ -170,97 +171,95 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         best_rating = QualityRating.POOR
         self.refinement_history = []
 
-        # Initial generation
+        # Use a single AsyncExitStack for the entire method to maintain connections
         async with contextlib.AsyncExitStack() as stack:
-            if isinstance(self.optimizer, Agent):
-                await stack.enter_async_context(self.optimizer)
-            response = await self.optimizer_llm.generate(
+            # Enter all agent contexts once at the beginning
+            if isinstance(self.generator, Agent):
+                await stack.enter_async_context(self.generator)
+            if isinstance(self.evaluator, Agent):
+                await stack.enter_async_context(self.evaluator)
+
+            # Initial generation
+            response = await self.generator_llm.generate(
                 message=message,
                 request_params=request_params,
             )
 
-        best_response = response
-
-        while refinement_count < self.max_refinements:
-            logger.debug("Optimizer result:", data=response)
+            best_response = response
 
-            # Evaluate current response
-            eval_prompt = self._build_eval_prompt(
-                original_request=str(message),
-                current_response="\n".join(str(r) for r in response)
-                if isinstance(response, list)
-                else str(response),
-                iteration=refinement_count,
-            )
+            while refinement_count < self.max_refinements:
+                logger.debug("Optimizer result:", data=response)
 
-            evaluation_result = None
-            async with contextlib.AsyncExitStack() as stack:
-                if isinstance(self.evaluator, Agent):
-                    await stack.enter_async_context(self.evaluator)
+                # Evaluate current response
+                eval_prompt = self._build_eval_prompt(
+                    original_request=str(message),
+                    current_response="\n".join(str(r) for r in response)
+                    if isinstance(response, list)
+                    else str(response),
+                    iteration=refinement_count,
+                )
 
+                # No need for nested AsyncExitStack here - using the outer one
                 evaluation_result = await self.evaluator_llm.generate_structured(
                     message=eval_prompt,
                     response_model=EvaluationResult,
                     request_params=request_params,
                 )
 
-            # Track iteration
-            self.refinement_history.append(
-                {
-                    "attempt": refinement_count + 1,
-                    "response": response,
-                    "evaluation_result": evaluation_result,
-                }
-            )
-
-            logger.debug("Evaluator result:", data=evaluation_result)
-
-            # Track best response (using enum ordering)
-            if evaluation_result.rating.value > best_rating.value:
-                best_rating = evaluation_result.rating
-                best_response = response
-                logger.debug(
-                    "New best response:",
-                    data={"rating": best_rating, "response": best_response},
+                # Track iteration
+                self.refinement_history.append(
+                    {
+                        "attempt": refinement_count + 1,
+                        "response": response,
+                        "evaluation_result": evaluation_result,
+                    }
                 )
 
-            # Check if we've reached acceptable quality
-            if (
-                evaluation_result.rating.value >= self.min_rating.value
-                or not evaluation_result.needs_improvement
-            ):
-                logger.debug(
-                    f"Acceptable quality {evaluation_result.rating.value} reached",
-                    data={
-                        "rating": evaluation_result.rating.value,
-                        "needs_improvement": evaluation_result.needs_improvement,
-                        "min_rating": self.min_rating.value,
-                    },
+                logger.debug("Evaluator result:", data=evaluation_result)
+
+                # Track best response (using enum ordering)
+                if evaluation_result.rating.value > best_rating.value:
+                    best_rating = evaluation_result.rating
+                    best_response = response
+                    logger.debug(
+                        "New best response:",
+                        data={"rating": best_rating, "response": best_response},
+                    )
+
+                # Check if we've reached acceptable quality
+                if (
+                    evaluation_result.rating.value >= self.min_rating.value
+                    or not evaluation_result.needs_improvement
+                ):
+                    logger.debug(
+                        f"Acceptable quality {evaluation_result.rating.value} reached",
+                        data={
+                            "rating": evaluation_result.rating.value,
+                            "needs_improvement": evaluation_result.needs_improvement,
+                            "min_rating": self.min_rating.value,
+                        },
+                    )
+                    break
+
+                # Generate refined response
+                refinement_prompt = self._build_refinement_prompt(
+                    original_request=str(message),
+                    current_response="\n".join(str(r) for r in response)
+                    if isinstance(response, list)
+                    else str(response),
+                    feedback=evaluation_result,
+                    iteration=refinement_count,
                 )
-                break
-
-            # Generate refined response
-            refinement_prompt = self._build_refinement_prompt(
-                original_request=str(message),
-                current_response="\n".join(str(r) for r in response)
-                if isinstance(response, list)
-                else str(response),
-                feedback=evaluation_result,
-                iteration=refinement_count,
-            )
-
-            async with contextlib.AsyncExitStack() as stack:
-                if isinstance(self.optimizer, Agent):
-                    await stack.enter_async_context(self.optimizer)
 
-                response = await self.optimizer_llm.generate(
+                # No nested AsyncExitStack here either
+                response = await self.generator_llm.generate(
                     message=refinement_prompt,
                     request_params=request_params,
                 )
 
-            refinement_count += 1
+                refinement_count += 1
 
-        return best_response
+            return best_response
 
     async def generate_str(
         self,
@@ -276,13 +275,13 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         # Handle case where response is a single message
         if not isinstance(response, list):
             return str(response)
-            
+
         # Convert all messages to strings, handling different message types
         result_strings = []
         for r in response:
-            if hasattr(r, 'text'):
+            if hasattr(r, "text"):
                 result_strings.append(r.text)
-            elif hasattr(r, 'content'):
+            elif hasattr(r, "content"):
                 # Handle ToolUseBlock and similar
                 if isinstance(r.content, list):
                     # Typically content is a list of blocks
@@ -292,7 +291,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             else:
                 # Fallback to string representation
                 result_strings.append(str(r))
-                
+
         return "\n".join(result_strings)
 
     async def generate_structured(
@@ -306,7 +305,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             message=message, request_params=request_params
         )
 
-        return await self.optimizer.generate_structured(
+        return await self.generator.generate_structured(
             message=response_str,
             response_model=response_model,
             request_params=request_params,

mcp_agent/workflows/llm/augmented_llm.py

@@ -238,6 +238,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
 
         self.model_selector = self.context.model_selector
         self.type_converter = type_converter
+        self.verb = kwargs.get("verb")
 
     @abstractmethod
     async def generate(
@@ -494,7 +495,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         console.console.print("\n")
 
     async def show_assistant_message(
-        self, message_text: str | Text, highlight_namespaced_tool: str = ""
+        self,
+        message_text: str | Text,
+        highlight_namespaced_tool: str = "",
+        title: str = "ASSISTANT",
     ):
         """Display an assistant message in a formatted panel."""
 
@@ -524,7 +528,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
 
         panel = Panel(
             message_text,
-            title=f"[ASSISTANT]{f' ({self.name})' if self.name else ''}",
+            title=f"[{title}]{f' ({self.name})' if self.name else ''}",
             title_align="left",
             style="green",
             border_style="bold white",
@@ -627,8 +631,15 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         self, chat_turn: Optional[int] = None, model: Optional[str] = None
     ):
         """Log a chat progress event"""
+        # Determine action type based on verb
+        if hasattr(self, "verb") and self.verb:
+            # Use verb directly regardless of type
+            act = self.verb
+        else:
+            act = ProgressAction.CHATTING
+
         data = {
-            "progress_action": ProgressAction.CHATTING,
+            "progress_action": act,
             "model": model,
             "agent_name": self.name,
             "chat_turn": chat_turn if chat_turn is not None else None,

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -52,11 +52,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, type_converter=AnthropicMCPTypeConverter, **kwargs)
-
         self.provider = "Anthropic"
-        # Initialize logger with name if available
-        self.logger = get_logger(f"{__name__}.{self.name}" if self.name else __name__)
+        # Initialize logger - keep it simple without name reference
+        self.logger = get_logger(__name__)
+
+        # Now call super().__init__
+        super().__init__(*args, type_converter=AnthropicMCPTypeConverter, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Anthropic-specific default parameters"""
@@ -330,7 +331,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             messages=[{"role": "user", "content": response}],
             max_tokens=params.maxTokens,
         )
-
+        await self.show_assistant_message(
+            str(structured_response), title="ASSISTANT/STRUCTURED"
+        )
         return structured_response
 
     @classmethod

mcp_agent/workflows/llm/augmented_llm_openai.py

@@ -97,12 +97,7 @@ class OpenAIAugmentedLLM(
             use_history=True,
         )
 
-    async def generate(self, message, request_params: RequestParams | None = None):
-        """
-        Process a query using an LLM and available tools.
-        The default implementation uses OpenAI's ChatCompletion as the LLM.
-        Override this method to use a different LLM.
-        """
+    def _api_key(self) -> str:
         config = self.context.config
         api_key = None
 
@@ -121,9 +116,22 @@ class OpenAIAugmentedLLM(
                 "Add it to your configuration file under openai.api_key\n"
                 "Or set the OPENAI_API_KEY environment variable",
             )
+        return api_key
+
+    def _base_url(self) -> str:
+        return (
+            self.context.config.openai.base_url if self.context.config.openai else None
+        )
+
+    async def generate(self, message, request_params: RequestParams | None = None):
+        """
+        Process a query using an LLM and available tools.
+        The default implementation uses OpenAI's ChatCompletion as the LLM.
+        Override this method to use a different LLM.
+        """
 
         try:
-            openai_client = OpenAI(api_key=api_key, base_url=config.openai.base_url)
+            openai_client = OpenAI(api_key=self._api_key(), base_url=self._base_url())
             messages: List[ChatCompletionMessageParam] = []
             params = self.get_request_params(request_params)
         except AuthenticationError as e:
@@ -356,8 +364,8 @@ class OpenAIAugmentedLLM(
         # Next we pass the text through instructor to extract structured data
         client = instructor.from_openai(
             OpenAI(
-                api_key=self.context.config.openai.api_key,
-                base_url=self.context.config.openai.base_url,
+                api_key=self._api_key(),
+                base_url=self._base_url(),
             ),
             mode=instructor.Mode.TOOLS_STRICT,
         )
@@ -373,6 +381,9 @@ class OpenAIAugmentedLLM(
                 {"role": "user", "content": response},
             ],
         )
+        await self.show_assistant_message(
+            str(structured_response), title="ASSISTANT/STRUCTURED"
+        )
 
         return structured_response
 

mcp_agent/workflows/llm/model_factory.py

@@ -62,18 +62,23 @@ class ModelFactory:
         "o1-preview": Provider.OPENAI,
         "o3-mini": Provider.OPENAI,
         "claude-3-haiku-20240307": Provider.ANTHROPIC,
+        "claude-3-5-haiku-20241022": Provider.ANTHROPIC,
+        "claude-3-5-haiku-latest": Provider.ANTHROPIC,
         "claude-3-5-sonnet-20240620": Provider.ANTHROPIC,
         "claude-3-5-sonnet-20241022": Provider.ANTHROPIC,
         "claude-3-5-sonnet-latest": Provider.ANTHROPIC,
+        "claude-3-7-sonnet-20250219": Provider.ANTHROPIC,
+        "claude-3-7-sonnet-latest": Provider.ANTHROPIC,
         "claude-3-opus-20240229": Provider.ANTHROPIC,
         "claude-3-opus-latest": Provider.ANTHROPIC,
     }
 
     MODEL_ALIASES = {
-        "sonnet": "claude-3-5-sonnet-latest",
+        "sonnet": "claude-3-7-sonnet-latest",
         "sonnet35": "claude-3-5-sonnet-latest",
+        "sonnet37": "claude-3-7-sonnet-latest",
         "claude": "claude-3-5-sonnet-latest",
-        "haiku": "claude-3-haiku-20240307",
+        "haiku": "claude-3-5-haiku-latest",
         "haiku3": "claude-3-haiku-20240307",
         "opus": "claude-3-opus-latest",
         "opus3": "claude-3-opus-latest",
@@ -161,15 +166,24 @@ class ModelFactory:
                     config.model_name
                 )  # Ensure parsed model name isn't overwritten
 
-            llm = llm_class(
-                agent=agent,
-                model=config.model_name,
-                reasoning_effort=config.reasoning_effort.value
-                if config.reasoning_effort
-                else None,
-                request_params=factory_params,
-                name=kwargs.get("name"),
-            )
+            # Forward all keyword arguments to LLM constructor
+            llm_args = {
+                "agent": agent,
+                "model": config.model_name,
+                "request_params": factory_params,
+                "name": kwargs.get("name"),
+            }
+            
+            # Add reasoning effort if available
+            if config.reasoning_effort:
+                llm_args["reasoning_effort"] = config.reasoning_effort.value
+                
+            # Forward all other kwargs (including verb)
+            for key, value in kwargs.items():
+                if key not in ["agent", "default_request_params", "name"]:
+                    llm_args[key] = value
+                    
+            llm = llm_class(**llm_args)
             return llm
 
         return factory