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

mcp_agent/{workflows/llm → llm}/providers/sampling_converter_openai.py

@@ -1,29 +1,25 @@
-from typing import Dict, Any
-
-from openai.types.chat import (
-    ChatCompletionMessage,
-)
+from typing import Any, Dict
 
 from mcp.types import (
     PromptMessage,
 )
-
-from mcp_agent.workflows.llm.sampling_format_converter import (
-    SamplingFormatConverter,
+from openai.types.chat import (
+    ChatCompletionMessage,
 )
 
+from mcp_agent.llm.sampling_format_converter import (
+    ProviderFormatConverter,
+)
 from mcp_agent.logging.logger import get_logger
 
 _logger = get_logger(__name__)
 
 
-class OpenAISamplingConverter(
-    SamplingFormatConverter[Dict[str, Any], ChatCompletionMessage]
-):
+class OpenAISamplingConverter(ProviderFormatConverter[Dict[str, Any], ChatCompletionMessage]):
     @classmethod
     def from_prompt_message(cls, message: PromptMessage) -> Dict[str, Any]:
         """Convert an MCP PromptMessage to an OpenAI message dict."""
-        from mcp_agent.workflows.llm.providers.multipart_converter_openai import (
+        from mcp_agent.llm.providers.multipart_converter_openai import (
             OpenAIConverter,
         )
 

mcp_agent/{workflows/llm → llm}/sampling_converter.py

@@ -9,12 +9,11 @@ from mcp.types import (
     CreateMessageRequestParams,
     CreateMessageResult,
     SamplingMessage,
-    StopReason,
     TextContent,
 )
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.interfaces import RequestParams
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
 class SamplingConverter:
@@ -63,31 +62,7 @@ class SamplingConverter:
         )
 
     @staticmethod
-    def create_message_result(
-        response: str, model: str, stop_reason: StopReason = "endTurn"
-    ) -> CreateMessageResult:
-        """
-        Create a CreateMessageResult from an LLM response.
-
-        Args:
-            response: Text response from the LLM
-            model: Model identifier
-            stop_reason: Reason generation stopped
-
-        Returns:
-            CreateMessageResult suitable for returning to MCP
-        """
-        return CreateMessageResult(
-            role="assistant",
-            content=TextContent(type="text", text=response),
-            model=model,
-            stopReason=stop_reason,
-        )
-
-    @staticmethod
-    def error_result(
-        error_message: str, model: Optional[str] = None
-    ) -> CreateMessageResult:
+    def error_result(error_message: str, model: Optional[str] = None) -> CreateMessageResult:
         """
         Create an error result.
 
@@ -118,7 +93,4 @@ class SamplingConverter:
         Returns:
             List of PromptMessageMultipart objects, each with a single content item
         """
-        return [
-            SamplingConverter.sampling_message_to_prompt_message(msg)
-            for msg in messages
-        ]
+        return [SamplingConverter.sampling_message_to_prompt_message(msg) for msg in messages]

mcp_agent/llm/sampling_format_converter.py

@@ -0,0 +1,37 @@
+from typing import Generic, List, Protocol, TypeVar
+
+from mcp.types import PromptMessage
+
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+# Define covariant type variables
+MessageParamT_co = TypeVar("MessageParamT_co", covariant=True)
+MessageT_co = TypeVar("MessageT_co", covariant=True)
+
+
+class ProviderFormatConverter(Protocol, Generic[MessageParamT_co, MessageT_co]):
+    """Conversions between LLM provider and MCP types"""
+
+    @classmethod
+    def from_prompt_message(cls, message: PromptMessage) -> MessageParamT_co:
+        """Convert an MCP PromptMessage to a provider-specific message parameter."""
+        ...
+
+    @classmethod
+    def from_mutlipart_prompts(
+        cls, messages: List[PromptMessageMultipart]
+    ) -> List[MessageParamT_co]:
+        """Convert a list of PromptMessageMultiparts to a list of provider-specific implementations"""
+        ...
+
+
+class BasicFormatConverter(ProviderFormatConverter[PromptMessage, PromptMessage]):
+    @classmethod
+    def from_prompt_message(cls, message: PromptMessage) -> PromptMessage:
+        return message
+
+    @classmethod
+    def from_multipart_prompts(
+        cls, messages: List[PromptMessageMultipart]
+    ) -> List[PromptMessageMultipart]:
+        return messages

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)
@@ -194,7 +192,7 @@ class LoggingConfig:
         batch_size: int = 100,
         flush_interval: float = 2.0,
         **kwargs: Any,
-    ):
+    ) -> None:
         """
         Configure the logging system.
 
@@ -232,7 +230,7 @@ class LoggingConfig:
         cls._initialized = True
 
     @classmethod
-    async def shutdown(cls):
+    async def shutdown(cls) -> None:
         """Shutdown the logging system gracefully."""
         if not cls._initialized:
             return

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