fast-agent-mcp 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -1,8 +1,12 @@
 import contextlib
 from enum import Enum
-from typing import Callable, List, Optional, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional, Type
+
 from pydantic import BaseModel, Field
 
+from mcp_agent.agents.agent import Agent
+from mcp_agent.core.agent_types import AgentConfig
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
@@ -10,8 +14,6 @@ from mcp_agent.workflows.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
-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:
@@ -33,15 +35,9 @@ class EvaluationResult(BaseModel):
     """Model representing the evaluation result from the evaluator LLM"""
 
     rating: QualityRating = Field(description="Quality rating of the response")
-    feedback: str = Field(
-        description="Specific feedback and suggestions for improvement"
-    )
-    needs_improvement: bool = Field(
-        description="Whether the output needs further improvement"
-    )
-    focus_areas: List[str] = Field(
-        default_factory=list, description="Specific areas to focus on in next iteration"
-    )
+    feedback: str = Field(description="Specific feedback and suggestions for improvement")
+    needs_improvement: bool = Field(description="Whether the output needs further improvement")
+    focus_areas: List[str] = Field(default_factory=list, description="Specific areas to focus on in next iteration")
 
 
 class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
@@ -68,14 +64,13 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters using the workflow's settings."""
         return RequestParams(
-            modelPreferences=self.model_preferences,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
             max_iterations=10,
             use_history=self.generator_use_history,  # Use generator's history setting
         )
 
-    def _init_request_params(self):
+    def _init_request_params(self) -> None:
         """Initialize request parameters for both generator and evaluator components."""
         # Set up workflow's default params based on generator's history setting
         self.default_request_params = self._initialize_default_params({})
@@ -94,7 +89,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         context: Optional["Context"] = None,
         name: Optional[str] = None,
         instruction: Optional[str] = None,
-    ):
+    ) -> None:
         """
         Initialize the evaluator-optimizer workflow.
 
@@ -120,14 +115,10 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         if isinstance(generator, Agent):
             self.generator_use_history = generator.config.use_history
         elif isinstance(generator, AugmentedLLM):
-            if hasattr(generator, "aggregator") and isinstance(
-                generator.aggregator, Agent
-            ):
+            if hasattr(generator, "aggregator") and isinstance(generator.aggregator, Agent):
                 self.generator_use_history = generator.aggregator.config.use_history
             elif hasattr(generator, "default_request_params"):
-                self.generator_use_history = getattr(
-                    generator.default_request_params, "use_history", False
-                )
+                self.generator_use_history = getattr(generator.default_request_params, "use_history", False)
         # All other types default to False
 
         # Initialize parent class
@@ -140,20 +131,12 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         # 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 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.generator_llm = getattr(generator, "_llm", None) or llm_factory(agent=generator)
             self.aggregator = generator
-            self.instruction = instruction or (
-                generator.instruction
-                if isinstance(generator.instruction, str)
-                else None
-            )
+            self.instruction = instruction or (generator.instruction if isinstance(generator.instruction, str) else None)
         elif isinstance(generator, AugmentedLLM):
             self.generator_llm = generator
             self.aggregator = getattr(generator, "aggregator", None)
@@ -162,16 +145,12 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             # ChainProxy-like object
             self.generator_llm = generator
             self.aggregator = None
-            self.instruction = (
-                instruction or f"Chain of agents: {', '.join(generator._sequence)}"
-            )
+            self.instruction = instruction or f"Chain of agents: {', '.join(generator._sequence)}"
 
         # 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"
-                )
+                raise ValueError("llm_factory is required when using a string evaluator")
 
             evaluator_agent = Agent(
                 name="Evaluator",
@@ -186,15 +165,11 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             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"
-                )
+                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
-            )
+            self.evaluator_llm = getattr(evaluator, "_llm", None) or llm_factory(agent=evaluator)
         elif isinstance(evaluator, AugmentedLLM):
             self.evaluator_llm = evaluator
             # Ensure history is disabled
@@ -282,10 +257,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                     )
 
                 # Check if we've reached acceptable quality
-                if (
-                    evaluation_result.rating.value >= self.min_rating.value
-                    or not evaluation_result.needs_improvement
-                ):
+                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={
@@ -338,9 +310,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         request_params: RequestParams | None = None,
     ) -> ModelT:
         """Generate an optimized structured response"""
-        response_str = await self.generate_str(
-            message=message, request_params=request_params
-        )
+        response_str = await self.generate_str(message=message, request_params=request_params)
 
         return await self.generator.generate_structured(
             message=response_str,
@@ -348,9 +318,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             request_params=request_params,
         )
 
-    def _build_eval_prompt(
-        self, original_request: str, current_response: str, iteration: int
-    ) -> str:
+    def _build_eval_prompt(self, original_request: str, current_response: str, iteration: int) -> str:
         """Build the evaluation prompt for the evaluator"""
         return f"""
 You are an expert evaluator for content quality. Your task is to evaluate a response against the user's original request.
@@ -409,9 +377,7 @@ Be concrete and actionable in your recommendations.
         """Build the refinement prompt for the optimizer"""
         # Get the correct history setting - use param if provided, otherwise class default
         if use_history is None:
-            use_history = (
-                self.generator_use_history
-            )  # Use generator's setting as default
+            use_history = self.generator_use_history  # Use generator's setting as default
 
         # Start with clear non-delimited instructions
         prompt = f"""

mcp_agent/workflows/intent_classifier/intent_classifier_base.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List, Optional
+
 from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
@@ -54,9 +55,7 @@ class IntentClassifier(ABC):
         - Determining the type of analysis requested for a dataset
     """
 
-    def __init__(
-        self, intents: List[Intent], context: Optional["Context"] = None, **kwargs
-    ):
+    def __init__(self, intents: List[Intent], context: Optional["Context"] = None, **kwargs) -> None:
         super().__init__(context=context, **kwargs)
         self.intents = {intent.name: intent for intent in intents}
         self.initialized: bool = False
@@ -65,9 +64,7 @@ class IntentClassifier(ABC):
             raise ValueError("At least one intent must be provided")
 
     @abstractmethod
-    async def classify(
-        self, request: str, top_k: int = 1
-    ) -> List[IntentClassificationResult]:
+    async def classify(self, request: str, top_k: int = 1) -> List[IntentClassificationResult]:
         """
         Classify the input request into one or more intents.
 
@@ -79,7 +76,7 @@ class IntentClassifier(ABC):
             List of classification results, ordered by confidence
         """
 
-    async def initialize(self):
+    async def initialize(self) -> None:
         """Initialize the classifier. Override this method if needed."""
         self.initialized = True
 

mcp_agent/workflows/intent_classifier/intent_classifier_embedding.py

@@ -1,17 +1,17 @@
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
 from numpy import mean
 
 from mcp_agent.workflows.embedding.embedding_base import (
-    FloatArray,
     EmbeddingModel,
+    FloatArray,
     compute_confidence,
     compute_similarity_scores,
 )
 from mcp_agent.workflows.intent_classifier.intent_classifier_base import (
     Intent,
-    IntentClassifier,
     IntentClassificationResult,
+    IntentClassifier,
 )
 
 if TYPE_CHECKING:
@@ -43,7 +43,7 @@ class EmbeddingIntentClassifier(IntentClassifier):
         embedding_model: EmbeddingModel,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(intents=intents, context=context, **kwargs)
         self.embedding_model = embedding_model
         self.initialized = False
@@ -65,7 +65,7 @@ class EmbeddingIntentClassifier(IntentClassifier):
         await instance.initialize()
         return instance
 
-    async def initialize(self):
+    async def initialize(self) -> None:
         """
         Precompute embeddings for all intents by combining their
         descriptions and examples
@@ -91,9 +91,7 @@ class EmbeddingIntentClassifier(IntentClassifier):
 
         self.initialized = True
 
-    async def classify(
-        self, request: str, top_k: int = 1
-    ) -> List[IntentClassificationResult]:
+    async def classify(self, request: str, top_k: int = 1) -> List[IntentClassificationResult]:
         """
         Classify the input text into one or more intents
 
@@ -116,9 +114,7 @@ class EmbeddingIntentClassifier(IntentClassifier):
             if intent.embedding is None:
                 continue
 
-            similarity_scores = compute_similarity_scores(
-                request_embedding, intent.embedding
-            )
+            similarity_scores = compute_similarity_scores(request_embedding, intent.embedding)
 
             # Compute overall confidence score
             confidence = compute_confidence(similarity_scores)

mcp_agent/workflows/intent_classifier/intent_classifier_embedding_cohere.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
 from mcp_agent.workflows.embedding.embedding_cohere import CohereEmbeddingModel
 from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
@@ -21,11 +21,9 @@ class CohereEmbeddingIntentClassifier(EmbeddingIntentClassifier):
         embedding_model: CohereEmbeddingModel | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         embedding_model = embedding_model or CohereEmbeddingModel()
-        super().__init__(
-            embedding_model=embedding_model, intents=intents, context=context, **kwargs
-        )
+        super().__init__(embedding_model=embedding_model, intents=intents, context=context, **kwargs)
 
     @classmethod
     async def create(
@@ -38,8 +36,6 @@ class CohereEmbeddingIntentClassifier(EmbeddingIntentClassifier):
         Factory method to create and initialize a classifier.
         Use this instead of constructor since we need async initialization.
         """
-        instance = cls(
-            intents=intents, embedding_model=embedding_model, context=context
-        )
+        instance = cls(intents=intents, embedding_model=embedding_model, context=context)
         await instance.initialize()
         return instance

mcp_agent/workflows/intent_classifier/intent_classifier_embedding_openai.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
 from mcp_agent.workflows.embedding.embedding_openai import OpenAIEmbeddingModel
 from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
@@ -21,11 +21,9 @@ class OpenAIEmbeddingIntentClassifier(EmbeddingIntentClassifier):
         embedding_model: OpenAIEmbeddingModel | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         embedding_model = embedding_model or OpenAIEmbeddingModel()
-        super().__init__(
-            embedding_model=embedding_model, intents=intents, context=context, **kwargs
-        )
+        super().__init__(embedding_model=embedding_model, intents=intents, context=context, **kwargs)
 
     @classmethod
     async def create(
@@ -38,8 +36,6 @@ class OpenAIEmbeddingIntentClassifier(EmbeddingIntentClassifier):
         Factory method to create and initialize a classifier.
         Use this instead of constructor since we need async initialization.
         """
-        instance = cls(
-            intents=intents, embedding_model=embedding_model, context=context
-        )
+        instance = cls(intents=intents, embedding_model=embedding_model, context=context)
         await instance.initialize()
         return instance

mcp_agent/workflows/intent_classifier/intent_classifier_llm.py

@@ -1,12 +1,13 @@
-from typing import List, Literal, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Literal, Optional
+
 from pydantic import BaseModel
 
-from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
 from mcp_agent.workflows.intent_classifier.intent_classifier_base import (
     Intent,
-    IntentClassifier,
     IntentClassificationResult,
+    IntentClassifier,
 )
+from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -75,7 +76,7 @@ class LLMIntentClassifier(IntentClassifier):
         classification_instruction: str | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(intents=intents, context=context, **kwargs)
         self.llm = llm
         self.classification_instruction = classification_instruction
@@ -99,28 +100,20 @@ class LLMIntentClassifier(IntentClassifier):
         await instance.initialize()
         return instance
 
-    async def classify(
-        self, request: str, top_k: int = 1
-    ) -> List[LLMIntentClassificationResult]:
+    async def classify(self, request: str, top_k: int = 1) -> List[LLMIntentClassificationResult]:
         if not self.initialized:
             self.initialize()
 
-        classification_instruction = (
-            self.classification_instruction or DEFAULT_INTENT_CLASSIFICATION_INSTRUCTION
-        )
+        classification_instruction = self.classification_instruction or DEFAULT_INTENT_CLASSIFICATION_INSTRUCTION
 
         # Generate the context with intent descriptions and examples
         context = self._generate_context()
 
         # Format the prompt with all the necessary information
-        prompt = classification_instruction.format(
-            context=context, request=request, top_k=top_k
-        )
+        prompt = classification_instruction.format(context=context, request=request, top_k=top_k)
 
         # Get classification from LLM
-        response = await self.llm.generate_structured(
-            message=prompt, response_model=StructuredIntentResponse
-        )
+        response = await self.llm.generate_structured(message=prompt, response_model=StructuredIntentResponse)
 
         if not response or not response.classifications:
             return []
@@ -142,18 +135,14 @@ class LLMIntentClassifier(IntentClassifier):
         context_parts = []
 
         for idx, intent in enumerate(self.intents.values(), 1):
-            description = (
-                f"{idx}. Intent: {intent.name}\nDescription: {intent.description}"
-            )
+            description = f"{idx}. Intent: {intent.name}\nDescription: {intent.description}"
 
             if intent.examples:
                 examples = "\n".join(f"- {example}" for example in intent.examples)
                 description += f"\nExamples:\n{examples}"
 
             if intent.metadata:
-                metadata = "\n".join(
-                    f"- {key}: {value}" for key, value in intent.metadata.items()
-                )
+                metadata = "\n".join(f"- {key}: {value}" for key, value in intent.metadata.items())
                 description += f"\nAdditional Information:\n{metadata}"
 
             context_parts.append(description)

mcp_agent/workflows/intent_classifier/intent_classifier_llm_anthropic.py

@@ -1,10 +1,10 @@
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
-from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
 from mcp_agent.workflows.intent_classifier.intent_classifier_llm import (
     LLMIntentClassifier,
 )
+from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -27,7 +27,7 @@ class AnthropicLLMIntentClassifier(LLMIntentClassifier):
         classification_instruction: str | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         anthropic_llm = AnthropicAugmentedLLM(
             instruction=CLASSIFIER_SYSTEM_INSTRUCTION, context=context
         )

mcp_agent/workflows/intent_classifier/intent_classifier_llm_openai.py

@@ -1,10 +1,10 @@
-from typing import List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
 
-from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
 from mcp_agent.workflows.intent_classifier.intent_classifier_llm import (
     LLMIntentClassifier,
 )
+from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -27,10 +27,8 @@ class OpenAILLMIntentClassifier(LLMIntentClassifier):
         classification_instruction: str | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
-        openai_llm = OpenAIAugmentedLLM(
-            instruction=CLASSIFIER_SYSTEM_INSTRUCTION, context=context
-        )
+    ) -> None:
+        openai_llm = OpenAIAugmentedLLM(instruction=CLASSIFIER_SYSTEM_INSTRUCTION, context=context)
 
         super().__init__(
             llm=openai_llm,

mcp_agent/workflows/llm/anthropic_utils.py

@@ -8,11 +8,10 @@ leveraging existing code for resource handling and delimited formats.
 from anthropic.types import (
     MessageParam,
 )
-
 from mcp.types import (
-    TextContent,
-    ImageContent,
     EmbeddedResource,
+    ImageContent,
+    TextContent,
     TextResourceContents,
 )
 
@@ -37,9 +36,7 @@ def anthropic_message_param_to_prompt_message_multipart(
 
     # Handle string content (user messages can be simple strings)
     if isinstance(content, str):
-        return PromptMessageMultipart(
-            role=role, content=[TextContent(type="text", text=content)]
-        )
+        return PromptMessageMultipart(role=role, content=[TextContent(type="text", text=content)])
 
     # Convert content blocks to MCP content types
     mcp_contents = []
@@ -50,29 +47,13 @@ def anthropic_message_param_to_prompt_message_multipart(
                 text = block.get("text", "")
 
                 # Check if this is a resource marker
-                if (
-                    text
-                    and (
-                        text.startswith("[Resource:")
-                        or text.startswith("[Binary Resource:")
-                    )
-                    and "\n" in text
-                ):
+                if text and (text.startswith("[Resource:") or text.startswith("[Binary Resource:")) and "\n" in text:
                     header, content_text = text.split("\n", 1)
                     if "MIME:" in header:
                         mime_match = header.split("MIME:", 1)[1].split("]")[0].strip()
-                        if (
-                            mime_match != "text/plain"
-                        ):  # Only process non-plain text resources
-                            if (
-                                "Resource:" in header
-                                and "Binary Resource:" not in header
-                            ):
-                                uri = (
-                                    header.split("Resource:", 1)[1]
-                                    .split(",")[0]
-                                    .strip()
-                                )
+                        if mime_match != "text/plain":  # Only process non-plain text resources
+                            if "Resource:" in header and "Binary Resource:" not in header:
+                                uri = header.split("Resource:", 1)[1].split(",")[0].strip()
                                 mcp_contents.append(
                                     EmbeddedResource(
                                         type="resource",
@@ -94,8 +75,6 @@ def anthropic_message_param_to_prompt_message_multipart(
                 if isinstance(source, dict) and source.get("type") == "base64":
                     media_type = source.get("media_type", "image/png")
                     data = source.get("data", "")
-                    mcp_contents.append(
-                        ImageContent(type="image", data=data, mimeType=media_type)
-                    )
+                    mcp_contents.append(ImageContent(type="image", data=data, mimeType=media_type))
 
     return PromptMessageMultipart(role=role, content=mcp_contents)