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

mcp_agent/workflows/parallel/fan_in.py

@@ -1,5 +1,5 @@
 import contextlib
-from typing import Callable, Dict, List, Optional, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Type
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.context_dependent import ContextDependent
@@ -43,7 +43,7 @@ class FanIn(ContextDependent):
         llm_factory: Callable[[Agent], AugmentedLLM[MessageParamT, MessageT]] = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         """
         Initialize the FanIn with an Agent responsible for processing multiple responses into a single aggregated one.
         """
@@ -67,9 +67,7 @@ class FanIn(ContextDependent):
         Request fan-in agent generation from a list of messages from multiple sources/agents.
         Internally aggregates the messages and then calls the aggregator agent to generate a response.
         """
-        message: (
-            str | MessageParamT | List[MessageParamT]
-        ) = await self.aggregate_messages(messages)
+        message: str | MessageParamT | List[MessageParamT] = await self.aggregate_messages(messages)
 
         async with contextlib.AsyncExitStack() as stack:
             if isinstance(self.aggregator_agent, AugmentedLLM):
@@ -95,9 +93,7 @@ class FanIn(ContextDependent):
         response, which is returned as a string.
         """
 
-        message: (
-            str | MessageParamT | List[MessageParamT]
-        ) = await self.aggregate_messages(messages)
+        message: str | MessageParamT | List[MessageParamT] = await self.aggregate_messages(messages)
 
         async with contextlib.AsyncExitStack() as stack:
             if isinstance(self.aggregator_agent, AugmentedLLM):
@@ -107,9 +103,7 @@ class FanIn(ContextDependent):
                 ctx_agent = await stack.enter_async_context(self.aggregator_agent)
                 llm = await ctx_agent.attach_llm(self.llm_factory)
 
-            return await llm.generate_str(
-                message=message, request_params=request_params
-            )
+            return await llm.generate_str(message=message, request_params=request_params)
 
     async def generate_structured(
         self,
@@ -123,9 +117,7 @@ class FanIn(ContextDependent):
         the aggregator agent to generate a response, which is returned as a Pydantic model.
         """
 
-        message: (
-            str | MessageParamT | List[MessageParamT]
-        ) = await self.aggregate_messages(messages)
+        message: str | MessageParamT | List[MessageParamT] = await self.aggregate_messages(messages)
 
         async with contextlib.AsyncExitStack() as stack:
             if isinstance(self.aggregator_agent, AugmentedLLM):
@@ -141,9 +133,7 @@ class FanIn(ContextDependent):
                 request_params=request_params,
             )
 
-    async def aggregate_messages(
-        self, messages: FanInInput
-    ) -> str | MessageParamT | List[MessageParamT]:
+    async def aggregate_messages(self, messages: FanInInput) -> str | MessageParamT | List[MessageParamT]:
         """
         Aggregate messages from multiple sources/agents into a single message to
         use with the aggregator agent generation.
@@ -187,9 +177,7 @@ class FanIn(ContextDependent):
                 return await self.aggregate_agent_message_strings(messages)
 
             else:
-                raise ValueError(
-                    "Dictionary values must be either lists of messages or strings"
-                )
+                raise ValueError("Dictionary values must be either lists of messages or strings")
 
         # Handle list inputs
         elif isinstance(messages, list):
@@ -214,19 +202,13 @@ class FanIn(ContextDependent):
                 return await self.aggregate_message_strings(messages)
 
             else:
-                raise ValueError(
-                    "List items must be either lists of messages or strings"
-                )
+                raise ValueError("List items must be either lists of messages or strings")
 
         else:
-            raise ValueError(
-                "Input must be either a dictionary of agent messages or a list of messages"
-            )
+            raise ValueError("Input must be either a dictionary of agent messages or a list of messages")
 
     # Helper methods for processing different types of inputs
-    async def aggregate_agent_messages(
-        self, messages: Dict[str, List[MessageT] | List[MessageParamT]]
-    ) -> str | MessageParamT | List[MessageParamT]:
+    async def aggregate_agent_messages(self, messages: Dict[str, List[MessageT] | List[MessageParamT]]) -> str | MessageParamT | List[MessageParamT]:
         """
         Aggregate message lists with agent names.
 
@@ -254,9 +236,7 @@ class FanIn(ContextDependent):
                 else:
                     # Assume it's a Message/MessageParamT and add attribution
                     # TODO -- this should really unpack the text from the message
-                    agent_message_strings.append(
-                        f"Agent {agent_name}: {str(msg.content[0])}"
-                    )
+                    agent_message_strings.append(f"Agent {agent_name}: {str(msg.content[0])}")
 
             aggregated_messages.append("\n".join(agent_message_strings))
 
@@ -279,18 +259,14 @@ class FanIn(ContextDependent):
             return ""
 
         # Format each agent's message with agent attribution
-        aggregated_messages = [
-            f"Agent {agent_name}: {message}" for agent_name, message in messages.items()
-        ]
+        aggregated_messages = [f"Agent {agent_name}: {message}" for agent_name, message in messages.items()]
 
         # Combine all messages with clear separation
         final_message = "\n\n".join(aggregated_messages)
         final_message = f"Aggregated responses from multiple Agents:\n\n{final_message}"
         return final_message
 
-    async def aggregate_message_lists(
-        self, messages: List[List[MessageT] | List[MessageParamT]]
-    ) -> str | MessageParamT | List[MessageParamT]:
+    async def aggregate_message_lists(self, messages: List[List[MessageT] | List[MessageParamT]]) -> str | MessageParamT | List[MessageParamT]:
         """
         Aggregate message lists without agent names.
 
@@ -319,9 +295,7 @@ class FanIn(ContextDependent):
 
         # Combine all messages with clear separation
         final_message = "\n\n".join(aggregated_messages)
-        final_message = (
-            f"Aggregated responses from multiple sources:\n\n{final_message}"
-        )
+        final_message = f"Aggregated responses from multiple sources:\n\n{final_message}"
         return final_message
 
     async def aggregate_message_strings(self, messages: List[str]) -> str:
@@ -338,13 +312,9 @@ class FanIn(ContextDependent):
             return ""
 
         # Format each source's message with attribution
-        aggregated_messages = [
-            f"Source {i}: {message}" for i, message in enumerate(messages, 1)
-        ]
+        aggregated_messages = [f"Source {i}: {message}" for i, message in enumerate(messages, 1)]
 
         # Combine all messages with clear separation
         final_message = "\n\n".join(aggregated_messages)
-        final_message = (
-            f"Aggregated responses from multiple sources:\n\n{final_message}"
-        )
+        final_message = f"Aggregated responses from multiple sources:\n\n{final_message}"
         return final_message

mcp_agent/workflows/parallel/fan_out.py

@@ -1,9 +1,10 @@
 import contextlib
 import functools
-from typing import Any, Callable, Coroutine, Dict, List, Optional, Type, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, List, Optional, Type
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.context_dependent import ContextDependent
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
@@ -11,7 +12,6 @@ from mcp_agent.workflows.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
-from mcp_agent.logging.logger import get_logger
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -34,7 +34,7 @@ class FanOut(ContextDependent):
         llm_factory: Callable[[Agent], AugmentedLLM[MessageParamT, MessageT]] = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         """
         Initialize the FanOut with a list of agents, functions, or LLMs.
         If agents are provided, they will be wrapped in an AugmentedLLM using llm_factory if not already done so.
@@ -47,9 +47,7 @@ class FanOut(ContextDependent):
         self.functions: List[Callable[[MessageParamT], MessageT]] = functions or []
 
         if not self.agents and not self.functions:
-            raise ValueError(
-                "At least one agent or function must be provided for fan-out to work"
-            )
+            raise ValueError("At least one agent or function must be provided for fan-out to work")
 
         if not self.llm_factory:
             for agent in self.agents:
@@ -65,9 +63,7 @@ class FanOut(ContextDependent):
         Request fan-out agent/function generations, and return the results as a dictionary.
         The keys are the names of the agents or functions that generated the results.
         """
-        tasks: List[
-            Callable[..., List[MessageT]] | Coroutine[Any, Any, List[MessageT]]
-        ] = []
+        tasks: List[Callable[..., List[MessageT]] | Coroutine[Any, Any, List[MessageT]]] = []
         task_names: List[str] = []
         task_results = []
 
@@ -97,9 +93,7 @@ class FanOut(ContextDependent):
             logger.debug("Running fan-out tasks:", data=task_names)
             task_results = await self.executor.execute(*tasks)
 
-        logger.debug(
-            "Fan-out tasks completed:", data=dict(zip(task_names, task_results))
-        )
+        logger.debug("Fan-out tasks completed:", data=dict(zip(task_names, task_results)))
         return dict(zip(task_names, task_results))
 
     async def generate_str(

mcp_agent/workflows/parallel/parallel_llm.py

@@ -1,5 +1,5 @@
-from typing import Any, Callable, List, Optional, Type, TYPE_CHECKING, Union
 import asyncio
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Type, Union
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.workflows.llm.augmented_llm import (
@@ -30,7 +30,7 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
         context: Optional["Context"] = None,
         include_request: bool = True,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(context=context, **kwargs)
         self.fan_in_agent = fan_in_agent
         self.fan_out_agents = fan_out_agents
@@ -63,14 +63,10 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
         fan_in_llm = await self.ensure_llm(self.fan_in_agent)
 
         # Run fan-out operations in parallel
-        responses = await asyncio.gather(
-            *[llm.generate(message, request_params) for llm in fan_out_llms]
-        )
+        responses = await asyncio.gather(*[llm.generate(message, request_params) for llm in fan_out_llms])
 
         # Get message string for inclusion in formatted output
-        message_str = (
-            str(message) if isinstance(message, (str, MessageParamT)) else None
-        )
+        message_str = str(message) if isinstance(message, (str, MessageParamT)) else None
 
         # Run fan-in to aggregate results
         result = await fan_in_llm.generate(
@@ -95,14 +91,10 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
         fan_in_llm = await self.ensure_llm(self.fan_in_agent)
 
         # Run fan-out operations in parallel
-        responses = await asyncio.gather(
-            *[llm.generate_str(message, request_params) for llm in fan_out_llms]
-        )
+        responses = await asyncio.gather(*[llm.generate_str(message, request_params) for llm in fan_out_llms])
 
         # Get message string for inclusion in formatted output
-        message_str = (
-            str(message) if isinstance(message, (str, MessageParamT)) else None
-        )
+        message_str = str(message) if isinstance(message, (str, MessageParamT)) else None
 
         # Run fan-in to aggregate results
         result = await fan_in_llm.generate_str(
@@ -128,17 +120,10 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
         fan_in_llm = await self.ensure_llm(self.fan_in_agent)
 
         # Run fan-out operations in parallel
-        responses = await asyncio.gather(
-            *[
-                llm.generate_structured(message, response_model, request_params)
-                for llm in fan_out_llms
-            ]
-        )
+        responses = await asyncio.gather(*[llm.generate_structured(message, response_model, request_params) for llm in fan_out_llms])
 
         # Get message string for inclusion in formatted output
-        message_str = (
-            str(message) if isinstance(message, (str, MessageParamT)) else None
-        )
+        message_str = str(message) if isinstance(message, (str, MessageParamT)) else None
 
         # Run fan-in to aggregate results
         result = await fan_in_llm.generate_structured(
@@ -160,7 +145,5 @@ class ParallelLLM(AugmentedLLM[MessageParamT, MessageT]):
 
         for i, response in enumerate(responses):
             agent_name = self.fan_out_agents[i].name
-            formatted.append(
-                f'<fastagent:response agent="{agent_name}">\n{response}\n</fastagent:response>'
-            )
+            formatted.append(f'<fastagent:response agent="{agent_name}">\n{response}\n</fastagent:response>')
         return "\n\n".join(formatted)

mcp_agent/workflows/router/router_base.py

@@ -1,8 +1,8 @@
 from abc import ABC, abstractmethod
-from typing import Callable, Dict, Generic, List, Optional, TypeVar, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Dict, Generic, List, Optional, TypeVar
 
-from pydantic import BaseModel, Field, ConfigDict
 from mcp.server.fastmcp.tools import Tool as FastTool
+from pydantic import BaseModel, ConfigDict, Field
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.context_dependent import ContextDependent
@@ -98,7 +98,7 @@ class Router(ABC, ContextDependent):
         routing_instruction: str | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(context=context, **kwargs)
         self.routing_instruction = routing_instruction
         self.server_names = server_names or []
@@ -115,19 +115,13 @@ class Router(ABC, ContextDependent):
         self.initialized: bool = False
 
         if not self.server_names and not self.agents and not self.functions:
-            raise ValueError(
-                "At least one of mcp_servers_names, agents, or functions must be provided."
-            )
+            raise ValueError("At least one of mcp_servers_names, agents, or functions must be provided.")
 
         if self.server_names and not self.server_registry:
-            raise ValueError(
-                "server_registry must be provided if mcp_servers_names are provided."
-            )
+            raise ValueError("server_registry must be provided if mcp_servers_names are provided.")
 
     @abstractmethod
-    async def route(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[str | Agent | Callable]]:
+    async def route(self, request: str, top_k: int = 1) -> List[RouterResult[str | Agent | Callable]]:
         """
         Route the input request to one or more MCP servers, agents, or functions.
         If no routing decision can be made, returns an empty list.
@@ -138,21 +132,15 @@ class Router(ABC, ContextDependent):
         """
 
     @abstractmethod
-    async def route_to_server(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[str]]:
+    async def route_to_server(self, request: str, top_k: int = 1) -> List[RouterResult[str]]:
         """Route the input to one or more MCP servers."""
 
     @abstractmethod
-    async def route_to_agent(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[Agent]]:
+    async def route_to_agent(self, request: str, top_k: int = 1) -> List[RouterResult[Agent]]:
         """Route the input to one or more agents."""
 
     @abstractmethod
-    async def route_to_function(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[Callable]]:
+    async def route_to_function(self, request: str, top_k: int = 1) -> List[RouterResult[Callable]]:
         """
         Route the input to one or more functions.
 
@@ -160,30 +148,20 @@ class Router(ABC, ContextDependent):
             input: The input to route.
         """
 
-    async def initialize(self):
+    async def initialize(self) -> None:
         """Initialize the router categories."""
 
         if self.initialized:
             return
 
-        server_categories = [
-            self.get_server_category(server_name) for server_name in self.server_names
-        ]
-        self.server_categories = {
-            category.name: category for category in server_categories
-        }
+        server_categories = [self.get_server_category(server_name) for server_name in self.server_names]
+        self.server_categories = {category.name: category for category in server_categories}
 
         agent_categories = [self.get_agent_category(agent) for agent in self.agents]
-        self.agent_categories = {
-            category.name: category for category in agent_categories
-        }
+        self.agent_categories = {category.name: category for category in agent_categories}
 
-        function_categories = [
-            self.get_function_category(function) for function in self.functions
-        ]
-        self.function_categories = {
-            category.name: category for category in function_categories
-        }
+        function_categories = [self.get_function_category(function) for function in self.functions]
+        self.function_categories = {category.name: category for category in function_categories}
 
         all_categories = server_categories + agent_categories + function_categories
 
@@ -204,15 +182,11 @@ class Router(ABC, ContextDependent):
         )
 
     def get_agent_category(self, agent: Agent) -> AgentRouterCategory:
-        agent_description = (
-            agent.instruction({}) if callable(agent.instruction) else agent.instruction
-        )
+        agent_description = agent.instruction({}) if callable(agent.instruction) else agent.instruction
 
         # Just get server categories without attempting to access tools
         # This is a simpler approach that avoids potential issues with uninitialized agents
-        server_categories = [
-            self.get_server_category(server_name) for server_name in agent.server_names
-        ]
+        server_categories = [self.get_server_category(server_name) for server_name in agent.server_names]
 
         return AgentRouterCategory(
             category=agent,
@@ -230,9 +204,7 @@ class Router(ABC, ContextDependent):
             description=tool.description,
         )
 
-    def format_category(
-        self, category: RouterCategory, index: int | None = None
-    ) -> str:
+    def format_category(self, category: RouterCategory, index: int | None = None) -> str:
         """Format a category into a readable string."""
 
         if isinstance(category, ServerRouterCategory):
@@ -265,16 +237,16 @@ class Router(ABC, ContextDependent):
         # Check if we have any content (description or tools)
         has_description = bool(category.description)
         has_tools = bool(category.tools)
-        
+
         # If no content at all, use self-closing tag
         if not has_description and not has_tools:
             return f'<fastagent:server-category name="{category.name}" />'
-            
+
         # Otherwise, build the content
         description_section = ""
         if has_description:
             description_section = f"\n<fastagent:description>{category.description}</fastagent:description>"
-            
+
         # Add tools section if we have tool information
         if has_tools:
             tools = self._format_tools(category.tools)
@@ -293,11 +265,11 @@ class Router(ABC, ContextDependent):
         # Check if we have any content (description or servers)
         has_description = bool(category.description)
         has_servers = bool(category.servers)
-        
+
         # If no content at all, use self-closing tag
         if not has_description and not has_servers:
             return f'<fastagent:agent-category name="{category.name}" />'
-            
+
         # Build description section if needed
         description_section = ""
         if has_description:
@@ -314,13 +286,13 @@ class Router(ABC, ContextDependent):
             # Check if this server has any content
             has_server_description = bool(server.description)
             has_server_tools = bool(server.tools)
-            
+
             # Use self-closing tag if server has no content
             if not has_server_description and not has_server_tools:
                 server_section = f'<fastagent:server name="{server.name}" />'
                 server_sections.append(server_section)
                 continue
-                
+
             # Build server description if needed
             server_desc_section = ""
             if has_server_description:
@@ -331,9 +303,7 @@ class Router(ABC, ContextDependent):
                 tool_items = []
                 for tool in server.tools:
                     tool_desc = tool.description if tool.description else ""
-                    tool_items.append(
-                        f'<fastagent:tool name="{tool.name}">{tool_desc}</fastagent:tool>'
-                    )
+                    tool_items.append(f'<fastagent:tool name="{tool.name}">{tool_desc}</fastagent:tool>')
 
                 tools_section = f"\n<fastagent:tools>\n{chr(10).join(tool_items)}\n</fastagent:tools>"
                 server_section = f"""<fastagent:server name="{server.name}">{server_desc_section}{tools_section}
@@ -342,7 +312,7 @@ class Router(ABC, ContextDependent):
                 # Just description, no tools
                 server_section = f"""<fastagent:server name="{server.name}">{server_desc_section}
 </fastagent:server>"""
-            
+
             server_sections.append(server_section)
 
         servers = "\n".join(server_sections)
@@ -357,11 +327,11 @@ class Router(ABC, ContextDependent):
         """Format a function category into a readable string."""
         # Check if we have a description
         has_description = bool(category.description)
-        
+
         # If no description, use self-closing tag
         if not has_description:
             return f'<fastagent:function-category name="{category.name}" />'
-            
+
         # Include description
         return f"""<fastagent:function-category name="{category.name}">
 <fastagent:description>{category.description}</fastagent:description>

mcp_agent/workflows/router/router_embedding.py

@@ -1,4 +1,4 @@
-from typing import Callable, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from numpy import mean
 
@@ -6,8 +6,8 @@ from mcp_agent.agents.agent import Agent
 from mcp_agent.workflows.embedding.embedding_base import (
     EmbeddingModel,
     FloatArray,
-    compute_similarity_scores,
     compute_confidence,
+    compute_similarity_scores,
 )
 from mcp_agent.workflows.router.router_base import (
     Router,
@@ -56,7 +56,7 @@ class EmbeddingRouter(Router):
         functions: List[Callable] | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(
             server_names=server_names,
             agents=agents,
@@ -90,7 +90,7 @@ class EmbeddingRouter(Router):
         await instance.initialize()
         return instance
 
-    async def initialize(self):
+    async def initialize(self) -> None:
         """Initialize by computing embeddings for all categories"""
 
         async def create_category_with_embedding(
@@ -99,9 +99,7 @@ class EmbeddingRouter(Router):
             # Get formatted text representation of category
             category_text = self.format_category(category)
             embedding = self._compute_embedding([category_text])
-            category_with_embedding = EmbeddingRouterCategory(
-                **category, embedding=embedding
-            )
+            category_with_embedding = EmbeddingRouterCategory(**category, embedding=embedding)
 
             return category_with_embedding
 
@@ -129,18 +127,14 @@ class EmbeddingRouter(Router):
 
         self.initialized = True
 
-    async def route(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[str | Agent | Callable]]:
+    async def route(self, request: str, top_k: int = 1) -> List[RouterResult[str | Agent | Callable]]:
         """Route the request based on embedding similarity"""
         if not self.initialized:
             await self.initialize()
 
         return await self._route_with_embedding(request, top_k)
 
-    async def route_to_server(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[str]]:
+    async def route_to_server(self, request: str, top_k: int = 1) -> List[RouterResult[str]]:
         """Route specifically to server categories"""
         if not self.initialized:
             await self.initialize()
@@ -154,9 +148,7 @@ class EmbeddingRouter(Router):
         )
         return [r.result for r in results[:top_k]]
 
-    async def route_to_agent(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[Agent]]:
+    async def route_to_agent(self, request: str, top_k: int = 1) -> List[RouterResult[Agent]]:
         """Route specifically to agent categories"""
         if not self.initialized:
             await self.initialize()
@@ -170,9 +162,7 @@ class EmbeddingRouter(Router):
         )
         return [r.result for r in results[:top_k]]
 
-    async def route_to_function(
-        self, request: str, top_k: int = 1
-    ) -> List[RouterResult[Callable]]:
+    async def route_to_function(self, request: str, top_k: int = 1) -> List[RouterResult[Callable]]:
         """Route specifically to function categories"""
         if not self.initialized:
             await self.initialize()
@@ -198,13 +188,9 @@ class EmbeddingRouter(Router):
             if category.embedding is None:
                 return None
 
-            similarity = compute_similarity_scores(
-                request_embedding, category.embedding
-            )
+            similarity = compute_similarity_scores(request_embedding, category.embedding)
 
-            return RouterResult(
-                p_score=compute_confidence(similarity), result=category.category
-            )
+            return RouterResult(p_score=compute_confidence(similarity), result=category.category)
 
         request_embedding = self._compute_embedding([request])
 

mcp_agent/workflows/router/router_embedding_cohere.py

@@ -1,4 +1,4 @@
-from typing import Callable, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.workflows.embedding.embedding_cohere import CohereEmbeddingModel
@@ -23,7 +23,7 @@ class CohereEmbeddingRouter(EmbeddingRouter):
         embedding_model: CohereEmbeddingModel | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         embedding_model = embedding_model or CohereEmbeddingModel()
 
         super().__init__(

mcp_agent/workflows/router/router_embedding_openai.py

@@ -1,4 +1,4 @@
-from typing import Callable, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, List, Optional
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.workflows.embedding.embedding_openai import OpenAIEmbeddingModel
@@ -23,7 +23,7 @@ class OpenAIEmbeddingRouter(EmbeddingRouter):
         embedding_model: OpenAIEmbeddingModel | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         embedding_model = embedding_model or OpenAIEmbeddingModel()
 
         super().__init__(