fast-agent-mcp 0.0.7__py3-none-any.whl

mcp_agent/config.py

@@ -0,0 +1,334 @@
+"""
+Reading settings from environment variables and providing a settings object
+for the application configuration.
+"""
+
+from pathlib import Path
+from typing import Dict, List, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class MCPServerAuthSettings(BaseModel):
+    """Represents authentication configuration for a server."""
+
+    api_key: str | None = None
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
+class MCPRootSettings(BaseModel):
+    """Represents a root directory configuration for an MCP server."""
+
+    uri: str
+    """The URI identifying the root. Must start with file://"""
+
+    name: Optional[str] = None
+    """Optional name for the root."""
+
+    server_uri_alias: Optional[str] = None
+    """Optional URI alias for presentation to the server"""
+
+    @field_validator("uri", "server_uri_alias")
+    @classmethod
+    def validate_uri(cls, v: str) -> str:
+        """Validate that the URI starts with file:// (required by specification 2024-11-05)"""
+        if not v.startswith("file://"):
+            raise ValueError("Root URI must start with file://")
+        return v
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
+class MCPServerSettings(BaseModel):
+    """
+    Represents the configuration for an individual server.
+    """
+
+    # TODO: saqadri - server name should be something a server can provide itself during initialization
+    name: str | None = None
+    """The name of the server."""
+
+    # TODO: saqadri - server description should be something a server can provide itself during initialization
+    description: str | None = None
+    """The description of the server."""
+
+    transport: Literal["stdio", "sse"] = "stdio"
+    """The transport mechanism."""
+
+    command: str | None = None
+    """The command to execute the server (e.g. npx)."""
+
+    args: List[str] | None = None
+    """The arguments for the server command."""
+
+    read_timeout_seconds: int | None = None
+    """The timeout in seconds for the server connection."""
+
+    url: str | None = None
+    """The URL for the server (e.g. for SSE transport)."""
+
+    auth: MCPServerAuthSettings | None = None
+    """The authentication configuration for the server."""
+
+    roots: Optional[List[MCPRootSettings]] = None
+    """Root directories this server has access to."""
+
+    env: Dict[str, str] | None = None
+    """Environment variables to pass to the server process."""
+
+    env: Dict[str, str] | None = None
+    """Environment variables to pass to the server process."""
+
+
+class MCPSettings(BaseModel):
+    """Configuration for all MCP servers."""
+
+    servers: Dict[str, MCPServerSettings] = {}
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
+class AnthropicSettings(BaseModel):
+    """
+    Settings for using Anthropic models in the MCP Agent application.
+    """
+
+    api_key: str | None = None
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
+class CohereSettings(BaseModel):
+    """
+    Settings for using Cohere models in the MCP Agent application.
+    """
+
+    api_key: str | None = None
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
+class OpenAISettings(BaseModel):
+    """
+    Settings for using OpenAI models in the MCP Agent application.
+    """
+
+    api_key: str | None = None
+    reasoning_effort: Literal["low", "medium", "high"] = "medium"
+
+    base_url: str | None = None
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
+class TemporalSettings(BaseModel):
+    """
+    Temporal settings for the MCP Agent application.
+    """
+
+    host: str
+    namespace: str = "default"
+    task_queue: str
+    api_key: str | None = None
+
+
+class UsageTelemetrySettings(BaseModel):
+    """
+    Settings for usage telemetry in the MCP Agent application.
+    Anonymized usage metrics are sent to a telemetry server to help improve the product.
+    """
+
+    enabled: bool = True
+    """Enable usage telemetry in the MCP Agent application."""
+
+    enable_detailed_telemetry: bool = False
+    """If enabled, detailed telemetry data, including prompts and agents, will be sent to the telemetry server."""
+
+
+class OpenTelemetrySettings(BaseModel):
+    """
+    OTEL settings for the MCP Agent application.
+    """
+
+    enabled: bool = True
+
+    service_name: str = "mcp-agent"
+    service_instance_id: str | None = None
+    service_version: str | None = None
+
+    otlp_endpoint: str | None = None
+    """OTLP endpoint for OpenTelemetry tracing"""
+
+    console_debug: bool = False
+    """Log spans to console"""
+
+    sample_rate: float = 1.0
+    """Sample rate for tracing (1.0 = sample everything)"""
+
+
+class LoggerSettings(BaseModel):
+    """
+    Logger settings for the MCP Agent application.
+    """
+
+    type: Literal["none", "console", "file", "http"] = "file"
+
+    level: Literal["debug", "info", "warning", "error"] = "warning"
+    """Minimum logging level"""
+
+    progress_display: bool = True
+    """Enable or disable the progress display"""
+
+    path: str = "fastagent.jsonl"
+    """Path to log file, if logger 'type' is 'file'."""
+
+    batch_size: int = 100
+    """Number of events to accumulate before processing"""
+
+    flush_interval: float = 2.0
+    """How often to flush events in seconds"""
+
+    max_queue_size: int = 2048
+    """Maximum queue size for event processing"""
+
+    # HTTP transport settings
+    http_endpoint: str | None = None
+    """HTTP endpoint for event transport"""
+
+    http_headers: dict[str, str] | None = None
+    """HTTP headers for event transport"""
+
+    http_timeout: float = 5.0
+    """HTTP timeout seconds for event transport"""
+
+    show_chat: bool = True
+    """Show chat User/Assistant on the console"""
+    show_tools: bool = True
+    """Show MCP Sever tool calls on the console"""
+    truncate_tools: bool = True
+    """Truncate display of long tool calls"""
+
+
+class Settings(BaseSettings):
+    """
+    Settings class for the MCP Agent application.
+    """
+
+    model_config = SettingsConfigDict(
+        env_nested_delimiter="__",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="allow",
+        nested_model_default_partial_update=True,
+    )  # Customize the behavior of settings here
+
+    mcp: MCPSettings | None = MCPSettings()
+    """MCP config, such as MCP servers"""
+
+    execution_engine: Literal["asyncio", "temporal"] = "asyncio"
+    """Execution engine for the MCP Agent application"""
+
+    default_model: str | None = "haiku"
+    """
+    Default model for agents. Format is provider.model_name.<reasoning_effort>, for example openai.o3-mini.low
+    Aliases are provided for common models e.g. sonnet, haiku, gpt-4o, o3-mini etc.
+    """
+    temporal: TemporalSettings | None = None
+    """Settings for Temporal workflow orchestration"""
+
+    anthropic: AnthropicSettings | None = None
+    """Settings for using Anthropic models in the MCP Agent application"""
+
+    cohere: CohereSettings | None = None
+    """Settings for using Cohere models in the MCP Agent application"""
+
+    openai: OpenAISettings | None = None
+    """Settings for using OpenAI models in the MCP Agent application"""
+
+    otel: OpenTelemetrySettings | None = OpenTelemetrySettings()
+    """OpenTelemetry logging settings for the MCP Agent application"""
+
+    logger: LoggerSettings | None = LoggerSettings()
+    """Logger settings for the MCP Agent application"""
+
+    usage_telemetry: UsageTelemetrySettings | None = UsageTelemetrySettings()
+    """Usage tracking settings for the MCP Agent application"""
+
+    @classmethod
+    def find_config(cls) -> Path | None:
+        """Find the config file in the current directory or parent directories."""
+        current_dir = Path.cwd()
+
+        # Check current directory and parent directories
+        while current_dir != current_dir.parent:
+            for filename in [
+                "mcp-agent.config.yaml",
+                "mcp_agent.config.yaml",
+                "fastagent.config.yaml",
+            ]:
+                config_path = current_dir / filename
+                if config_path.exists():
+                    return config_path
+            current_dir = current_dir.parent
+
+        return None
+
+
+# Global settings object
+_settings: Settings | None = None
+
+
+def get_settings(config_path: str | None = None) -> Settings:
+    """Get settings instance, automatically loading from config file if available."""
+
+    def deep_merge(base: dict, update: dict) -> dict:
+        """Recursively merge two dictionaries, preserving nested structures."""
+        merged = base.copy()
+        for key, value in update.items():
+            if (
+                key in merged
+                and isinstance(merged[key], dict)
+                and isinstance(value, dict)
+            ):
+                merged[key] = deep_merge(merged[key], value)
+            else:
+                merged[key] = value
+        return merged
+
+    global _settings
+    if _settings:
+        return _settings
+
+    config_file = Path(config_path) if config_path else Settings.find_config()
+    merged_settings = {}
+
+    if config_file:
+        if not config_file.exists():
+            pass
+        else:
+            import yaml  # pylint: disable=C0415
+
+            # Load main config
+            with open(config_file, "r", encoding="utf-8") as f:
+                yaml_settings = yaml.safe_load(f) or {}
+                merged_settings = yaml_settings
+
+            # Look for secrets file in the same directory
+            for secrets_file in [
+                config_file.parent / "mcp-agent.secrets.yaml",
+                config_file.parent / "mcp_agent.secrets.yaml",
+                config_file.parent / "fastagent.secrets.yaml",
+            ]:
+                if secrets_file.exists():
+                    with open(secrets_file, "r", encoding="utf-8") as f:
+                        yaml_secrets = yaml.safe_load(f) or {}
+                        merged_settings = deep_merge(merged_settings, yaml_secrets)
+
+            _settings = Settings(**merged_settings)
+            return _settings
+    else:
+        pass
+
+    _settings = Settings()
+    return _settings

mcp_agent/console.py

@@ -0,0 +1,28 @@
+"""
+Centralized console configuration for MCP Agent.
+
+This module provides shared console instances for consistent output handling:
+- console: Main console for general output
+- error_console: Error console for application errors (writes to stderr)
+- server_console: Special console for MCP server output
+"""
+
+from rich.console import Console
+
+# Main console for general output
+console = Console(
+    color_system="auto",
+)
+
+# Error console for application errors
+error_console = Console(
+    stderr=True,
+    style="bold red",
+)
+
+# Special console for MCP server output
+# This could have custom styling to distinguish server messages
+server_console = Console(
+    # Not stderr since we want to maintain output ordering with other messages
+    style="dim blue",  # Or whatever style makes server output distinct
+)

mcp_agent/context.py

@@ -0,0 +1,251 @@
+"""
+A central context object to store global state that is shared across the application.
+"""
+
+import asyncio
+import concurrent.futures
+from typing import Any, Optional, Union, TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict
+
+from mcp import ServerSession
+
+from opentelemetry import trace
+from opentelemetry.propagate import set_global_textmap
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+
+from mcp_agent.config import get_settings
+from mcp_agent.config import Settings
+from mcp_agent.executor.executor import Executor
+from mcp_agent.executor.decorator_registry import (
+    DecoratorRegistry,
+    register_asyncio_decorators,
+    register_temporal_decorators,
+)
+from mcp_agent.executor.task_registry import ActivityRegistry
+from mcp_agent.executor.executor import AsyncioExecutor
+
+from mcp_agent.logging.events import EventFilter
+from mcp_agent.logging.logger import LoggingConfig
+from mcp_agent.logging.transport import create_transport
+from mcp_agent.mcp_server_registry import ServerRegistry
+from mcp_agent.workflows.llm.llm_selector import ModelSelector
+from mcp_agent.logging.logger import get_logger
+
+
+if TYPE_CHECKING:
+    from mcp_agent.human_input.types import HumanInputCallback
+    from mcp_agent.executor.workflow_signal import SignalWaitCallback
+else:
+    # Runtime placeholders for the types
+    HumanInputCallback = Any
+    SignalWaitCallback = Any
+
+logger = get_logger(__name__)
+
+
+class Context(BaseModel):
+    """
+    Context that is passed around through the application.
+    This is a global context that is shared across the application.
+    """
+
+    config: Optional[Settings] = None
+    executor: Optional[Executor] = None
+    human_input_handler: Optional[HumanInputCallback] = None
+    signal_notification: Optional[SignalWaitCallback] = None
+    upstream_session: Optional[ServerSession] = None  # TODO: saqadri - figure this out
+    model_selector: Optional[ModelSelector] = None
+
+    # Registries
+    server_registry: Optional[ServerRegistry] = None
+    task_registry: Optional[ActivityRegistry] = None
+    decorator_registry: Optional[DecoratorRegistry] = None
+
+    tracer: Optional[trace.Tracer] = None
+
+    model_config = ConfigDict(
+        extra="allow",
+        arbitrary_types_allowed=True,  # Tell Pydantic to defer type evaluation
+    )
+
+
+async def configure_otel(config: "Settings"):
+    """
+    Configure OpenTelemetry based on the application config.
+    """
+    if not config.otel.enabled:
+        return
+
+    # Check if a provider is already set to avoid re-initialization
+    if trace.get_tracer_provider().__class__.__name__ != "NoOpTracerProvider":
+        return
+
+    # Set up global textmap propagator first
+    set_global_textmap(TraceContextTextMapPropagator())
+
+    service_name = config.otel.service_name
+    service_instance_id = config.otel.service_instance_id
+    service_version = config.otel.service_version
+
+    # Create resource identifying this service
+    resource = Resource.create(
+        attributes={
+            key: value
+            for key, value in {
+                "service.name": service_name,
+                "service.instance.id": service_instance_id,
+                "service.version": service_version,
+            }.items()
+            if value is not None
+        }
+    )
+
+    # Create provider with resource
+    tracer_provider = TracerProvider(resource=resource)
+
+    # Add exporters based on config
+    otlp_endpoint = config.otel.otlp_endpoint
+    if otlp_endpoint:
+        exporter = OTLPSpanExporter(endpoint=otlp_endpoint)
+        tracer_provider.add_span_processor(BatchSpanProcessor(exporter))
+
+        if config.otel.console_debug:
+            tracer_provider.add_span_processor(
+                BatchSpanProcessor(ConsoleSpanExporter())
+            )
+    else:
+        # Default to console exporter in development
+        tracer_provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
+
+    # Set as global tracer provider
+    trace.set_tracer_provider(tracer_provider)
+
+
+async def configure_logger(config: "Settings"):
+    """
+    Configure logging and tracing based on the application config.
+    """
+    event_filter: EventFilter = EventFilter(min_level=config.logger.level)
+    logger.info(f"Configuring logger with level: {config.logger.level}")
+    transport = create_transport(settings=config.logger, event_filter=event_filter)
+    await LoggingConfig.configure(
+        event_filter=event_filter,
+        transport=transport,
+        batch_size=config.logger.batch_size,
+        flush_interval=config.logger.flush_interval,
+        progress_display=config.logger.progress_display,
+    )
+
+
+async def configure_usage_telemetry(_config: "Settings"):
+    """
+    Configure usage telemetry based on the application config.
+    TODO: saqadri - implement usage tracking
+    """
+    pass
+
+
+async def configure_executor(config: "Settings"):
+    """
+    Configure the executor based on the application config.
+    """
+    if config.execution_engine == "asyncio":
+        return AsyncioExecutor()
+    elif config.execution_engine == "temporal":
+        # Configure Temporal executor
+        from mcp_agent.executor.temporal import TemporalExecutor
+
+        executor = TemporalExecutor(config=config.temporal)
+        return executor
+    else:
+        # Default to asyncio executor
+        executor = AsyncioExecutor()
+        return executor
+
+
+async def initialize_context(
+    config: Optional[Union["Settings", str]] = None, store_globally: bool = False
+):
+    """
+    Initialize the global application context.
+    """
+    if config is None:
+        config = get_settings()
+    elif isinstance(config, str):
+        config = get_settings(config_path=config)
+
+    context = Context()
+    context.config = config
+    context.server_registry = ServerRegistry(config=config)
+
+    # Configure logging and telemetry
+    await configure_otel(config)
+    await configure_logger(config)
+    await configure_usage_telemetry(config)
+
+    # Configure the executor
+    context.executor = await configure_executor(config)
+    context.task_registry = ActivityRegistry()
+
+    context.decorator_registry = DecoratorRegistry()
+    register_asyncio_decorators(context.decorator_registry)
+    register_temporal_decorators(context.decorator_registry)
+
+    # Store the tracer in context if needed
+    context.tracer = trace.get_tracer(config.otel.service_name)
+
+    if store_globally:
+        global _global_context
+        _global_context = context
+
+    return context
+
+
+async def cleanup_context():
+    """
+    Cleanup the global application context.
+    """
+
+    # Shutdown logging and telemetry
+    await LoggingConfig.shutdown()
+
+
+_global_context: Context | None = None
+
+
+def get_current_context() -> Context:
+    """
+    Synchronous initializer/getter for global application context.
+    For async usage, use aget_current_context instead.
+    """
+    global _global_context
+    if _global_context is None:
+        try:
+            # Try to get the current event loop
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # Create a new loop in a separate thread
+                def run_async():
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    return new_loop.run_until_complete(initialize_context())
+
+                with concurrent.futures.ThreadPoolExecutor() as pool:
+                    _global_context = pool.submit(run_async).result()
+            else:
+                _global_context = loop.run_until_complete(initialize_context())
+        except RuntimeError:
+            _global_context = asyncio.run(initialize_context())
+    return _global_context
+
+
+def get_current_config():
+    """
+    Get the current application config.
+    """
+    return get_current_context().config or get_settings()

mcp_agent/context_dependent.py

@@ -0,0 +1,48 @@
+from contextlib import contextmanager
+from typing import Optional, TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from mcp_agent.context import Context
+
+
+class ContextDependent:
+    """
+    Mixin class for components that need context access.
+    Provides both global fallback and instance-specific context support.
+    """
+
+    def __init__(self, context: Optional["Context"] = None, **kwargs):
+        self._context = context
+        super().__init__(**kwargs)
+
+    @property
+    def context(self) -> "Context":
+        """
+        Get context, with graceful fallback to global context if needed.
+        Raises clear error if no context is available.
+        """
+        # First try instance context
+        if self._context is not None:
+            return self._context
+
+        try:
+            # Fall back to global context if available
+            from mcp_agent.context import get_current_context
+
+            return get_current_context()
+        except Exception as e:
+            raise RuntimeError(
+                f"No context available for {self.__class__.__name__}. "
+                "Either initialize MCPApp first or pass context explicitly."
+            ) from e
+
+    @contextmanager
+    def use_context(self, context: "Context"):
+        """Temporarily use a different context."""
+        old_context = self._context
+        self._context = context
+        try:
+            yield
+        finally:
+            self._context = old_context