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

mcp_agent/core/validation.py

@@ -2,17 +2,22 @@
 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.core.exceptions import (
+    AgentConfigError,
+    CircularDependencyError,
+    ServerConfigError,
+)
 from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
-from mcp_agent.core.exceptions import ServerConfigError, AgentConfigError, CircularDependencyError
 
 
 def validate_server_references(context, agents: Dict[str, Dict[str, Any]]) -> None:
     """
     Validate that all server references in agent configurations exist in config.
     Raises ServerConfigError if any referenced servers are not defined.
-    
+
     Args:
         context: Application context
         agents: Dictionary of agent configurations
@@ -39,7 +44,7 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
     Validate that all workflow references point to valid agents/workflows.
     Also validates that referenced agents have required configuration.
     Raises AgentConfigError if any validation fails.
-    
+
     Args:
         agents: Dictionary of agent configurations
     """
@@ -133,11 +138,11 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
 
 
 def get_dependencies(
-    name: str, 
+    name: str,
     agents: Dict[str, Dict[str, Any]],
-    visited: set, 
-    path: set, 
-    agent_type: AgentType = None
+    visited: set,
+    path: set,
+    agent_type: AgentType = None,
 ) -> List[str]:
     """
     Get dependencies for an agent in topological order.
@@ -184,9 +189,7 @@ def get_dependencies(
         # Get dependencies from sequence agents
         sequence = config.get("sequence", config.get("agents", []))
         for agent_name in sequence:
-            deps.extend(
-                get_dependencies(agent_name, agents, visited, path, agent_type)
-            )
+            deps.extend(get_dependencies(agent_name, agents, visited, path, agent_type))
 
     # Add this agent after its dependencies
     deps.append(name)
@@ -197,10 +200,7 @@ def get_dependencies(
 
 
 def get_parallel_dependencies(
-    name: str, 
-    agents: Dict[str, Dict[str, Any]],
-    visited: set, 
-    path: set
+    name: str, agents: Dict[str, Dict[str, Any]], visited: set, path: set
 ) -> List[str]:
     """
     Get dependencies for a parallel agent in topological order.
@@ -218,4 +218,4 @@ def get_parallel_dependencies(
     Raises:
         CircularDependencyError: If circular dependency detected
     """
-    return get_dependencies(name, agents, visited, path, AgentType.PARALLEL)
+    return get_dependencies(name, agents, visited, path, AgentType.PARALLEL)

mcp_agent/executor/decorator_registry.py

@@ -11,17 +11,15 @@ 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]]
-        ] = {}
+        self._workflow_run_decorators: Dict[str, Callable[[Callable[..., R]], Callable[..., R]]] = {}
 
     def register_workflow_defn_decorator(
         self,
         executor_name: str,
         decorator: Callable[[Type], Type],
-    ):
+    ) -> None:
         """
         Registers a workflow definition decorator for a given executor.
 
@@ -48,7 +46,7 @@ class DecoratorRegistry:
         self,
         executor_name: str,
         decorator: Callable[[Callable[..., R]], Callable[..., R]],
-    ):
+    ) -> None:
         """
         Registers a workflow run decorator for a given executor.
 
@@ -62,9 +60,7 @@ class DecoratorRegistry:
             )
         self._workflow_run_decorators[executor_name] = decorator
 
-    def get_workflow_run_decorator(
-        self, executor_name: str
-    ) -> Callable[[Callable[..., R]], Callable[..., R]]:
+    def get_workflow_run_decorator(self, executor_name: str) -> Callable[[Callable[..., R]], Callable[..., R]]:
         """
         Retrieves a workflow run decorator for a given executor.
 
@@ -88,18 +84,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 +104,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
 
@@ -43,9 +43,7 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
 
     async def wait_for_signal(self, signal, timeout_seconds=None) -> SignalValueT:
         if not workflow._Runtime.current():
-            raise RuntimeError(
-                "TemporalSignalHandler.wait_for_signal must be called from within a workflow"
-            )
+            raise RuntimeError("TemporalSignalHandler.wait_for_signal must be called from within a workflow")
 
         unique_signal_name = f"{signal.name}_{uuid.uuid4()}"
         registration = SignalRegistration(
@@ -59,22 +57,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:
@@ -83,21 +77,13 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
             async with self._lock:
                 # Remove ourselves from _pending_signals
                 if signal.name in self._pending_signals:
-                    self._pending_signals[signal.name] = [
-                        sr
-                        for sr in self._pending_signals[signal.name]
-                        if sr.unique_name != unique_signal_name
-                    ]
+                    self._pending_signals[signal.name] = [sr for sr in self._pending_signals[signal.name] if sr.unique_name != unique_signal_name]
                     if not self._pending_signals[signal.name]:
                         del self._pending_signals[signal.name]
 
                 # 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
-                    ]
+                    self._handlers[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 +96,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 +109,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:
@@ -146,30 +128,22 @@ class TemporalSignalHandler(BaseSignalHandler[SignalValueT]):
                     registration = pending_signal.registration
                     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
-                            )
-                        )
+                        signal_tasks.append(workflow_handle.signal(registration.unique_name, signal.payload))
                     else:
                         continue
 
             # 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:
-            raise ValueError(
-                "No workflow_id provided on Signal. That is required for Temporal signals"
-            )
+            raise ValueError("No workflow_id provided on Signal. That is required for Temporal signals")
 
 
 class TemporalExecutorConfig(ExecutorConfig, TemporalSettings):
@@ -188,7 +162,7 @@ class TemporalExecutor(Executor):
         client: TemporalClient | None = None,
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         signal_bus = signal_bus or TemporalSignalHandler()
         super().__init__(
             engine="temporal",
@@ -197,17 +171,13 @@ class TemporalExecutor(Executor):
             context=context,
             **kwargs,
         )
-        self.config: TemporalExecutorConfig = (
-            config or self.context.config.temporal or TemporalExecutorConfig()
-        )
+        self.config: TemporalExecutorConfig = config or self.context.config.temporal or TemporalExecutorConfig()
         self.client = client
         self._worker = None
         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(
@@ -234,9 +204,7 @@ class TemporalExecutor(Executor):
 
         return wrapped_activity
 
-    async def _execute_task_as_async(
-        self, task: Callable[..., R] | Coroutine[Any, Any, R], **kwargs: Any
-    ) -> R | BaseException:
+    async def _execute_task_as_async(self, task: Callable[..., R] | Coroutine[Any, Any, R], **kwargs: Any) -> R | BaseException:
         async def run_task(task: Callable[..., R] | Coroutine[Any, Any, R]) -> R:
             try:
                 if asyncio.iscoroutine(task):
@@ -269,15 +237,11 @@ class TemporalExecutor(Executor):
         else:
             return await run_task(task)
 
-    async def _execute_task(
-        self, task: Callable[..., R] | Coroutine[Any, Any, R], **kwargs: Any
-    ) -> R | BaseException:
+    async def _execute_task(self, task: Callable[..., R] | Coroutine[Any, Any, R], **kwargs: Any) -> R | BaseException:
         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", {})
 
@@ -286,9 +250,7 @@ class TemporalExecutor(Executor):
         if not activity_name:
             activity_name = f"{func.__module__}.{func.__qualname__}"
 
-        schedule_to_close = execution_metadata.get(
-            "schedule_to_close_timeout", self.config.timeout_seconds
-        )
+        schedule_to_close = execution_metadata.get("schedule_to_close_timeout", self.config.timeout_seconds)
 
         retry_policy = execution_metadata.get("retry_policy", None)
 
@@ -319,9 +281,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():
@@ -336,9 +296,7 @@ class TemporalExecutor(Executor):
         **kwargs: Any,
     ) -> AsyncIterator[R | BaseException]:
         if not workflow._Runtime.current():
-            raise RuntimeError(
-                "TemporalExecutor.execute_streaming must be called from within a workflow"
-            )
+            raise RuntimeError("TemporalExecutor.execute_streaming 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 +305,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 +324,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
@@ -398,8 +354,6 @@ class TemporalExecutor(Executor):
                 activities=activities,
                 workflows=[],  # We'll auto-load by Python scanning or let the user specify
             )
-            print(
-                f"Starting Temporal Worker on task queue '{self.config.task_queue}' with {len(activities)} activities."
-            )
+            print(f"Starting Temporal Worker on task queue '{self.config.task_queue}' with {len(activities)} activities.")
 
         await self._worker.run()

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)
 
 
 # ############################