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

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]] = {}
 
@@ -147,9 +147,7 @@ class ConsoleSignalHandler(SignalHandler[str]):
         loop = asyncio.get_event_loop()
         if timeout_seconds is not None:
             try:
-                value = await asyncio.wait_for(
-                    loop.run_in_executor(None, input, "Enter value: "), timeout_seconds
-                )
+                value = await asyncio.wait_for(loop.run_in_executor(None, input, "Enter value: "), timeout_seconds)
             except asyncio.TimeoutError:
                 print("\nTimeout waiting for input")
                 raise
@@ -163,7 +161,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 +172,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 +190,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())
 
@@ -226,17 +220,13 @@ class AsyncioSignalHandler(BaseSignalHandler[SignalValueT]):
             async with self._lock:
                 # Remove from pending signals
                 if signal.name in self._pending_signals:
-                    self._pending_signals[signal.name] = [
-                        ps
-                        for ps in self._pending_signals[signal.name]
-                        if ps.registration.unique_name != unique_name
-                    ]
+                    self._pending_signals[signal.name] = [ps for ps in self._pending_signals[signal.name] if ps.registration.unique_name != unique_name]
                     if not self._pending_signals[signal.name]:
                         del self._pending_signals[signal.name]
 
     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 +237,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 +262,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 +274,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()
 

mcp_agent/human_input/handler.py

@@ -1,13 +1,14 @@
 import asyncio
+
 from rich.panel import Panel
 
 from mcp_agent.console import console
+from mcp_agent.core.enhanced_prompt import get_enhanced_input, handle_special_commands
 from mcp_agent.human_input.types import (
     HumanInputRequest,
     HumanInputResponse,
 )
 from mcp_agent.progress_display import progress_display
-from mcp_agent.core.enhanced_prompt import get_enhanced_input, handle_special_commands
 
 
 async def console_input_callback(request: HumanInputRequest) -> HumanInputResponse:
@@ -29,11 +30,7 @@ async def console_input_callback(request: HumanInputRequest) -> HumanInputRespon
     )
 
     # Extract agent name from metadata dictionary
-    agent_name = (
-        request.metadata.get("agent_name", "Unknown Agent")
-        if request.metadata
-        else "Unknown Agent"
-    )
+    agent_name = request.metadata.get("agent_name", "Unknown Agent") if request.metadata else "Unknown Agent"
 
     # Use the context manager to pause the progress display while getting input
     with progress_display.paused():
@@ -70,9 +67,7 @@ async def console_input_callback(request: HumanInputRequest) -> HumanInputRespon
             if isinstance(command_result, dict) and "list_prompts" in command_result:
                 from rich import print as rich_print
 
-                rich_print(
-                    "[yellow]Prompt listing not available in human input context[/yellow]"
-                )
+                rich_print("[yellow]Prompt listing not available in human input context[/yellow]")
 
         except KeyboardInterrupt:
             console.print("\n[yellow]Input interrupted[/yellow]")

mcp_agent/human_input/types.py

@@ -1,4 +1,5 @@
 from typing import Any, AsyncIterator, Protocol
+
 from pydantic import BaseModel
 
 HUMAN_INPUT_SIGNAL_NAME = "__human_input__"
@@ -42,9 +43,7 @@ class HumanInputResponse(BaseModel):
 class HumanInputCallback(Protocol):
     """Protocol for callbacks that handle human input requests."""
 
-    async def __call__(
-        self, request: HumanInputRequest
-    ) -> AsyncIterator[HumanInputResponse]:
+    async def __call__(self, request: HumanInputRequest) -> AsyncIterator[HumanInputResponse]:
         """
         Handle a human input request.
 

mcp_agent/logging/events.py

@@ -4,7 +4,6 @@ Events and event filters for the logger module for the MCP Agent
 
 import logging
 import random
-
 from datetime import datetime
 from typing import (
     Any,
@@ -15,7 +14,6 @@ from typing import (
 
 from pydantic import BaseModel, ConfigDict, Field
 
-
 EventType = Literal["debug", "info", "warning", "error", "progress"]
 """Broad categories for events (severity or role)."""
 
@@ -86,9 +84,7 @@ class EventFilter(BaseModel):
                 return False
 
         # 3) Filter by namespace prefix
-        if self.namespaces and not any(
-            event.namespace.startswith(ns) for ns in self.namespaces
-        ):
+        if self.namespaces and not any(event.namespace.startswith(ns) for ns in self.namespaces):
             return False
 
         # 4) Minimum severity

mcp_agent/logging/json_serializer.py

@@ -1,13 +1,14 @@
+import dataclasses
+import inspect
 import os
 import warnings
-from typing import Any, Dict, Iterable, Set
-from datetime import datetime, date
+from datetime import date, datetime
 from decimal import Decimal
+from enum import Enum
 from pathlib import Path
+from typing import Any, Dict, Iterable, Set
 from uuid import UUID
-from enum import Enum
-import dataclasses
-import inspect
+
 import httpx
 
 from mcp_agent.logging import logger
@@ -34,7 +35,7 @@ class JSONSerializer:
         "refresh_token",
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Set of already processed objects to prevent infinite recursion
         self._processed_objects: Set[int] = set()
         # Check if secrets should be logged in full

mcp_agent/logging/listeners.py

@@ -5,12 +5,11 @@ Listeners for the logger module of MCP Agent.
 import asyncio
 import logging
 import time
-
 from abc import ABC, abstractmethod
 from typing import Dict, List
 
-from mcp_agent.logging.events import Event, EventFilter, EventType
 from mcp_agent.event_progress import convert_log_event
+from mcp_agent.logging.events import Event, EventFilter, EventType
 
 
 class EventListener(ABC):
@@ -27,11 +26,11 @@ class LifecycleAwareListener(EventListener):
     The event bus calls these at bus start/stop time.
     """
 
-    async def start(self):
+    async def start(self) -> None:
         """Start an event listener, usually when the event bus is set up."""
         pass
 
-    async def stop(self):
+    async def stop(self) -> None:
         """Stop an event listener, usually when the event bus is shutting down."""
         pass
 
@@ -42,7 +41,7 @@ class FilteredListener(LifecycleAwareListener):
     Subclasses override _handle_matched_event().
     """
 
-    def __init__(self, event_filter: EventFilter | None = None):
+    def __init__(self, event_filter: EventFilter | None = None) -> None:
         """
         Initialize the listener.
         Args:
@@ -50,11 +49,11 @@ class FilteredListener(LifecycleAwareListener):
         """
         self.filter = event_filter
 
-    async def handle_event(self, event):
+    async def handle_event(self, event) -> None:
         if not self.filter or self.filter.matches(event):
             await self.handle_matched_event(event)
 
-    async def handle_matched_event(self, event: Event):
+    async def handle_matched_event(self, event: Event) -> None:
         """Process an event that matches the filter."""
         pass
 
@@ -68,7 +67,7 @@ class LoggingListener(FilteredListener):
         self,
         event_filter: EventFilter | None = None,
         logger: logging.Logger | None = None,
-    ):
+    ) -> None:
         """
         Initialize the listener.
         Args:
@@ -77,7 +76,7 @@ class LoggingListener(FilteredListener):
         super().__init__(event_filter=event_filter)
         self.logger = logger or logging.getLogger("mcp_agent")
 
-    async def handle_matched_event(self, event):
+    async def handle_matched_event(self, event) -> None:
         level_map: Dict[EventType, int] = {
             "debug": logging.DEBUG,
             "info": logging.INFO,
@@ -113,7 +112,7 @@ class ProgressListener(LifecycleAwareListener):
     FilteredListener, we get events before any filtering occurs.
     """
 
-    def __init__(self, display=None):
+    def __init__(self, display=None) -> None:
         """Initialize the progress listener.
         Args:
             display: Optional display handler. If None, the shared progress_display will be used.
@@ -122,15 +121,15 @@ class ProgressListener(LifecycleAwareListener):
 
         self.display = display or progress_display
 
-    async def start(self):
+    async def start(self) -> None:
         """Start the progress display."""
         self.display.start()
 
-    async def stop(self):
+    async def stop(self) -> None:
         """Stop the progress display."""
         self.display.stop()
 
-    async def handle_event(self, event: Event):
+    async def handle_event(self, event: Event) -> None:
         """Process an incoming event and display progress if relevant."""
 
         if event.data:
@@ -150,7 +149,7 @@ class BatchingListener(FilteredListener):
         event_filter: EventFilter | None = None,
         batch_size: int = 5,
         flush_interval: float = 2.0,
-    ):
+    ) -> None:
         """
         Initialize the listener.
         Args:
@@ -165,12 +164,12 @@ class BatchingListener(FilteredListener):
         self._flush_task: asyncio.Task | None = None  # Task for periodic flush loop
         self._stop_event = None  # Event to signal flush task to stop
 
-    async def start(self, loop=None):
+    async def start(self, loop=None) -> None:
         """Spawn a periodic flush loop."""
         self._stop_event = asyncio.Event()
         self._flush_task = asyncio.create_task(self._periodic_flush())
 
-    async def stop(self):
+    async def stop(self) -> None:
         """Stop flush loop and flush any remaining events."""
         if self._stop_event:
             self._stop_event.set()
@@ -181,13 +180,11 @@ class BatchingListener(FilteredListener):
             self._flush_task = None
         await self.flush()
 
-    async def _periodic_flush(self):
+    async def _periodic_flush(self) -> None:
         try:
             while not self._stop_event.is_set():
                 try:
-                    await asyncio.wait_for(
-                        self._stop_event.wait(), timeout=self.flush_interval
-                    )
+                    await asyncio.wait_for(self._stop_event.wait(), timeout=self.flush_interval)
                 except asyncio.TimeoutError:
                     await self.flush()
         # except asyncio.CancelledError:
@@ -195,12 +192,12 @@ class BatchingListener(FilteredListener):
         finally:
             await self.flush()  # Final flush
 
-    async def handle_matched_event(self, event):
+    async def handle_matched_event(self, event) -> None:
         self.batch.append(event)
         if len(self.batch) >= self.batch_size:
             await self.flush()
 
-    async def flush(self):
+    async def flush(self) -> None:
         """Flush the current batch of events."""
         if not self.batch:
             return
@@ -209,5 +206,5 @@ class BatchingListener(FilteredListener):
         self.last_flush = time.time()
         await self._process_batch(to_process)
 
-    async def _process_batch(self, events: List[Event]):
+    async def _process_batch(self, events: List[Event]) -> None:
         pass

mcp_agent/logging/logger.py

@@ -10,10 +10,8 @@ Logger module for the MCP Agent, which provides:
 import asyncio
 import threading
 import time
-
-from typing import Any, Dict
-
 from contextlib import asynccontextmanager, contextmanager
+from typing import Any, Dict
 
 from mcp_agent.logging.events import Event, EventContext, EventFilter, EventType
 from mcp_agent.logging.listeners import (
@@ -31,7 +29,7 @@ class Logger:
     - `name` can be a custom domain-specific event name, e.g. "ORDER_PLACED".
     """
 
-    def __init__(self, namespace: str):
+    def __init__(self, namespace: str) -> None:
         self.namespace = namespace
         self.event_bus = AsyncEventBus.get()
 
@@ -45,7 +43,7 @@ class Logger:
             asyncio.set_event_loop(loop)
             return loop
 
-    def _emit_event(self, event: Event):
+    def _emit_event(self, event: Event) -> None:
         """Emit an event by running it in the event loop."""
         loop = self._ensure_event_loop()
         if loop.is_running():
@@ -62,7 +60,7 @@ class Logger:
         message: str,
         context: EventContext | None,
         data: dict,
-    ):
+    ) -> None:
         """Create and emit an event."""
         evt = Event(
             type=etype,
@@ -78,9 +76,9 @@ class Logger:
         self,
         message: str,
         name: str | None = None,
-        context: EventContext = None,
+        context: EventContext | None = None,
         **data,
-    ):
+    ) -> None:
         """Log a debug message."""
         self.event("debug", name, message, context, data)
 
@@ -88,9 +86,9 @@ class Logger:
         self,
         message: str,
         name: str | None = None,
-        context: EventContext = None,
+        context: EventContext | None = None,
         **data,
-    ):
+    ) -> None:
         """Log an info message."""
         self.event("info", name, message, context, data)
 
@@ -98,9 +96,9 @@ class Logger:
         self,
         message: str,
         name: str | None = None,
-        context: EventContext = None,
+        context: EventContext | None = None,
         **data,
-    ):
+    ) -> None:
         """Log a warning message."""
         self.event("warning", name, message, context, data)
 
@@ -108,9 +106,9 @@ class Logger:
         self,
         message: str,
         name: str | None = None,
-        context: EventContext = None,
+        context: EventContext | None = None,
         **data,
-    ):
+    ) -> None:
         """Log an error message."""
         self.event("error", name, message, context, data)
 
@@ -118,10 +116,10 @@ class Logger:
         self,
         message: str,
         name: str | None = None,
-        percentage: float = None,
-        context: EventContext = None,
+        percentage: float | None = None,
+        context: EventContext | None = None,
         **data,
-    ):
+    ) -> None:
         """Log a progress message."""
         merged_data = dict(percentage=percentage, **data)
         self.event("progress", name, message, context, merged_data)

mcp_agent/logging/rich_progress.py

@@ -1,18 +1,20 @@
 """Rich-based progress display for MCP Agent."""
 
 import time
+from contextlib import contextmanager
 from typing import Optional
+
 from rich.console import Console
-from mcp_agent.console import console as default_console
-from mcp_agent.event_progress import ProgressEvent, ProgressAction
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from contextlib import contextmanager
+
+from mcp_agent.console import console as default_console
+from mcp_agent.event_progress import ProgressAction, ProgressEvent
 
 
 class RichProgressDisplay:
     """Rich-based display for progress events."""
 
-    def __init__(self, console: Optional[Console] = None):
+    def __init__(self, console: Optional[Console] = None) -> None:
         """Initialize the progress display."""
         self.console = console or default_console
         self._taskmap = {}
@@ -29,16 +31,16 @@ class RichProgressDisplay:
         )
         self._paused = False
 
-    def start(self):
+    def start(self) -> None:
         """start"""
 
         self._progress.start()
 
-    def stop(self):
+    def stop(self) -> None:
         """stop"""
         self._progress.stop()
 
-    def pause(self):
+    def pause(self) -> None:
         """Pause the progress display."""
         if not self._paused:
             self._paused = True
@@ -47,7 +49,7 @@ class RichProgressDisplay:
                 task.visible = False
             self._progress.stop()
 
-    def resume(self):
+    def resume(self) -> None:
         """Resume the progress display."""
         if self._paused:
             for task in self._progress.tasks:

mcp_agent/logging/tracing.py

@@ -5,16 +5,14 @@ for the Logger module for MCP Agent
 
 import asyncio
 import functools
-from typing import Any, Dict, Callable, Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
 
 from opentelemetry import trace
 from opentelemetry.context import Context as OtelContext
 from opentelemetry.propagate import extract as otel_extract
-from opentelemetry.trace import set_span_in_context
+from opentelemetry.trace import SpanKind, Status, StatusCode, set_span_in_context
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 
-from opentelemetry.trace import SpanKind, Status, StatusCode
-
 from mcp_agent.context_dependent import ContextDependent
 
 if TYPE_CHECKING:
@@ -27,7 +25,7 @@ class TelemetryManager(ContextDependent):
     Decorator usage: @telemetry.traced("SomeSpanName")
     """
 
-    def __init__(self, context: Optional["Context"] = None, **kwargs):
+    def __init__(self, context: Optional["Context"] = None, **kwargs) -> None:
         # If needed, configure resources, exporters, etc.
         # E.g.: from opentelemetry.sdk.trace import TracerProvider
         # trace.set_tracer_provider(TracerProvider(...))
@@ -88,7 +86,7 @@ class TelemetryManager(ContextDependent):
 
         return decorator
 
-    def _record_args(self, span, args, kwargs):
+    def _record_args(self, span, args, kwargs) -> None:
         """Optionally record primitive args as span attributes."""
         for i, arg in enumerate(args):
             if isinstance(arg, (str, int, float, bool)):