fast-agent-mcp 0.1.12__py3-none-any.whl → 0.2.0__py3-none-any.whl

mcp_agent/core/validation.py

@@ -2,14 +2,15 @@
 Validation utilities for FastAgent configuration and dependencies.
 """
 
-from typing import Dict, List, Any
+from typing import Any, Dict, List
+
 from mcp_agent.core.agent_types import AgentType
-from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
 from mcp_agent.core.exceptions import (
-    ServerConfigError,
     AgentConfigError,
     CircularDependencyError,
+    ServerConfigError,
 )
+from mcp_agent.llm.augmented_llm import AugmentedLLM
 
 
 def validate_server_references(context, agents: Dict[str, Dict[str, Any]]) -> None:
@@ -55,7 +56,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
         if agent_type == AgentType.PARALLEL.value:
             # Check fan_in exists
             fan_in = agent_data["fan_in"]
-            if fan_in not in available_components:
+            if fan_in and fan_in not in available_components:
                 raise AgentConfigError(
                     f"Parallel workflow '{name}' references non-existent fan_in component: {fan_in}"
                 )
@@ -105,7 +106,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
 
         elif agent_type == AgentType.ROUTER.value:
             # Check all referenced agents exist
-            router_agents = agent_data["agents"]
+            router_agents = agent_data["router_agents"]
             missing = [a for a in router_agents if a not in available_components]
             if missing:
                 raise AgentConfigError(
@@ -186,7 +187,7 @@ def get_dependencies(
             deps.extend(get_dependencies(fan_out, agents, visited, path, agent_type))
     elif config["type"] == AgentType.CHAIN.value:
         # Get dependencies from sequence agents
-        sequence = config.get("sequence", config.get("agents", []))
+        sequence = config.get("sequence", config.get("router_agents", []))
         for agent_name in sequence:
             deps.extend(get_dependencies(agent_name, agents, visited, path, agent_type))
 
@@ -198,23 +199,96 @@ def get_dependencies(
     return deps
 
 
-def get_parallel_dependencies(
-    name: str, agents: Dict[str, Dict[str, Any]], visited: set, path: set
-) -> List[str]:
+def get_dependencies_groups(
+    agents_dict: Dict[str, Dict[str, Any]], allow_cycles: bool = False
+) -> List[List[str]]:
     """
-    Get dependencies for a parallel agent in topological order.
-    Legacy function that calls the more general get_dependencies.
+    Get dependencies between agents and group them into dependency layers.
+    Each layer can be initialized in parallel.
 
     Args:
-        name: Name of the parallel agent
-        agents: Dictionary of agent configurations
-        visited: Set of already visited agents
-        path: Current path for cycle detection
+        agents_dict: Dictionary of agent configurations
+        allow_cycles: Whether to allow cyclic dependencies
 
     Returns:
-        List of agent names in dependency order
+        List of lists, where each inner list is a group of agents that can be initialized together
 
     Raises:
-        CircularDependencyError: If circular dependency detected
+        CircularDependencyError: If circular dependency detected and allow_cycles is False
     """
-    return get_dependencies(name, agents, visited, path, AgentType.PARALLEL)
+    # Get all agent names
+    agent_names = list(agents_dict.keys())
+
+    # Dictionary to store dependencies for each agent
+    dependencies = {name: set() for name in agent_names}
+
+    # Build the dependency graph
+    for name, agent_data in agents_dict.items():
+        agent_type = agent_data["type"]
+
+        if agent_type == AgentType.PARALLEL.value:
+            # Parallel agents depend on their fan-out and fan-in agents
+            dependencies[name].update(agent_data.get("parallel_agents", []))
+        elif agent_type == AgentType.CHAIN.value:
+            # Chain agents depend on the agents in their sequence
+            dependencies[name].update(agent_data.get("chain_agents", []))
+        elif agent_type == AgentType.ROUTER.value:
+            # Router agents depend on the agents they route to
+            dependencies[name].update(agent_data.get("router_agents", []))
+        elif agent_type == AgentType.ORCHESTRATOR.value:
+            # Orchestrator agents depend on their child agents
+            dependencies[name].update(agent_data.get("child_agents", []))
+        elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
+            # Evaluator-Optimizer agents depend on their evaluation and optimization agents
+            dependencies[name].update(agent_data.get("eval_optimizer_agents", []))
+
+    # Check for cycles if not allowed
+    if not allow_cycles:
+        visited = set()
+        path = set()
+
+        def visit(node) -> None:
+            if node in path:
+                path_str = " -> ".join(path) + " -> " + node
+                raise CircularDependencyError(f"Circular dependency detected: {path_str}")
+            if node in visited:
+                return
+
+            path.add(node)
+            for dep in dependencies[node]:
+                if dep in agent_names:  # Skip dependencies to non-existent agents
+                    visit(dep)
+            path.remove(node)
+            visited.add(node)
+
+        # Check each node
+        for name in agent_names:
+            if name not in visited:
+                visit(name)
+
+    # Group agents by dependency level
+    result = []
+    remaining = set(agent_names)
+
+    while remaining:
+        # Find all agents that have no remaining dependencies
+        current_level = set()
+        for name in remaining:
+            if not dependencies[name] & remaining:  # If no dependencies in remaining agents
+                current_level.add(name)
+
+        if not current_level:
+            if allow_cycles:
+                # If cycles are allowed, just add one remaining node to break the cycle
+                current_level.add(next(iter(remaining)))
+            else:
+                # This should not happen if we checked for cycles
+                raise CircularDependencyError("Unresolvable dependency cycle detected")
+
+        # Add the current level to the result
+        result.append(list(current_level))
+
+        # Remove current level from remaining
+        remaining -= current_level
+
+    return result

mcp_agent/executor/decorator_registry.py

@@ -11,7 +11,7 @@ R = TypeVar("R")
 class DecoratorRegistry:
     """Centralized decorator management with validation and metadata."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._workflow_defn_decorators: Dict[str, Callable[[Type], Type]] = {}
         self._workflow_run_decorators: Dict[
             str, Callable[[Callable[..., R]], Callable[..., R]]
@@ -21,7 +21,7 @@ class DecoratorRegistry:
         self,
         executor_name: str,
         decorator: Callable[[Type], Type],
-    ):
+    ) -> None:
         """
         Registers a workflow definition decorator for a given executor.
 
@@ -48,7 +48,7 @@ class DecoratorRegistry:
         self,
         executor_name: str,
         decorator: Callable[[Callable[..., R]], Callable[..., R]],
-    ):
+    ) -> None:
         """
         Registers a workflow run decorator for a given executor.
 
@@ -88,18 +88,14 @@ def default_workflow_run(fn: Callable[..., R]) -> Callable[..., R]:
     return wrapper
 
 
-def register_asyncio_decorators(decorator_registry: DecoratorRegistry):
+def register_asyncio_decorators(decorator_registry: DecoratorRegistry) -> None:
     """Registers default asyncio decorators."""
     executor_name = "asyncio"
-    decorator_registry.register_workflow_defn_decorator(
-        executor_name, default_workflow_defn
-    )
-    decorator_registry.register_workflow_run_decorator(
-        executor_name, default_workflow_run
-    )
+    decorator_registry.register_workflow_defn_decorator(executor_name, default_workflow_defn)
+    decorator_registry.register_workflow_run_decorator(executor_name, default_workflow_run)
 
 
-def register_temporal_decorators(decorator_registry: DecoratorRegistry):
+def register_temporal_decorators(decorator_registry: DecoratorRegistry) -> None:
     """Registers Temporal decorators if Temporal SDK is available."""
     try:
         import temporalio.workflow as temporal_workflow
@@ -112,9 +108,5 @@ def register_temporal_decorators(decorator_registry: DecoratorRegistry):
         return
 
     executor_name = "temporal"
-    decorator_registry.register_workflow_defn_decorator(
-        executor_name, temporal_workflow.defn
-    )
-    decorator_registry.register_workflow_run_decorator(
-        executor_name, temporal_workflow.run
-    )
+    decorator_registry.register_workflow_defn_decorator(executor_name, temporal_workflow.defn)
+    decorator_registry.register_workflow_run_decorator(executor_name, temporal_workflow.run)

mcp_agent/executor/executor.py

@@ -4,6 +4,7 @@ from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
 from datetime import timedelta
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncIterator,
     Callable,
@@ -13,7 +14,6 @@ from typing import (
     Optional,
     Type,
     TypeVar,
-    TYPE_CHECKING,
 )
 
 from pydantic import BaseModel, ConfigDict
@@ -56,7 +56,7 @@ class Executor(ABC, ContextDependent):
         signal_bus: SignalHandler = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(context=context, **kwargs)
         self.execution_engine = engine
 
@@ -127,9 +127,7 @@ class Executor(ABC, ContextDependent):
 
         return results
 
-    async def validate_task(
-        self, task: Callable[..., R] | Coroutine[Any, Any, R]
-    ) -> None:
+    async def validate_task(self, task: Callable[..., R] | Coroutine[Any, Any, R]) -> None:
         """Validate a task before execution."""
         if not (asyncio.iscoroutine(task) or asyncio.iscoroutinefunction(task)):
             raise TypeError(f"Task must be async: {task}")
@@ -164,7 +162,7 @@ class Executor(ABC, ContextDependent):
 
         # Notify any callbacks that the workflow is about to be paused waiting for a signal
         if self.context.signal_notification:
-            self.context.signal_notification(
+            await self.context.signal_notification(
                 signal_name=signal_name,
                 request_id=request_id,
                 workflow_id=workflow_id,
@@ -188,15 +186,13 @@ class AsyncioExecutor(Executor):
         self,
         config: ExecutorConfig | None = None,
         signal_bus: SignalHandler | None = None,
-    ):
+    ) -> None:
         signal_bus = signal_bus or AsyncioSignalHandler()
         super().__init__(engine="asyncio", config=config, signal_bus=signal_bus)
 
         self._activity_semaphore: asyncio.Semaphore | None = None
         if self.config.max_concurrent_activities is not None:
-            self._activity_semaphore = asyncio.Semaphore(
-                self.config.max_concurrent_activities
-            )
+            self._activity_semaphore = asyncio.Semaphore(self.config.max_concurrent_activities)
 
     async def _execute_task(
         self, task: Callable[..., R] | Coroutine[Any, Any, R], **kwargs: Any
@@ -253,16 +249,11 @@ class AsyncioExecutor(Executor):
         # TODO: saqadri - validate if async with self.execution_context() is needed here
         async with self.execution_context():
             # Create futures for all tasks
-            futures = [
-                asyncio.create_task(self._execute_task(task, **kwargs))
-                for task in tasks
-            ]
+            futures = [asyncio.create_task(self._execute_task(task, **kwargs)) for task in tasks]
             pending = set(futures)
 
             while pending:
-                done, pending = await asyncio.wait(
-                    pending, return_when=asyncio.FIRST_COMPLETED
-                )
+                done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
                 for future in done:
                     yield await future
 

mcp_agent/executor/task_registry.py

@@ -10,13 +10,11 @@ from typing import Any, Callable, Dict, List
 class ActivityRegistry:
     """Centralized task/activity management with validation and metadata."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._activities: Dict[str, Callable] = {}
         self._metadata: Dict[str, Dict[str, Any]] = {}
 
-    def register(
-        self, name: str, func: Callable, metadata: Dict[str, Any] | None = None
-    ):
+    def register(self, name: str, func: Callable, metadata: Dict[str, Any] | None = None) -> None:
         if name in self._activities:
             raise ValueError(f"Activity '{name}' is already registered.")
         self._activities[name] = func

mcp_agent/executor/temporal.py

@@ -9,6 +9,7 @@ import asyncio
 import functools
 import uuid
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncIterator,
     Callable,
@@ -16,11 +17,10 @@ from typing import (
     Dict,
     List,
     Optional,
-    TYPE_CHECKING,
 )
 
 from pydantic import ConfigDict
-from temporalio import activity, workflow, exceptions
+from temporalio import activity, exceptions, workflow
 from temporalio.client import Client as TemporalClient
 from temporalio.worker import Worker
 
@@ -59,22 +59,18 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
 
         # Define the signal handler for this specific registration
         @workflow.signal(name=unique_signal_name)
-        def signal_handler(value: SignalValueT):
+        def signal_handler(value: SignalValueT) -> None:
             container["value"] = value
             container["completed"] = True
 
         async with self._lock:
             # Register both the signal registration and handler atomically
             self._pending_signals.setdefault(signal.name, []).append(registration)
-            self._handlers.setdefault(signal.name, []).append(
-                (unique_signal_name, signal_handler)
-            )
+            self._handlers.setdefault(signal.name, []).append((unique_signal_name, signal_handler))
 
         try:
             # Wait for signal with optional timeout
-            await workflow.wait_condition(
-                lambda: container["completed"], timeout=timeout_seconds
-            )
+            await workflow.wait_condition(lambda: container["completed"], timeout=timeout_seconds)
 
             return container["value"]
         except asyncio.TimeoutError as exc:
@@ -94,9 +90,7 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
                 # Remove ourselves from _handlers
                 if signal.name in self._handlers:
                     self._handlers[signal.name] = [
-                        h
-                        for h in self._handlers[signal.name]
-                        if h[0] != unique_signal_name
+                        h for h in self._handlers[signal.name] if h[0] != unique_signal_name
                     ]
                     if not self._handlers[signal.name]:
                         del self._handlers[signal.name]
@@ -110,7 +104,7 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
 
             # Create the actual handler that will be registered with Temporal
             @workflow.signal(name=unique_signal_name)
-            async def wrapped(signal_value: SignalValueT):
+            async def wrapped(signal_value: SignalValueT) -> None:
                 # Create a signal object to pass to the handler
                 signal = Signal(
                     name=signal_name,
@@ -123,19 +117,15 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
                     func(signal)
 
             # Register the handler under the original signal name
-            self._handlers.setdefault(signal_name, []).append(
-                (unique_signal_name, wrapped)
-            )
+            self._handlers.setdefault(signal_name, []).append((unique_signal_name, wrapped))
             return func
 
         return decorator
 
-    async def signal(self, signal):
+    async def signal(self, signal) -> None:
         self.validate_signal(signal)
 
-        workflow_handle = workflow.get_external_workflow_handle(
-            workflow_id=signal.workflow_id
-        )
+        workflow_handle = workflow.get_external_workflow_handle(workflow_id=signal.workflow_id)
 
         # Send the signal to all registrations of this signal
         async with self._lock:
@@ -147,9 +137,7 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
                     if registration.workflow_id == signal.workflow_id:
                         # Only signal for registrations of that workflow
                         signal_tasks.append(
-                            workflow_handle.signal(
-                                registration.unique_name, signal.payload
-                            )
+                            workflow_handle.signal(registration.unique_name, signal.payload)
                         )
                     else:
                         continue
@@ -157,13 +145,11 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
             # Notify any registered handler functions
             if signal.name in self._handlers:
                 for unique_name, _ in self._handlers[signal.name]:
-                    signal_tasks.append(
-                        workflow_handle.signal(unique_name, signal.payload)
-                    )
+                    signal_tasks.append(workflow_handle.signal(unique_name, signal.payload))
 
         await asyncio.gather(*signal_tasks, return_exceptions=True)
 
-    def validate_signal(self, signal):
+    def validate_signal(self, signal) -> None:
         super().validate_signal(signal)
         # Add TemporalSignalHandler-specific validation
         if signal.workflow_id is None:
@@ -188,7 +174,7 @@ class TemporalExecutor(Executor):
         client: TemporalClient | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         signal_bus = signal_bus or TemporalSignalHandler()
         super().__init__(
             engine="temporal",
@@ -205,9 +191,7 @@ class TemporalExecutor(Executor):
         self._activity_semaphore = None
 
         if config.max_concurrent_activities is not None:
-            self._activity_semaphore = asyncio.Semaphore(
-                self.config.max_concurrent_activities
-            )
+            self._activity_semaphore = asyncio.Semaphore(self.config.max_concurrent_activities)
 
     @staticmethod
     def wrap_as_activity(
@@ -275,9 +259,7 @@ class TemporalExecutor(Executor):
         func = task.func if isinstance(task, functools.partial) else task
         is_workflow_task = getattr(func, "is_workflow_task", False)
         if not is_workflow_task:
-            return await asyncio.create_task(
-                self._execute_task_as_async(task, **kwargs)
-            )
+            return await asyncio.create_task(self._execute_task_as_async(task, **kwargs))
 
         execution_metadata: Dict[str, Any] = getattr(func, "execution_metadata", {})
 
@@ -319,9 +301,7 @@ class TemporalExecutor(Executor):
     ) -> List[R | BaseException]:
         # Must be called from within a workflow
         if not workflow._Runtime.current():
-            raise RuntimeError(
-                "TemporalExecutor.execute must be called from within a workflow"
-            )
+            raise RuntimeError("TemporalExecutor.execute must be called from within a workflow")
 
         # TODO: saqadri - validate if async with self.execution_context() is needed here
         async with self.execution_context():
@@ -347,9 +327,7 @@ class TemporalExecutor(Executor):
             pending = set(futures)
 
             while pending:
-                done, pending = await workflow.wait(
-                    pending, return_when=asyncio.FIRST_COMPLETED
-                )
+                done, pending = await workflow.wait(pending, return_when=asyncio.FIRST_COMPLETED)
                 for future in done:
                     try:
                         result = await future
@@ -368,7 +346,7 @@ class TemporalExecutor(Executor):
 
         return self.client
 
-    async def start_worker(self):
+    async def start_worker(self) -> None:
         """
         Start a worker in this process, auto-registering all tasks
         from the global registry. Also picks up any classes decorated

mcp_agent/executor/workflow.py

@@ -62,7 +62,7 @@ class Workflow(ABC, Generic[T]):
         name: str | None = None,
         metadata: Dict[str, Any] | None = None,
         **kwargs: Any,
-    ):
+    ) -> None:
         self.executor = executor
         self.name = name or self.__class__.__name__
         self.init_kwargs = kwargs
@@ -80,7 +80,7 @@ class Workflow(ABC, Generic[T]):
         Main workflow implementation. Must be overridden by subclasses.
         """
 
-    async def update_state(self, **kwargs):
+    async def update_state(self, **kwargs) -> None:
         """Syntactic sugar to update workflow state."""
         for key, value in kwargs.items():
             self.state[key] = value
@@ -93,9 +93,7 @@ class Workflow(ABC, Generic[T]):
         Convenience method for human input. Uses `human_input` signal
         so we can unify local (console input) and Temporal signals.
         """
-        return await self.executor.wait_for_signal(
-            "human_input", description=description
-        )
+        return await self.executor.wait_for_signal("human_input", description=description)
 
 
 # ############################

mcp_agent/executor/workflow_signal.py

@@ -1,6 +1,6 @@
 import asyncio
 import uuid
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 from typing import Any, Callable, Dict, Generic, List, Protocol, TypeVar
 
 from pydantic import BaseModel, ConfigDict
@@ -71,14 +71,14 @@ class PendingSignal(BaseModel):
 class BaseSignalHandler(ABC, Generic[SignalValueT]):
     """Base class implementing common signal handling functionality."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Map signal_name -> list of PendingSignal objects
         self._pending_signals: Dict[str, List[PendingSignal]] = {}
         # Map signal_name -> list of (unique_name, handler) tuples
         self._handlers: Dict[str, List[tuple[str, Callable]]] = {}
         self._lock = asyncio.Lock()
 
-    async def cleanup(self, signal_name: str | None = None):
+    async def cleanup(self, signal_name: str | None = None) -> None:
         """Clean up handlers and registrations for a signal or all signals."""
         async with self._lock:
             if signal_name:
@@ -90,7 +90,7 @@ class BaseSignalHandler(ABC, Generic[SignalValueT]):
                 self._handlers.clear()
                 self._pending_signals.clear()
 
-    def validate_signal(self, signal: Signal[SignalValueT]):
+    def validate_signal(self, signal: Signal[SignalValueT]) -> None:
         """Validate signal properties."""
         if not signal.name:
             raise ValueError("Signal name is required")
@@ -102,7 +102,7 @@ class BaseSignalHandler(ABC, Generic[SignalValueT]):
         def decorator(func: Callable) -> Callable:
             unique_name = f"{signal_name}_{uuid.uuid4()}"
 
-            async def wrapped(value: SignalValueT):
+            async def wrapped(value: SignalValueT) -> None:
                 try:
                     if asyncio.iscoroutinefunction(func):
                         await func(value)
@@ -133,7 +133,7 @@ class BaseSignalHandler(ABC, Generic[SignalValueT]):
 class ConsoleSignalHandler(SignalHandler[str]):
     """Simple console-based signal handling (blocks on input)."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._pending_signals: Dict[str, List[PendingSignal]] = {}
         self._handlers: Dict[str, List[Callable]] = {}
 
@@ -163,7 +163,7 @@ class ConsoleSignalHandler(SignalHandler[str]):
 
     def on_signal(self, signal_name):
         def decorator(func):
-            async def wrapped(value: SignalValueT):
+            async def wrapped(value: SignalValueT) -> None:
                 if asyncio.iscoroutinefunction(func):
                     await func(value)
                 else:
@@ -174,13 +174,11 @@ class ConsoleSignalHandler(SignalHandler[str]):
 
         return decorator
 
-    async def signal(self, signal):
+    async def signal(self, signal) -> None:
         print(f"[SIGNAL SENT: {signal.name}] Value: {signal.payload}")
 
         handlers = self._handlers.get(signal.name, [])
-        await asyncio.gather(
-            *(handler(signal) for handler in handlers), return_exceptions=True
-        )
+        await asyncio.gather(*(handler(signal) for handler in handlers), return_exceptions=True)
 
         # Notify any waiting coroutines
         if signal.name in self._pending_signals:
@@ -194,9 +192,7 @@ class AsyncioSignalHandler(BaseSignalHandler[SignalValueT]):
     Asyncio-based signal handling using an internal dictionary of asyncio Events.
     """
 
-    async def wait_for_signal(
-        self, signal, timeout_seconds: int | None = None
-    ) -> SignalValueT:
+    async def wait_for_signal(self, signal, timeout_seconds: int | None = None) -> SignalValueT:
         event = asyncio.Event()
         unique_name = str(uuid.uuid4())
 
@@ -236,7 +232,7 @@ class AsyncioSignalHandler(BaseSignalHandler[SignalValueT]):
 
     def on_signal(self, signal_name):
         def decorator(func):
-            async def wrapped(value: SignalValueT):
+            async def wrapped(value: SignalValueT) -> None:
                 if asyncio.iscoroutinefunction(func):
                     await func(value)
                 else:
@@ -247,7 +243,7 @@ class AsyncioSignalHandler(BaseSignalHandler[SignalValueT]):
 
         return decorator
 
-    async def signal(self, signal):
+    async def signal(self, signal) -> None:
         async with self._lock:
             # Notify any waiting coroutines
             if signal.name in self._pending_signals:
@@ -272,11 +268,11 @@ class LocalSignalStore:
     and triggers them when a signal is emitted.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         # For each signal_name, store a list of futures that are waiting for it
         self._waiters: Dict[str, List[asyncio.Future]] = {}
 
-    async def emit(self, signal_name: str, payload: Any):
+    async def emit(self, signal_name: str, payload: Any) -> None:
         # If we have waiting futures, set their result
         if signal_name in self._waiters:
             for future in self._waiters[signal_name]:
@@ -284,9 +280,7 @@ class LocalSignalStore:
                     future.set_result(payload)
             self._waiters[signal_name].clear()
 
-    async def wait_for(
-        self, signal_name: str, timeout_seconds: int | None = None
-    ) -> Any:
+    async def wait_for(self, signal_name: str, timeout_seconds: int | None = None) -> Any:
         loop = asyncio.get_running_loop()
         future = loop.create_future()