fast-agent-mcp 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

mcp_agent/resources/examples/researcher/researcher.py

@@ -3,7 +3,7 @@ import asyncio
 from mcp_agent.core.fastagent import FastAgent
 # from rich import print
 
-agents = FastAgent(name="Researcher")
+agents = FastAgent(name="Researcher Agent")
 
 
 @agents.agent(

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -45,13 +45,14 @@ fast = FastAgent("Orchestrator-Workers")
 @fast.orchestrator(
     name="orchestrate",
     agents=["finder", "writer", "proofreader"],
-    plan_type="full",
+    plan_type="iterative",
 )
 async def main():
     async with fast.run() as agent:
-        await agent.author(
-            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-        )
+        await agent()
+#        await agent.author(
+#            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
+#        )
 
         # The orchestrator can be used just like any other agent
         task = (

mcp_agent/resources/examples/workflows/router.py

@@ -25,7 +25,6 @@ SAMPLE_REQUESTS = [
     name="fetcher",
     instruction="""You are an agent, with a tool enabling you to fetch URLs.""",
     servers=["fetch"],
-    model="haiku",
 )
 @fast.agent(
     name="code_expert",
@@ -33,7 +32,6 @@ SAMPLE_REQUESTS = [
     When asked about code, architecture, or development practices,
     you provide thorough and practical insights.""",
     servers=["filesystem"],
-    model="gpt-4o",
 )
 @fast.agent(
     name="general_assistant",

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -12,6 +12,7 @@ from mcp_agent.workflows.llm.augmented_llm import (
 )
 from mcp_agent.agents.agent import Agent, AgentConfig
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -89,45 +90,33 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         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,
         context: Optional["Context"] = None,
-        name: Optional[str] = None,  # Allow overriding the name
-        instruction: Optional[str] = None,  # Allow overriding the instruction
+        name: Optional[str] = None,
+        instruction: Optional[str] = None,
     ):
         """
         Initialize the evaluator-optimizer workflow.
 
         Args:
-            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
-            evaluator_agent: The agent/LLM that evaluates responses
-            evaluation_criteria: Criteria for the evaluator to assess responses
+            generator: The agent/LLM/workflow that generates responses
+            evaluator: The evaluator (string instruction, Agent or AugmentedLLM)
             min_rating: Minimum acceptable quality rating
             max_refinements: Maximum refinement iterations
-            llm_factory: Optional factory to create LLMs from agents
+            llm_factory: Factory to create LLMs from agents when needed
             name: Optional name for the workflow (defaults to generator's name)
             instruction: Optional instruction (defaults to generator's instruction)
-
-        Note on History Management:
-            This workflow manages two distinct history contexts:
-            1. Generator History: Controlled by the generator's use_history setting. When False,
-               each refinement iteration starts fresh without previous context.
-            2. Evaluator History: Always disabled as each evaluation should be independent
-               and based solely on the current response.
         """
-        # Set up initial instance attributes - allow name override
-        self.name = name or generator.name
+        # Set initial attributes
+        self.name = name or getattr(generator, "name", "EvaluatorOptimizer")
         self.llm_factory = llm_factory
         self.generator = generator
         self.evaluator = evaluator
         self.min_rating = min_rating
         self.max_refinements = max_refinements
 
-        # Determine generator's history setting before super().__init__
-
+        # Determine generator's history setting directly based on type
+        self.generator_use_history = False
         if isinstance(generator, Agent):
             self.generator_use_history = generator.config.use_history
         elif isinstance(generator, AugmentedLLM):
@@ -135,90 +124,55 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                 generator.aggregator, Agent
             ):
                 self.generator_use_history = generator.aggregator.config.use_history
-            else:
+            elif hasattr(generator, "default_request_params"):
                 self.generator_use_history = getattr(
-                    generator,
-                    "use_history",
-                    getattr(generator.default_request_params, "use_history", False),
+                    generator.default_request_params, "use_history", False
                 )
-        # Handle ChainProxy with type checking
-        elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
-            # This is how we detect a ChainProxy without directly importing it
-            # For ChainProxy, we'll default use_history to False
-            self.generator_use_history = False
-        else:
-            raise ValueError(f"Unsupported optimizer type: {type(generator)}")
-
-        # Now we can call super().__init__ which will use generator_use_history
-        super().__init__(context=context, name=name or generator.name)
+        # All other types default to False
 
-        # Add a PassthroughLLM as _llm property for compatibility with Orchestrator
-        from mcp_agent.workflows.llm.augmented_llm import PassthroughLLM
+        # Initialize parent class
+        super().__init__(context=context, name=name or getattr(generator, "name", None))
 
+        # Create a PassthroughLLM as _llm property
+        # TODO -- remove this when we fix/remove the inheritance hierarchy
         self._llm = PassthroughLLM(name=f"{self.name}_passthrough", context=context)
 
-        # Set up the generator
-
+        # Set up the generator based on type
         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(generator, "_llm") and generator._llm:
-                self.generator_llm = generator._llm
-            else:
-                self.generator_llm = llm_factory(agent=generator)
+                raise ValueError(
+                    "llm_factory is required when using an Agent generator"
+                )
 
+            # Use existing LLM if available, otherwise create new one
+            self.generator_llm = getattr(generator, "_llm", None) or llm_factory(
+                agent=generator
+            )
             self.aggregator = generator
-            self.instruction = (
-                instruction  # Use provided instruction if any
-                or (
-                    generator.instruction
-                    if isinstance(generator.instruction, str)
-                    else None
-                )  # Fallback to generator's
+            self.instruction = instruction or (
+                generator.instruction
+                if isinstance(generator.instruction, str)
+                else None
             )
-        elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
-            # For ChainProxy, use it directly for generation
+        elif isinstance(generator, AugmentedLLM):
+            self.generator_llm = generator
+            self.aggregator = getattr(generator, "aggregator", None)
+            self.instruction = instruction or generator.instruction
+        else:
+            # ChainProxy-like object
             self.generator_llm = generator
             self.aggregator = None
             self.instruction = (
                 instruction or f"Chain of agents: {', '.join(generator._sequence)}"
             )
 
-        elif isinstance(generator, AugmentedLLM):
-            self.generator_llm = generator
-            self.aggregator = generator.aggregator
-            self.instruction = generator.instruction
-
-        # Set up the evaluator - evaluations should be independent, so history is always disabled
-        if isinstance(evaluator, AugmentedLLM):
-            self.evaluator_llm = evaluator
-            # Override evaluator's history setting
-            if hasattr(evaluator, "default_request_params"):
-                evaluator.default_request_params.use_history = False
-        elif isinstance(evaluator, Agent):
-            if not llm_factory:
-                raise ValueError(
-                    "llm_factory is required when using an Agent evaluator"
-                )
-
-            # Create evaluator with history disabled
-            if hasattr(evaluator, "_llm") and evaluator._llm:
-                self.evaluator_llm = evaluator._llm
-                if hasattr(self.evaluator_llm, "default_request_params"):
-                    self.evaluator_llm.default_request_params.use_history = False
-            else:
-                # Force history off in config before creating LLM
-                evaluator.config.use_history = False
-                self.evaluator_llm = llm_factory(agent=evaluator)
-        elif isinstance(evaluator, str):
+        # Set up the evaluator - always disable history
+        if isinstance(evaluator, str):
             if not llm_factory:
                 raise ValueError(
                     "llm_factory is required when using a string evaluator"
                 )
 
-            # Create evaluator agent with history disabled
             evaluator_agent = Agent(
                 name="Evaluator",
                 instruction=evaluator,
@@ -226,17 +180,33 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                     name="Evaluator",
                     instruction=evaluator,
                     servers=[],
-                    use_history=False,  # Force history off for evaluator
+                    use_history=False,
                 ),
             )
             self.evaluator_llm = llm_factory(agent=evaluator_agent)
+        elif isinstance(evaluator, Agent):
+            if not llm_factory:
+                raise ValueError(
+                    "llm_factory is required when using an Agent evaluator"
+                )
+
+            # Disable history and use/create LLM
+            evaluator.config.use_history = False
+            self.evaluator_llm = getattr(evaluator, "_llm", None) or llm_factory(
+                agent=evaluator
+            )
+        elif isinstance(evaluator, AugmentedLLM):
+            self.evaluator_llm = evaluator
+            # Ensure history is disabled
+            if hasattr(self.evaluator_llm, "default_request_params"):
+                self.evaluator_llm.default_request_params.use_history = False
         else:
             raise ValueError(f"Unsupported evaluator type: {type(evaluator)}")
 
-        # Track iteration history (for the workflow itself)
+        # Track iteration history
         self.refinement_history = []
 
-        # Set up workflow's default params based on generator's history setting
+        # Set up workflow's default params
         self.default_request_params = self._initialize_default_params({})
 
         # Ensure evaluator's request params have history disabled

mcp_agent/workflows/llm/augmented_llm.py

@@ -1,7 +1,6 @@
 from abc import abstractmethod
 
 from typing import (
-    Any,
     Generic,
     List,
     Optional,
@@ -9,7 +8,6 @@ from typing import (
     Type,
     TypeVar,
     TYPE_CHECKING,
-    Union,
 )
 
 from pydantic import Field
@@ -567,7 +565,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
                             text_parts.append(part.text)
                     if text_parts:
                         return "\n".join(text_parts)
-                    
+
         # For objects with content attribute
         if hasattr(message, "content"):
             content = message.content
@@ -575,7 +573,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
                 return content
             elif hasattr(content, "text"):
                 return content.text
-                
+
         # Default fallback
         return str(message)
 
@@ -588,7 +586,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         result = self.message_param_str(message)
         if result != str(message):
             return result
-            
+
         # Additional handling for output-specific formats
         if hasattr(message, "content"):
             content = message.content
@@ -600,7 +598,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
                         text_parts.append(block.text)
                 if text_parts:
                     return "\n".join(text_parts)
-        
+
         # Default fallback
         return str(message)
 
@@ -650,7 +648,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
     ):
         """
         Display information about a loaded prompt template.
-        
+
         Args:
             prompt_name: The name of the prompt
             description: Optional description of the prompt
@@ -679,11 +677,11 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
             prompt_name: The name of the prompt being applied
 
         Returns:
-            String representation of the assistant's response if generated, 
+            String representation of the assistant's response if generated,
             or the last assistant message in the prompt
         """
         prompt_messages: List[PromptMessage] = prompt_result.messages
-        
+
         # Check if we have any messages
         if not prompt_messages:
             return "Prompt contains no messages"
@@ -698,14 +696,16 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
             message_count=len(prompt_messages),
             arguments=arguments,
         )
-        
+
         # Check the last message role
         last_message = prompt_messages[-1]
-        
+
         if last_message.role == "user":
             # For user messages: Add all previous messages to history, then generate response to the last one
-            self.logger.debug("Last message in prompt is from user, generating assistant response")
-            
+            self.logger.debug(
+                "Last message in prompt is from user, generating assistant response"
+            )
+
             # Add all but the last message to history
             if len(prompt_messages) > 1:
                 previous_messages = prompt_messages[:-1]
@@ -713,87 +713,28 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
                 for msg in previous_messages:
                     converted.append(self.type_converter.from_mcp_prompt_message(msg))
                 self.history.extend(converted, is_prompt=True)
-            
+
             # Extract the user's question and generate a response
             user_content = last_message.content
-            user_text = user_content.text if hasattr(user_content, "text") else str(user_content)
-            
+            user_text = (
+                user_content.text
+                if hasattr(user_content, "text")
+                else str(user_content)
+            )
+
             return await self.generate_str(user_text)
         else:
             # For assistant messages: Add all messages to history and return the last one
-            self.logger.debug("Last message in prompt is from assistant, returning it directly")
-            
+            self.logger.debug(
+                "Last message in prompt is from assistant, returning it directly"
+            )
+
             # Convert and add all messages to history
             converted = []
             for msg in prompt_messages:
                 converted.append(self.type_converter.from_mcp_prompt_message(msg))
             self.history.extend(converted, is_prompt=True)
-            
+
             # Return the assistant's message
             content = last_message.content
             return content.text if hasattr(content, "text") else str(content)
-        
-
-
-class PassthroughLLM(AugmentedLLM):
-    """
-    A specialized LLM implementation that simply passes through input messages without modification.
-
-    This is useful for cases where you need an object with the AugmentedLLM interface
-    but want to preserve the original message without any processing, such as in a
-    parallel workflow where no fan-in aggregation is needed.
-    """
-
-    def __init__(self, name: str = "Passthrough", context=None, **kwargs):
-        super().__init__(name=name, context=context, **kwargs)
-
-    async def generate(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        request_params: Optional[RequestParams] = None,
-    ) -> Union[List[MessageT], Any]:
-        """Simply return the input message as is."""
-        # Return in the format expected by the caller
-        return [message] if isinstance(message, list) else message
-
-    async def generate_str(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        request_params: Optional[RequestParams] = None,
-    ) -> str:
-        """Return the input message as a string."""
-        self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
-        await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
-
-        return str(message)
-
-    async def generate_structured(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        response_model: Type[ModelT],
-        request_params: Optional[RequestParams] = None,
-    ) -> ModelT:
-        """
-        Return the input message as the requested model type.
-        This is a best-effort implementation - it may fail if the
-        message cannot be converted to the requested model.
-        """
-        if isinstance(message, response_model):
-            return message
-        elif isinstance(message, dict):
-            return response_model(**message)
-        elif isinstance(message, str):
-            try:
-                # Try to parse as JSON if it's a string
-                import json
-
-                data = json.loads(message)
-                return response_model(**data)
-            except:  # noqa: E722
-                raise ValueError(
-                    f"Cannot convert message of type {type(message)} to {response_model}"
-                )
-        else:
-            raise ValueError(
-                f"Cannot convert message of type {type(message)} to {response_model}"
-            )

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -4,7 +4,6 @@ from typing import Iterable, List, Type
 
 from pydantic import BaseModel
 
-import instructor
 from anthropic import Anthropic, AuthenticationError
 from anthropic.types import (
     ContentBlock,
@@ -27,8 +26,8 @@ from mcp.types import (
     TextContent,
     TextResourceContents,
 )
+from pydantic_core import from_json
 
-from mcp_agent.workflows.router.router_llm import StructuredResponse
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     ModelT,
@@ -96,7 +95,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 "Please check that your API key is valid and not expired.",
             ) from e
 
-        # Always include prompt messages, but only include conversation history 
+        # Always include prompt messages, but only include conversation history
         # if use_history is True
         messages.extend(self.history.get(include_history=params.use_history))
 
@@ -295,10 +294,10 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         if params.use_history:
             # Get current prompt messages
             prompt_messages = self.history.get(include_history=False)
-            
+
             # Calculate new conversation messages (excluding prompts)
-            new_messages = messages[len(prompt_messages):]
-            
+            new_messages = messages[len(prompt_messages) :]
+
             # Update conversation history
             self.history.set(new_messages)
 
@@ -367,10 +366,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         response_model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> ModelT:
-        # First we invoke the LLM to generate a string response
-        # We need to do this in a two-step process because Instructor doesn't
-        # know how to invoke MCP tools via call_tool, so we'll handle all the
-        # processing first and then pass the final response through Instructor
+        # TODO -- simiar to the OAI version, we should create a tool call for the expected schema
         response = await self.generate_str(
             message=message,
             request_params=request_params,
@@ -378,27 +374,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         # Don't try to parse if we got no response
         if not response:
             self.logger.error("No response from generate_str")
-            return StructuredResponse(categories=[])
-
-        # Next we pass the text through instructor to extract structured data
-        client = instructor.from_anthropic(
-            Anthropic(api_key=self._api_key(self.context.config)),
-        )
+            return None
 
-        params = self.get_request_params(request_params)
-        model = await self.select_model(params)
-
-        # Extract structured data from natural language
-        structured_response = client.chat.completions.create(
-            model=model,
-            response_model=response_model,
-            messages=[{"role": "user", "content": response}],
-            max_tokens=params.maxTokens,
-        )
-        await self.show_assistant_message(
-            str(structured_response), title="ASSISTANT/STRUCTURED"
-        )
-        return structured_response
+        return response_model.model_validate(from_json(response, allow_partial=True))
 
     @classmethod
     def convert_message_to_message_param(

mcp_agent/workflows/llm/augmented_llm_openai.py

@@ -2,15 +2,16 @@ import json
 import os
 from typing import Iterable, List, Type
 from mcp.types import PromptMessage
-import instructor
 from openai import OpenAI, AuthenticationError
+
+# from openai.types.beta.chat import
 from openai.types.chat import (
     ChatCompletionAssistantMessageParam,
+    ChatCompletionMessageParam,
     ChatCompletionContentPartParam,
     ChatCompletionContentPartTextParam,
     ChatCompletionContentPartRefusalParam,
     ChatCompletionMessage,
-    ChatCompletionMessageParam,
     ChatCompletionSystemMessageParam,
     ChatCompletionToolParam,
     ChatCompletionToolMessageParam,
@@ -128,7 +129,12 @@ class OpenAIAugmentedLLM(
             self.context.config.openai.base_url if self.context.config.openai else None
         )
 
-    async def generate(self, message, request_params: RequestParams | None = None):
+    async def generate(
+        self,
+        message,
+        request_params: RequestParams | None = None,
+        response_model: Type[ModelT] | None = None,
+    ) -> List[ChatCompletionMessage]:
         """
         Process a query using an LLM and available tools.
         The default implementation uses OpenAI's ChatCompletion as the LLM.
@@ -152,7 +158,7 @@ class OpenAIAugmentedLLM(
                 ChatCompletionSystemMessageParam(role="system", content=system_prompt)
             )
 
-        # Always include prompt messages, but only include conversation history 
+        # Always include prompt messages, but only include conversation history
         # if use_history is True
         messages.extend(self.history.get(include_history=params.use_history))
 
@@ -179,7 +185,7 @@ class OpenAIAugmentedLLM(
             for tool in response.tools
         ]
         if not available_tools:
-            available_tools = None
+            available_tools = []
 
         responses: List[ChatCompletionMessage] = []
         model = await self.select_model(params)
@@ -215,9 +221,16 @@ class OpenAIAugmentedLLM(
             self.logger.debug(f"{arguments}")
             self._log_chat_progress(chat_turn, model=model)
 
-            executor_result = await self.executor.execute(
-                openai_client.chat.completions.create, **arguments
-            )
+            if response_model is None:
+                executor_result = await self.executor.execute(
+                    openai_client.chat.completions.create, **arguments
+                )
+            else:
+                executor_result = await self.executor.execute(
+                    openai_client.beta.chat.completions.parse,
+                    **arguments,
+                    response_format=response_model,
+                )
 
             response = executor_result[0]
 
@@ -334,10 +347,10 @@ class OpenAIAugmentedLLM(
         if params.use_history:
             # Get current prompt messages
             prompt_messages = self.history.get(include_history=False)
-            
+
             # Calculate new conversation messages (excluding prompts)
-            new_messages = messages[len(prompt_messages):]
-            
+            new_messages = messages[len(prompt_messages) :]
+
             # Update conversation history
             self.history.set(new_messages)
 
@@ -379,40 +392,21 @@ class OpenAIAugmentedLLM(
         response_model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> ModelT:
-        # First we invoke the LLM to generate a string response
-        # We need to do this in a two-step process because Instructor doesn't
-        # know how to invoke MCP tools via call_tool, so we'll handle all the
-        # processing first and then pass the final response through Instructor
-        response = await self.generate_str(
+        responses = await self.generate(
             message=message,
             request_params=request_params,
-        )
-
-        # Next we pass the text through instructor to extract structured data
-        client = instructor.from_openai(
-            OpenAI(
-                api_key=self._api_key(),
-                base_url=self._base_url(),
-            ),
-            mode=instructor.Mode.TOOLS_STRICT,
-        )
-
-        params = self.get_request_params(request_params)
-        model = await self.select_model(params)
-
-        # Extract structured data from natural language
-        structured_response = client.chat.completions.create(
-            model=model,
             response_model=response_model,
-            messages=[
-                {"role": "user", "content": response},
-            ],
-        )
-        await self.show_assistant_message(
-            str(structured_response), title="ASSISTANT/STRUCTURED"
         )
+        return responses[0].parsed
+
+        # return response_model.model_validate(
+        #     from_json(responses[0].content, allow_partial=True)
+        # )
+        # part1 = from_json(response, allow_partial=True)
+        # return response_model.model_validate(part1)
 
-        return structured_response
+        # TODO -- would prefer to use the OpenAI message[0].parsed function here
+        # return response_model.model_validate(from_json(response, allow_partial=True))
 
     async def pre_tool_call(self, tool_call_id: str | None, request: CallToolRequest):
         return request