idun-agent-engine 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

idun_agent_engine/_version.py

@@ -1,3 +1,3 @@
 """Version information for Idun Agent Engine."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

idun_agent_engine/agent/adk/adk.py

@@ -5,6 +5,7 @@ import uuid
 from collections.abc import AsyncGenerator
 from typing import Any
 
+from ag_ui_adk import ADKAgent as ADKAGUIAgent
 from google.adk.apps.app import App
 from google.adk.memory import (
     InMemoryMemoryService,
@@ -25,9 +26,8 @@ from idun_agent_schema.engine.adk import (
 )
 from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
 
-from ag_ui_adk import ADKAgent as ADKAGUIAgent
-from idun_agent_engine.agent import base as agent_base
 from idun_agent_engine import observability
+from idun_agent_engine.agent import base as agent_base
 
 
 class AdkAgent(agent_base.BaseAgent):
@@ -123,7 +123,7 @@ class AdkAgent(agent_base.BaseAgent):
         # Observability (provider-agnostic)
         if observability_config:
             handlers, infos = observability.create_observability_handlers(
-                observability_config # type: ignore[arg-type]
+                observability_config  # type: ignore[arg-type]
             )
             self._obs_callbacks = []
             for handler in handlers:
@@ -153,6 +153,7 @@ class AdkAgent(agent_base.BaseAgent):
 
                 if is_langfuse_enabled:
                     import os
+
                     langfuse_pk = os.environ.get("LANGFUSE_PUBLIC_KEY")
                     langfuse_host = os.environ.get("LANGFUSE_BASE_URL")
                     print(f"LANGFUSE_PUBLIC_KEY: {langfuse_pk}")
@@ -171,7 +172,9 @@ class AdkAgent(agent_base.BaseAgent):
                     except Exception as e:
                         print(f"Failed to instrument Google ADK: {e}")
             except Exception as e:
-                print(f"Error checking observability config for ADK instrumentation: {e}")
+                print(
+                    f"Error checking observability config for ADK instrumentation: {e}"
+                )
 
         # Initialize Session Service
         await self._initialize_session_service()

idun_agent_engine/agent/haystack/__init__.py

@@ -1,9 +1,7 @@
 """LangGraph agent package."""
 
 from .haystack import HaystackAgent
-from .haystack_model import HaystackAgentConfig
 
 __all__ = [
     "HaystackAgent",
-    "HaystackAgentConfig",
 ]

idun_agent_engine/agent/haystack/haystack.py

@@ -10,9 +10,10 @@ from haystack import Pipeline
 from haystack.components.agents import Agent
 from haystack.dataclasses import ChatMessage
 from haystack_integrations.components.connectors.langfuse import LangfuseConnector
+from idun_agent_schema.engine.haystack import HaystackAgentConfig
+from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
 
 from idun_agent_engine.agent.base import BaseAgent
-from idun_agent_schema.engine.haystack import HaystackAgentConfig
 from idun_agent_engine.agent.haystack.utils import _parse_component_definition
 
 logging.basicConfig(
@@ -77,7 +78,9 @@ class HaystackAgent(BaseAgent):
         Raises:
             RuntimeError: If the CopilotKit agent is not yet initialized.
         """
-        raise NotImplementedError("CopilotKit agent instance not supported yet for Haystack agent.")
+        raise NotImplementedError(
+            "CopilotKit agent instance not supported yet for Haystack agent."
+        )
 
     @property
     def configuration(self) -> HaystackAgentConfig:
@@ -146,9 +149,10 @@ class HaystackAgent(BaseAgent):
             # TODO: await persistence haystack
             # TODO OBS block
 
-            # check if config has observability `enabled` or `disabled`, so that we adjust our component to
-            # either add a tracer or not
-            if self._configuration.observability.enabled:
+            if (
+                self._configuration.observability
+                and self._configuration.observability.enabled
+            ):  # FIXED: should also check for enabled
                 self._enable_tracing = True
                 logger.info("Enabling tracing...")
             component: Agent | Pipeline = self._load_component(

idun_agent_engine/agent/langgraph/langgraph.py

@@ -1,7 +1,7 @@
 """LangGraph agent adapter implementing the BaseAgent protocol."""
 
-import importlib.util
 import importlib
+import importlib.util
 import uuid
 from collections.abc import AsyncGenerator
 from typing import Any
@@ -9,6 +9,7 @@ from typing import Any
 import aiosqlite
 from ag_ui.core import events as ag_events
 from ag_ui.core import types as ag_types
+from copilotkit import LangGraphAGUIAgent
 from idun_agent_schema.engine.langgraph import (
     InMemoryCheckpointConfig,
     LangGraphAgentConfig,
@@ -24,7 +25,6 @@ from langgraph.graph.state import CompiledStateGraph
 
 from idun_agent_engine import observability
 from idun_agent_engine.agent import base as agent_base
-from copilotkit import LangGraphAGUIAgent
 
 
 class LanggraphAgent(agent_base.BaseAgent):
@@ -202,8 +202,11 @@ class LanggraphAgent(agent_base.BaseAgent):
             self._agent_instance = graph_builder.compile(
                 checkpointer=self._checkpointer, store=self._store
             )
-        elif isinstance(graph_builder, CompiledStateGraph): # TODO: to remove, dirty fix for template deepagent langgraph
-            self._agent_instance = graph_builder
+        elif isinstance(graph_builder, CompiledStateGraph):
+            # TODO: this was made for supporting langgraph's DeepAgent, modernize.
+            raise TypeError(
+                "Expected StateGraph, Got CompiledStateGraph. Make sure not to run `compile` on your agent's graph."
+            )
 
         self._copilotkit_agent_instance = LangGraphAGUIAgent(
             name=self._name,
@@ -212,12 +215,6 @@ class LanggraphAgent(agent_base.BaseAgent):
             config={"callbacks": self._obs_callbacks} if self._obs_callbacks else None,
         )
 
-        self._copilotkit_agent_instance = LangGraphAGUIAgent(
-            name=self._name,
-            description="Agent description", # TODO: add agent description
-            graph=self._agent_instance,
-        )
-
         if self._agent_instance:
             try:
                 self._input_schema = self._agent_instance.input_schema
@@ -252,9 +249,10 @@ class LanggraphAgent(agent_base.BaseAgent):
 
         if self._configuration.checkpointer:
             if isinstance(self._configuration.checkpointer, SqliteCheckpointConfig):
-                self._connection = await aiosqlite.connect(
-                    self._configuration.checkpointer.db_path
+                db_path = self._configuration.checkpointer.db_url.replace(
+                    "sqlite:///", ""
                 )
+                self._connection = await aiosqlite.connect(db_path)
                 self._checkpointer = AsyncSqliteSaver(conn=self._connection)
                 self._infos["checkpointer"] = (
                     self._configuration.checkpointer.model_dump()
@@ -344,7 +342,6 @@ class LanggraphAgent(agent_base.BaseAgent):
     def _validate_graph_builder(
         self, graph_builder: Any, module_path: str, graph_variable_name: str
     ) -> StateGraph:
-        # TODO to remove, dirty fix for template deepagent langgraph
         if not isinstance(graph_builder, StateGraph) and not isinstance(
             graph_builder, CompiledStateGraph
         ):

idun_agent_engine/core/config_builder.py

@@ -4,6 +4,7 @@ This module provides a fluent API for building configuration objects using Pydan
 This approach ensures type safety, validation, and consistency with the rest of the codebase.
 """
 
+import os
 from pathlib import Path
 from typing import Any
 
@@ -50,7 +51,6 @@ class ConfigBuilder:
         """Initialize a new configuration builder with default values."""
         self._server_config = ServerConfig()
         self._agent_config: AgentConfig | None = None
-        # TODO: add mcp_servers config
         self._mcp_servers: list[MCPServer] | None = None
         self._observability: list[ObservabilityConfig] | None = None
         self._guardrails: Guardrails | None = None
@@ -259,7 +259,7 @@ class ConfigBuilder:
             mcp_servers=self._mcp_servers,
         )
 
-    def build_dict(self) -> dict[str, Any]:
+    def build_dict(self) -> dict[str, Any]:  # NOT USED
         """Build and return the configuration as a dictionary.
 
         This is a convenience method for backward compatibility.
@@ -268,17 +268,24 @@ class ConfigBuilder:
             Dict[str, Any]: The complete configuration dictionary
         """
         engine_config = self.build()
-        return engine_config.model_dump()
+        return engine_config.model_dump(mode="python")
 
-    def save_to_file(self, file_path: str) -> None:
+    def save_to_file(
+        self, file_path: str
+    ) -> None:  # FIXED: old method doesn't serialize enums correctly
         """Save the configuration to a YAML file.
 
         Args:
             file_path: Path where to save the configuration file
         """
-        config = self.build_dict()
+        engine_model = self.build()
         with open(file_path, "w") as f:
-            yaml.dump(config, f, default_flow_style=False, indent=2)
+            yaml.dump(
+                engine_model.model_dump(mode="json"),
+                f,
+                default_flow_style=False,
+                indent=2,
+            )
 
     async def build_and_initialize_agent(
         self, mcp_registry: Any | None = None
@@ -319,9 +326,10 @@ class ConfigBuilder:
         # Initialize the appropriate agent
         agent_instance = None
         if agent_type == AgentFramework.LANGGRAPH:
-            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
             import os
 
+            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
+
             print("Current directory: ", os.getcwd())  # TODO remove
             try:
                 validated_config = LangGraphAgentConfig.model_validate(agent_config_obj)
@@ -334,10 +342,12 @@ class ConfigBuilder:
             agent_instance = LanggraphAgent()
 
         elif agent_type == AgentFramework.TRANSLATION_AGENT:
-            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
-            from idun_agent_schema.engine.templates import TranslationAgentConfig
             import os
 
+            from idun_agent_schema.engine.templates import TranslationAgentConfig
+
+            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
+
             try:
                 translation_config = TranslationAgentConfig.model_validate(
                     agent_config_obj
@@ -364,10 +374,12 @@ class ConfigBuilder:
             agent_instance = LanggraphAgent()
 
         elif agent_type == AgentFramework.CORRECTION_AGENT:
-            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
-            from idun_agent_schema.engine.templates import CorrectionAgentConfig
             import os
 
+            from idun_agent_schema.engine.templates import CorrectionAgentConfig
+
+            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
+
             try:
                 correction_config = CorrectionAgentConfig.model_validate(
                     agent_config_obj
@@ -391,10 +403,12 @@ class ConfigBuilder:
             agent_instance = LanggraphAgent()
 
         elif agent_type == AgentFramework.DEEP_RESEARCH_AGENT:
-            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
-            from idun_agent_schema.engine.templates import DeepResearchAgentConfig
             import os
 
+            from idun_agent_schema.engine.templates import DeepResearchAgentConfig
+
+            from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
+
             try:
                 deep_research_config = DeepResearchAgentConfig.model_validate(
                     agent_config_obj
@@ -517,6 +531,9 @@ class ConfigBuilder:
     def load_from_file(config_path: str = "config.yaml") -> EngineConfig:
         """Load configuration from a YAML file and return a validated EngineConfig.
 
+        Sets IDUN_CONFIG_PATH environment variable to enable MCP helper functions
+        (get_adk_tools, get_langchain_tools) to automatically discover the config file.
+
         Args:
             config_path: Path to the configuration YAML file
 
@@ -532,6 +549,9 @@ class ConfigBuilder:
             # Resolve relative to the current working directory
             path = Path.cwd() / path
 
+        # Set IDUN_CONFIG_PATH for MCP helpers to discover
+        os.environ["IDUN_CONFIG_PATH"] = str(path)
+
         with open(path) as f:
             config_data = yaml.safe_load(f)
 

idun_agent_engine/guardrails/guardrails_hub/guardrails_hub.py

@@ -9,26 +9,51 @@ from ..base import BaseGuardrail
 
 def get_guard_instance(name: GuardrailConfigId) -> Guard:
     """Returns a map of guard type -> guard instance."""
-    if name.value == "ban_list":
+    if name == GuardrailConfigId.BAN_LIST:
         from guardrails.hub import BanList
 
         return BanList
 
-    elif name.value == "detect_pii":
+    elif name == GuardrailConfigId.DETECT_PII:
         from guardrails.hub import DetectPII
 
         return DetectPII
 
-    elif name.value == "nsfw":
+    elif name == GuardrailConfigId.NSFW_TEXT:
         from guardrails.hub import NSFWText
 
         return NSFWText
 
-    elif name.value == "competitor_check":
+    elif name == GuardrailConfigId.COMPETITION_CHECK:
         from guardrails.hub import CompetitorCheck
 
         return CompetitorCheck
 
+    elif name == GuardrailConfigId.BIAS_CHECK:
+        from guardrails.hub import BiasCheck
+
+        return BiasCheck
+
+    elif name == GuardrailConfigId.CORRECT_LANGUAGE:
+        from guardrails.hub import ValidLanguage
+
+        return ValidLanguage
+
+    elif name == GuardrailConfigId.GIBBERISH_TEXT:
+        from guardrails.hub import GibberishText
+
+        return GibberishText
+
+    elif name == GuardrailConfigId.TOXIC_LANGUAGE:
+        from guardrails.hub import ToxicLanguage
+
+        return ToxicLanguage
+
+    elif name == GuardrailConfigId.RESTRICT_TO_TOPIC:
+        from guardrails.hub import RestrictToTopic
+
+        return RestrictToTopic
+
     else:
         raise ValueError(f"Guard {name} not found.")
 
@@ -90,11 +115,29 @@ class GuardrailsHubGuard(BaseGuardrail):
                 f"Guard: {self.guard_id} is not yet supported, or does not exist."
             )
 
-        guard_instance_params = self._guardrail_config.guard_params.model_dump()
-        guard_instance = guard(**guard_instance_params)
-        for param, value in guard_instance_params.items():
-            setattr(guard_instance, param, value)
-        return guard_instance
+        if hasattr(self._guardrail_config, "guard_params"):
+            guard_instance_params = self._guardrail_config.guard_params.model_dump()
+        else:
+            config_dict = self._guardrail_config.model_dump()
+            exclude_fields = {"config_id", "api_key", "reject_message", "guard_url"}
+            guard_instance_params = {
+                k: v for k, v in config_dict.items() if k not in exclude_fields
+            }
+
+        try:
+            guard_instance = guard(**guard_instance_params)
+            for param, value in guard_instance_params.items():
+                setattr(guard_instance, param, value)
+            return guard_instance
+        except SystemError:
+            # sentencepiece mutex lock error when loading models in quick succession
+            import time
+
+            time.sleep(0.5)
+            guard_instance = guard(**guard_instance_params)
+            for param, value in guard_instance_params.items():
+                setattr(guard_instance, param, value)
+            return guard_instance
 
     def validate(self, input: str) -> bool:
         """TODO."""

idun_agent_engine/mcp/__init__.py

@@ -1,14 +1,14 @@
 """MCP utilities for Idun Agent Engine."""
 
-from .registry import MCPClientRegistry
 from .helpers import (
+    get_adk_tools,
     get_adk_tools_from_api,
     get_adk_tools_from_file,
-    get_adk_tools,
     get_langchain_tools,
     get_langchain_tools_from_api,
     get_langchain_tools_from_file,
 )
+from .registry import MCPClientRegistry
 
 __all__ = [
     "MCPClientRegistry",

idun_agent_engine/mcp/helpers.py

@@ -1,11 +1,14 @@
+import os
 from pathlib import Path
 from typing import Any
-import yaml
+
 import requests
-import os
-from idun_agent_engine.mcp.registry import MCPClientRegistry
+import yaml
 from idun_agent_schema.engine.mcp_server import MCPServer
 
+from idun_agent_engine.mcp.registry import MCPClientRegistry
+
+
 def _extract_mcp_configs(config_data: dict[str, Any]) -> list[MCPServer]:
     """Parse MCP server configs from a config dictionary."""
     mcp_configs_data = config_data.get("mcp_servers") or config_data.get("mcpServers")
@@ -86,9 +89,9 @@ def _fetch_config_from_api() -> dict[str, Any]:
     except yaml.YAMLError as e:
         raise ValueError(f"Failed to parse config YAML: {e}") from e
 
+
 def get_adk_tools_from_file(config_path: str | Path) -> list[Any]:
-    """
-    Loads MCP configurations from a YAML file and returns a list of ADK toolsets.
+    """Loads MCP configurations from a YAML file and returns a list of ADK toolsets.
 
     Args:
         config_path: Path to the configuration YAML file.
@@ -99,9 +102,9 @@ def get_adk_tools_from_file(config_path: str | Path) -> list[Any]:
     config_data = _load_config_from_file(config_path)
     return _get_toolsets_from_data(config_data)
 
+
 def get_adk_tools_from_api() -> list[Any]:
-    """
-    Fetches configuration from the Idun Manager API and returns a list of ADK toolsets.
+    """Fetches configuration from the Idun Manager API and returns a list of ADK toolsets.
 
     Returns:
         List of initialized ADK McpToolset instances.
@@ -111,37 +114,72 @@ def get_adk_tools_from_api() -> list[Any]:
 
 
 def get_adk_tools(config_path: str | Path | None = None) -> list[Any]:
-    """
-    Returns ADK toolsets using config from file when provided, otherwise from API.
+    """Returns ADK toolsets using config from file when provided, from IDUN_CONFIG_PATH env var, or from API.
+
+    The function resolves configuration in the following order:
+    1. Uses the provided config_path if specified
+    2. Uses IDUN_CONFIG_PATH environment variable if set
+    3. Falls back to fetching from Idun Manager API
+
+    Args:
+        config_path: Optional path to configuration YAML file. If provided, takes precedence.
 
     Returns:
         List of initialized ADK McpToolset instances.
+
+    Raises:
+        ValueError: If no config source is available or API credentials are missing.
+        FileNotFoundError: If specified config file doesn't exist.
     """
     if config_path:
         return get_adk_tools_from_file(config_path)
+
+    # Check for IDUN_CONFIG_PATH environment variable
+    env_config_path = os.environ.get("IDUN_CONFIG_PATH")
+    if env_config_path:
+        return get_adk_tools_from_file(env_config_path)
+
     return get_adk_tools_from_api()
 
 
 async def get_langchain_tools_from_file(config_path: str | Path) -> list[Any]:
-    """
-    Loads MCP configurations from a YAML file and returns LangChain tool instances.
+    """Loads MCP configurations from a YAML file and returns LangChain tool instances.
     """
     config_data = _load_config_from_file(config_path)
     return await _get_langchain_tools_from_data(config_data)
 
 
 async def get_langchain_tools_from_api() -> list[Any]:
-    """
-    Fetches configuration from the Idun Manager API and returns LangChain tool instances.
+    """Fetches configuration from the Idun Manager API and returns LangChain tool instances.
     """
     config_data = _fetch_config_from_api()
     return await _get_langchain_tools_from_data(config_data)
 
 
 async def get_langchain_tools(config_path: str | Path | None = None) -> list[Any]:
-    """
-    Returns LangChain tool instances using config from file when provided, otherwise from API.
+    """Returns LangChain tool instances using config from file when provided, from IDUN_CONFIG_PATH env var, or from API.
+
+    The function resolves configuration in the following order:
+    1. Uses the provided config_path if specified
+    2. Uses IDUN_CONFIG_PATH environment variable if set
+    3. Falls back to fetching from Idun Manager API
+
+    Args:
+        config_path: Optional path to configuration YAML file. If provided, takes precedence.
+
+    Returns:
+        List of initialized LangChain tool instances.
+
+    Raises:
+        ValueError: If no config source is available or API credentials are missing.
+        FileNotFoundError: If specified config file doesn't exist.
     """
     if config_path:
         return await get_langchain_tools_from_file(config_path)
+
+    # Check for IDUN_CONFIG_PATH environment variable
+    env_config_path = os.environ.get("IDUN_CONFIG_PATH")
+    if env_config_path:
+        return await get_langchain_tools_from_file(env_config_path)
+
     return await get_langchain_tools_from_api()

idun_agent_engine/mcp/registry.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, cast
 
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_mcp_adapters.sessions import Connection
@@ -80,15 +80,15 @@ class MCPClientRegistry:
         return await self._client.get_tools(server_name=name)
 
     async def get_langchain_tools(self, name: str | None = None) -> list[Any]:
-        """
-        Alias for get_tools to make intent explicit when using LangChain/LangGraph agents.
-        """
+        """Alias for get_tools to make intent explicit when using LangChain/LangGraph agents."""
         return await self.get_tools(name=name)
 
     def get_adk_toolsets(self) -> list[Any]:
         """Return a list of Google ADK McpToolset instances for configured servers."""
         if McpToolset is None or StdioServerParameters is None:
-            raise ImportError("google-adk and mcp packages are required for ADK toolsets.")
+            raise ImportError(
+                "google-adk and mcp packages are required for ADK toolsets."
+            )
 
         toolsets = []
         for config in self._configs:

idun_agent_engine/observability/base.py

@@ -9,9 +9,13 @@ import os
 from abc import ABC, abstractmethod
 from typing import Any
 
-from idun_agent_schema.engine.observability import ObservabilityConfig as ObservabilityConfigV1
+from idun_agent_schema.engine.observability import (
+    ObservabilityConfig as ObservabilityConfigV1,
+)
 from idun_agent_schema.engine.observability_v2 import (
     ObservabilityConfig as ObservabilityConfigV2,
+)
+from idun_agent_schema.engine.observability_v2 import (
     ObservabilityProvider,
 )
 
@@ -49,7 +53,11 @@ def _normalize_config(
         if not config.enabled:
             return {"enabled": False}
 
-        provider = config.provider.value if hasattr(config.provider, "value") else config.provider
+        provider = (
+            config.provider.value
+            if hasattr(config.provider, "value")
+            else config.provider
+        )
         options = config.config.model_dump()
         return {
             "provider": provider,
@@ -152,6 +160,7 @@ def create_observability_handler(
         "error": "Unsupported provider",
     }
 
+
 def create_observability_handlers(
     configs: list[ObservabilityConfigV2 | ObservabilityConfigV1] | None,
 ) -> tuple[list[ObservabilityHandlerBase], list[dict[str, Any]]]:

idun_agent_engine/observability/gcp_trace/gcp_trace_handler.py

@@ -108,7 +108,9 @@ class GCPTraceHandler(ObservabilityHandlerBase):
         except ImportError:
             pass
 
-        logger.info("GCP Trace initialized for project: %s", project_id or "auto-detected")
+        logger.info(
+            "GCP Trace initialized for project: %s", project_id or "auto-detected"
+        )
 
     def get_callbacks(self) -> list[Any]:
         """Return callbacks."""

idun_agent_engine/observability/langfuse/langfuse_handler.py

@@ -59,9 +59,7 @@ class LangfuseHandler(ObservabilityHandlerBase):
             # Initialize callback handler
             # We pass the resolved credentials explicitly to ensure they are used
             # even if env vars were not successfully set or read.
-            self._callbacks = [
-                CallbackHandler()
-            ]
+            self._callbacks = [CallbackHandler()]
         except Exception as e:
             print(f"Failed to initialize Langfuse callback/client: {e}")
             self._callbacks = []

idun_agent_engine/server/dependencies.py

@@ -23,6 +23,7 @@ async def get_agent(request: Request):
         agent = await ConfigBuilder.initialize_agent_from_config(app_config)
         return agent
 
+
 async def get_copilotkit_agent(request: Request):
     """Return the pre-initialized agent instance from the app state.
 
@@ -34,7 +35,9 @@ async def get_copilotkit_agent(request: Request):
         # This is a fallback for cases where the lifespan event did not run,
         # like in some testing scenarios.
         # Consider logging a warning here.
-        print("⚠️  CopilotKit agent not found in app state, initializing fallback agent...")
+        print(
+            "⚠️  CopilotKit agent not found in app state, initializing fallback agent..."
+        )
 
         app_config = ConfigBuilder.load_from_file()
         copilotkit_agent = await ConfigBuilder.initialize_agent_from_config(app_config)
@@ -43,7 +46,9 @@ async def get_copilotkit_agent(request: Request):
 
 def get_mcp_registry(request: Request) -> MCPClientRegistry:
     """Return the configured MCP registry if available."""
-    registry: MCPClientRegistry | None = getattr(request.app.state, "mcp_registry", None)
+    registry: MCPClientRegistry | None = getattr(
+        request.app.state, "mcp_registry", None
+    )
     if registry is None or not registry.enabled:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,