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

mcp_agent/core/proxies.py

@@ -6,16 +6,18 @@ FOR COMPATIBILITY WITH LEGACY MCP-AGENT CODE
 
 """
 
-from typing import List, Optional, Dict, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+from mcp.types import EmbeddedResource
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.app import MCPApp
+from mcp_agent.core.request_params import RequestParams
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp.types import EmbeddedResource
 
 # Handle circular imports
 if TYPE_CHECKING:
-    from mcp_agent.core.types import WorkflowType, ProxyDict
+    from mcp_agent.core.types import ProxyDict, WorkflowType
 else:
     # Define minimal versions for runtime
     from typing import Any
@@ -28,7 +30,7 @@ else:
 class BaseAgentProxy:
     """Base class for all proxy types"""
 
-    def __init__(self, app: MCPApp, name: str):
+    def __init__(self, app: MCPApp, name: str) -> None:
         self._app = app
         self._name = name
 
@@ -39,9 +41,7 @@ class BaseAgentProxy:
             return await self.prompt()
         return await self.send(message)
 
-    async def send(
-        self, message: Optional[Union[str, PromptMessageMultipart]] = None
-    ) -> str:
+    async def send(self, message: Optional[Union[str, PromptMessageMultipart]] = None) -> str:
         """
         Allow: agent.researcher.send('message') or agent.researcher.send(Prompt.user('message'))
 
@@ -87,9 +87,7 @@ class BaseAgentProxy:
         """Send a message to the agent and return the response"""
         raise NotImplementedError("Subclasses must implement send(prompt)")
 
-    async def apply_prompt(
-        self, prompt_name: str = None, arguments: dict[str, str] = None
-    ) -> str:
+    async def apply_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
         """
         Apply a Prompt from an MCP Server - implemented by subclasses.
         This is the preferred method for applying prompts.
@@ -105,7 +103,7 @@ class BaseAgentProxy:
 class LLMAgentProxy(BaseAgentProxy):
     """Proxy for regular agents that use _llm.generate_str()"""
 
-    def __init__(self, app: MCPApp, name: str, agent: Agent):
+    def __init__(self, app: MCPApp, name: str, agent: Agent) -> None:
         super().__init__(app, name)
         self._agent = agent
 
@@ -117,9 +115,7 @@ class LLMAgentProxy(BaseAgentProxy):
         """Send a message to the agent and return the response"""
         return await self._agent._llm.generate_prompt(prompt, None)
 
-    async def apply_prompt(
-        self, prompt_name: str = None, arguments: dict[str, str] = None
-    ) -> str:
+    async def apply_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
         """
         Apply a prompt from an MCP server.
         This is the preferred method for applying prompts.
@@ -134,9 +130,7 @@ class LLMAgentProxy(BaseAgentProxy):
         return await self._agent.apply_prompt(prompt_name, arguments)
 
     # Add the new methods
-    async def get_embedded_resources(
-        self, server_name: str, resource_name: str
-    ) -> List[EmbeddedResource]:
+    async def get_embedded_resources(self, server_name: str, resource_name: str) -> List[EmbeddedResource]:
         """
         Get a resource from an MCP server and return it as a list of embedded resources ready for use in prompts.
 
@@ -166,15 +160,32 @@ class LLMAgentProxy(BaseAgentProxy):
         Returns:
             The agent's response as a string
         """
-        return await self._agent.with_resource(
-            prompt_content, server_name, resource_name
-        )
+        return await self._agent.with_resource(prompt_content, server_name, resource_name)
+
+    async def apply_prompt_messages(
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
+    ) -> str:
+        """
+        Apply a list of PromptMessageMultipart messages directly to the LLM.
+        This is a cleaner interface to _apply_prompt_template_provider_specific.
+
+        Args:
+            multipart_messages: List of PromptMessageMultipart objects
+            request_params: Optional parameters to configure the LLM request
+
+        Returns:
+            String representation of the assistant's response
+        """
+        # Delegate to the provider-specific implementation
+        return await self._agent._llm._apply_prompt_template_provider_specific(multipart_messages, request_params)
 
 
 class WorkflowProxy(BaseAgentProxy):
     """Proxy for workflow types that implement generate_str() directly"""
 
-    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType):
+    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType) -> None:
         super().__init__(app, name)
         self._workflow = workflow
 
@@ -186,7 +197,7 @@ class WorkflowProxy(BaseAgentProxy):
 class RouterProxy(BaseAgentProxy):
     """Proxy for LLM Routers"""
 
-    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType):
+    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType) -> None:
         super().__init__(app, name)
         self._workflow = workflow
 
@@ -215,9 +226,7 @@ class RouterProxy(BaseAgentProxy):
 class ChainProxy(BaseAgentProxy):
     """Proxy for chained agent operations"""
 
-    def __init__(
-        self, app: MCPApp, name: str, sequence: List[str], agent_proxies: ProxyDict
-    ):
+    def __init__(self, app: MCPApp, name: str, sequence: List[str], agent_proxies: ProxyDict) -> None:
         super().__init__(app, name)
         self._sequence = sequence
         self._agent_proxies = agent_proxies

mcp_agent/core/request_params.py

@@ -2,8 +2,11 @@
 Request parameters definitions for LLM interactions.
 """
 
-from pydantic import Field
+from typing import List
+
+from mcp import SamplingMessage
 from mcp.types import CreateMessageRequestParams
+from pydantic import Field
 
 
 class RequestParams(CreateMessageRequestParams):
@@ -11,7 +14,7 @@ class RequestParams(CreateMessageRequestParams):
     Parameters to configure the AugmentedLLM 'generate' requests.
     """
 
-    messages: None = Field(exclude=True, default=None)
+    messages: List[SamplingMessage] = Field(exclude=True, default=[])
     """
     Ignored. 'messages' are removed from CreateMessageRequestParams 
     to avoid confusion with the 'message' parameter on 'generate' method.
@@ -40,4 +43,4 @@ class RequestParams(CreateMessageRequestParams):
     """
     Whether to allow multiple tool calls per iteration.
     Also known as multi-step tool use.
-    """
+    """

mcp_agent/core/types.py

@@ -2,14 +2,14 @@
 Type definitions for fast-agent core module.
 """
 
-from typing import Dict, Union, TypeAlias, TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, TypeAlias, Union
 
 from mcp_agent.agents.agent import Agent
-from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
-from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
 from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
     EvaluatorOptimizerLLM,
 )
+from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
+from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
 from mcp_agent.workflows.router.router_llm import LLMRouter
 
 # Avoid circular imports
@@ -17,8 +17,6 @@ if TYPE_CHECKING:
     from mcp_agent.core.proxies import BaseAgentProxy
 
 # Type aliases for better readability
-WorkflowType: TypeAlias = Union[
-    Orchestrator, ParallelLLM, EvaluatorOptimizerLLM, LLMRouter
-]
+WorkflowType: TypeAlias = Union[Orchestrator, ParallelLLM, EvaluatorOptimizerLLM, LLMRouter]
 AgentOrWorkflow: TypeAlias = Union[Agent, WorkflowType]
 ProxyDict: TypeAlias = Dict[str, "BaseAgentProxy"]  # Forward reference as string

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.workflows.llm.augmented_llm import AugmentedLLM
 
 
 def validate_server_references(context, agents: Dict[str, Dict[str, Any]]) -> None:

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