idun-agent-engine 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

idun_agent_engine/core/config_builder.py

@@ -7,6 +7,7 @@ This approach ensures type safety, validation, and consistency with the rest of
 from pathlib import Path
 from typing import Any
 
+from idun_agent_schema.engine.guardrails import Guardrails as GuardrailsV1
 import yaml
 from idun_agent_schema.engine.agent_framework import AgentFramework
 from idun_agent_schema.engine.haystack import HaystackAgentConfig
@@ -14,8 +15,12 @@ from idun_agent_schema.engine.langgraph import (
     LangGraphAgentConfig,
     SqliteCheckpointConfig,
 )
-
+from idun_agent_schema.engine.adk import AdkAgentConfig
+from idun_agent_schema.engine.mcp_server import MCPServer
+from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
+from idun_agent_schema.engine.guardrails_v2 import GuardrailsV2 as Guardrails
 from idun_agent_engine.server.server_config import ServerAPIConfig
+from yaml import YAMLError
 
 from ..agent.base import BaseAgent
 from .engine_config import AgentConfig, EngineConfig, ServerConfig
@@ -44,6 +49,10 @@ 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
 
     def with_api_port(self, port: int) -> "ConfigBuilder":
         """Set the API port for the server.
@@ -90,14 +99,59 @@ class ConfigBuilder:
 
         headers = {"auth": f"Bearer {agent_api_key}"}
         try:
-            response = requests.get(url=url, headers=headers)
+            print(f"Fetching config from {url + '/api/v1/agents/config'}")
+            response = requests.get(url=url + "/api/v1/agents/config", headers=headers)
             if response.status_code != 200:
                 raise ValueError(
                     f"Error sending retrieving config from url. response : {response.json()}"
                 )
             yaml_config = yaml.safe_load(response.text)
-            self._server_config = yaml_config["engine_config"]["server"]
-            self._agent_config = yaml_config["engine_config"]["agent"]
+            try:
+                self._server_config = yaml_config.get("engine_config", {}).get("server")
+            except Exception as e:
+                raise YAMLError(
+                    f"Failed to parse yaml file for  ServerConfig: {e}"
+                ) from e
+            try:
+                self._agent_config = yaml_config.get("engine_config", {}).get("agent")
+            except Exception as e:
+                raise YAMLError(
+                    f"Failed to parse yaml file for Engine config: {e}"
+                ) from e
+            try:
+                guardrails = yaml_config.get("engine_config", {}).get("guardrails", "")
+                if not guardrails:
+                    # self._guardrails = Guardrails(enabled=False)
+                    self._guardrails = None
+            except Exception as e:
+                raise YAMLError(f"Failed to parse yaml file for Guardrails: {e}") from e
+
+            try:
+                observability_list = yaml_config.get("engine_config", {}).get(
+                    "observability"
+                )
+                if observability_list:
+                    self._observability = [
+                        ObservabilityConfig.model_validate(obs)
+                        for obs in observability_list
+                    ]
+                else:
+                    self._observability = None
+            except Exception as e:
+                raise YAMLError(
+                    f"Failed to parse yaml file for Observability: {e}"
+                ) from e
+            # try:
+            #     mcp_servers_list = yaml_config.get("engine_config", {}).get("mcp_servers") or yaml_config.get("engine_config", {}).get("mcpServers") # TODO to fix camelcase issues
+            #     if mcp_servers_list:
+            #         self._mcp_servers = [
+            #             MCPServer.model_validate(server) for server in mcp_servers_list
+            #         ]
+            #     else:
+            #         self._mcp_servers = None
+            # except Exception as e:
+            #     raise YAMLError(f"Failed to parse yaml file for MCP Servers: {e}") from e
+
             return self
 
         except Exception as e:
@@ -139,9 +193,13 @@ class ConfigBuilder:
         langgraph_config = LangGraphAgentConfig.model_validate(agent_config_dict)
 
         # Create the agent config (store as strongly-typed model, not dict)
-        self._agent_config = AgentConfig(type=AgentFramework.LANGGRAPH, config=langgraph_config)
+        self._agent_config = AgentConfig(
+            type=AgentFramework.LANGGRAPH, config=langgraph_config
+        )
         return self
 
+    # TODO: remove unused fns
+
     def with_custom_agent(
         self, agent_type: str, config: dict[str, Any]
     ) -> "ConfigBuilder":
@@ -160,12 +218,14 @@ class ConfigBuilder:
         """
         if agent_type == AgentFramework.LANGGRAPH:
             self._agent_config = AgentConfig(
-                type=AgentFramework.LANGGRAPH, config=LangGraphAgentConfig.model_validate(config)
+                type=AgentFramework.LANGGRAPH,
+                config=LangGraphAgentConfig.model_validate(config),
             )
 
         elif agent_type == AgentFramework.HAYSTACK:
             self._agent_config = AgentConfig(
-                type=AgentFramework.HAYSTACK, config=HaystackAgentConfig.model_validate(config)
+                type=AgentFramework.HAYSTACK,
+                config=HaystackAgentConfig.model_validate(config),
             )
         else:
             raise ValueError(f"Unsupported agent type: {agent_type}")
@@ -186,7 +246,13 @@ class ConfigBuilder:
             )
 
         # Create and validate the complete configuration
-        return EngineConfig(server=self._server_config, agent=self._agent_config)
+        return EngineConfig(
+            server=self._server_config,
+            agent=self._agent_config,
+            guardrails=self._guardrails,
+            observability=self._observability,
+            mcp_servers=self._mcp_servers,
+        )
 
     def build_dict(self) -> dict[str, Any]:
         """Build and return the configuration as a dictionary.
@@ -209,7 +275,9 @@ class ConfigBuilder:
         with open(file_path, "w") as f:
             yaml.dump(config, f, default_flow_style=False, indent=2)
 
-    async def build_and_initialize_agent(self) -> BaseAgent:
+    async def build_and_initialize_agent(
+        self, mcp_registry: Any | None = None
+    ) -> BaseAgent:
         """Build configuration and initialize the agent in one step.
 
         Returns:
@@ -219,14 +287,19 @@ class ConfigBuilder:
             ValueError: If agent type is unsupported or configuration is invalid
         """
         engine_config = self.build()
-        return await self.initialize_agent_from_config(engine_config)
+        return await self.initialize_agent_from_config(
+            engine_config, mcp_registry=mcp_registry
+        )
 
     @staticmethod
-    async def initialize_agent_from_config(engine_config: EngineConfig) -> BaseAgent:
+    async def initialize_agent_from_config(
+        engine_config: EngineConfig, mcp_registry: Any | None = None
+    ) -> BaseAgent:
         """Initialize an agent instance from a validated EngineConfig.
 
         Args:
             engine_config: Validated configuration object
+            mcp_registry: Optional MCP registry client.
 
         Returns:
             BaseAgent: Initialized agent instance
@@ -235,14 +308,16 @@ class ConfigBuilder:
             ValueError: If agent type is unsupported
         """
         agent_config_obj = engine_config.agent.config
-        print("CONFIG:", agent_config_obj)
         agent_type = engine_config.agent.type
-
+        observability_config = engine_config.observability
+        # mcp_servers = engine_config.mcp_servers
         # Initialize the appropriate agent
         agent_instance = None
         if agent_type == AgentFramework.LANGGRAPH:
             from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
+            import os
 
+            print("Current directory: ", os.getcwd())  # TODO remove
             try:
                 validated_config = LangGraphAgentConfig.model_validate(agent_config_obj)
 
@@ -253,6 +328,91 @@ 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
+
+            try:
+                translation_config = TranslationAgentConfig.model_validate(
+                    agent_config_obj
+                )
+            except Exception as e:
+                raise ValueError(
+                    f"Cannot validate into a TranslationAgentConfig model. Got {agent_config_obj}"
+                ) from e
+
+            # Configure environment for the template
+            os.environ["TRANSLATION_MODEL"] = translation_config.model_name
+            os.environ["TRANSLATION_SOURCE_LANG"] = translation_config.source_lang
+            os.environ["TRANSLATION_TARGET_LANG"] = translation_config.target_lang
+
+            # Create LangGraph config for the template
+            validated_config = LangGraphAgentConfig(
+                name=translation_config.name,
+                graph_definition="idun_agent_engine.templates.translation:graph",
+                input_schema_definition=translation_config.input_schema_definition,
+                output_schema_definition=translation_config.output_schema_definition,
+                observability=translation_config.observability,
+                checkpointer=translation_config.checkpointer,
+            )
+            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
+
+            try:
+                correction_config = CorrectionAgentConfig.model_validate(
+                    agent_config_obj
+                )
+            except Exception as e:
+                raise ValueError(
+                    f"Cannot validate into a CorrectionAgentConfig model. Got {agent_config_obj}"
+                ) from e
+
+            os.environ["CORRECTION_MODEL"] = correction_config.model_name
+            os.environ["CORRECTION_LANGUAGE"] = correction_config.language
+
+            validated_config = LangGraphAgentConfig(
+                name=correction_config.name,
+                graph_definition="idun_agent_engine.templates.correction:graph",
+                input_schema_definition=correction_config.input_schema_definition,
+                output_schema_definition=correction_config.output_schema_definition,
+                observability=correction_config.observability,
+                checkpointer=correction_config.checkpointer,
+            )
+            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
+
+            try:
+                deep_research_config = DeepResearchAgentConfig.model_validate(
+                    agent_config_obj
+                )
+            except Exception as e:
+                raise ValueError(
+                    f"Cannot validate into a DeepResearchAgentConfig model. Got {agent_config_obj}"
+                ) from e
+
+            os.environ["DEEP_RESEARCH_MODEL"] = deep_research_config.model_name
+            os.environ["DEEP_RESEARCH_PROMPT"] = deep_research_config.system_prompt
+            os.environ["TAVILY_API_KEY"] = deep_research_config.tavily_api_key
+
+            validated_config = LangGraphAgentConfig(
+                name=deep_research_config.name,
+                graph_definition="idun_agent_engine.templates.deep_research:graph",
+                input_schema_definition=deep_research_config.input_schema_definition,
+                output_schema_definition=deep_research_config.output_schema_definition,
+                observability=deep_research_config.observability,
+                checkpointer=deep_research_config.checkpointer,
+            )
+            agent_instance = LanggraphAgent()
+
         elif agent_type == AgentFramework.HAYSTACK:
             from idun_agent_engine.agent.haystack.haystack import HaystackAgent
 
@@ -264,11 +424,24 @@ class ConfigBuilder:
                     f"Cannot validate into a HaystackAgentConfig model. Got {agent_config_obj}"
                 ) from e
             agent_instance = HaystackAgent()
+        elif agent_type == AgentFramework.ADK:
+            from idun_agent_engine.agent.adk.adk import AdkAgent
+
+            try:
+                validated_config = AdkAgentConfig.model_validate(agent_config_obj)
+            except Exception as e:
+                raise ValueError(
+                    f"Cannot validate into a AdkAgentConfig model. Got {agent_config_obj}"
+                ) from e
+            agent_instance = AdkAgent()
         else:
             raise ValueError(f"Unsupported agent type: {agent_type}")
 
         # Initialize the agent with its configuration
-        await agent_instance.initialize(validated_config)  # type: ignore[arg-type]
+        await agent_instance.initialize(
+            validated_config,
+            observability_config,  # , mcp_registry=mcp_registry
+        )  # type: ignore[arg-type]
         return agent_instance
 
     @staticmethod
@@ -284,7 +457,13 @@ class ConfigBuilder:
         Raises:
             ValueError: If agent type is unsupported
         """
-        if agent_type == "langgraph":
+        if (
+            agent_type == "langgraph"
+            or agent_type == AgentFramework.LANGGRAPH
+            or agent_type == AgentFramework.TRANSLATION_AGENT
+            or agent_type == AgentFramework.CORRECTION_AGENT
+            or agent_type == AgentFramework.DEEP_RESEARCH_AGENT
+        ):
             from ..agent.langgraph.langgraph import LanggraphAgent
 
             return LanggraphAgent
@@ -311,10 +490,21 @@ class ConfigBuilder:
         if agent_type == "langgraph":
             validated_config = LangGraphAgentConfig.model_validate(config)
             return validated_config.model_dump()
-        # Future agent types can be added here:
-        # elif agent_type == "crewai":
-        #     validated_config = CrewAIAgentConfig.model_validate(config)
-        #     return validated_config.model_dump()
+        elif agent_type == AgentFramework.TRANSLATION_AGENT:
+            from idun_agent_schema.engine.templates import TranslationAgentConfig
+
+            validated_config = TranslationAgentConfig.model_validate(config)
+            return validated_config.model_dump()
+        elif agent_type == AgentFramework.CORRECTION_AGENT:
+            from idun_agent_schema.engine.templates import CorrectionAgentConfig
+
+            validated_config = CorrectionAgentConfig.model_validate(config)
+            return validated_config.model_dump()
+        elif agent_type == AgentFramework.DEEP_RESEARCH_AGENT:
+            from idun_agent_schema.engine.templates import DeepResearchAgentConfig
+
+            validated_config = DeepResearchAgentConfig.model_validate(config)
+            return validated_config.model_dump()
         else:
             raise ValueError(f"Unsupported agent type: {agent_type}")
 
@@ -345,17 +535,21 @@ class ConfigBuilder:
     @staticmethod
     async def load_and_initialize_agent(
         config_path: str = "config.yaml",
+        mcp_registry: Any | None = None,
     ) -> tuple[EngineConfig, BaseAgent]:
         """Load configuration and initialize agent in one step.
 
         Args:
             config_path: Path to the configuration YAML file
+            mcp_registry: Optional MCP registry client.
 
         Returns:
             tuple[EngineConfig, BaseAgent]: Configuration and initialized agent
         """
         engine_config = ConfigBuilder.load_from_file(config_path)
-        agent = await ConfigBuilder.initialize_agent_from_config(engine_config)
+        agent = await ConfigBuilder.initialize_agent_from_config(
+            engine_config, mcp_registry=mcp_registry
+        )
         return engine_config, agent
 
     @staticmethod
@@ -364,6 +558,7 @@ class ConfigBuilder:
         config_dict: dict[str, Any] | None = None,
         engine_config: EngineConfig | None = None,
     ) -> EngineConfig:
+        print(config_dict)
         """Umbrella function to resolve configuration from various sources.
 
         This function handles all the different ways configuration can be provided
@@ -424,7 +619,9 @@ class ConfigBuilder:
         builder = cls()
         builder._server_config = engine_config.server
         builder._agent_config = engine_config.agent
-
+        builder._guardrails = engine_config.guardrails
+        builder._observability = engine_config.observability
+        builder._mcp_servers = engine_config.mcp_servers
         return builder
 
     @classmethod
@@ -453,4 +650,8 @@ class ConfigBuilder:
         builder = cls()
         builder._server_config = engine_config.server
         builder._agent_config = engine_config.agent
+        builder._guardrails = engine_config.guardrails
+        builder._observability = engine_config.observability
+        builder._mcp_servers = engine_config.mcp_servers
+
         return builder

idun_agent_engine/core/engine_config.py

@@ -1,10 +1,9 @@
 """Compatibility re-exports for Engine configuration models."""
 
-from idun_agent_schema.engine.agent import BaseAgentConfig  # noqa: F401
 from idun_agent_schema.engine.agent import (  # noqa: F401
     AgentConfig,
+    BaseAgentConfig,  # noqa: F401
 )
-
 from idun_agent_schema.engine.engine import (  # noqa: F401
     EngineConfig,
 )

idun_agent_engine/core/server_runner.py

@@ -41,7 +41,7 @@ def run_server(
         # Run in production mode
         run_server(app, workers=4)
     """
-    print(f"🌐 Starting Idun Agent Engine server on http://{host}:{port}")
+    print(f"🌐 Starting Idun Agent Engine server on http://{host}:{port}...")
     print(f"📚 API documentation available at http://{host}:{port}/docs")
 
     if reload and workers:
@@ -50,13 +50,12 @@ def run_server(
         )
         reload = False
 
+    print("Config: ", app.state.engine_config)
     uvicorn.run(
         app,
         host=host,
         port=port,
-        # reload=reload,
         log_level=log_level,
-        # workers=workers
     )
 
 

idun_agent_engine/guardrails/base.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from idun_agent_schema.engine.guardrails import Guardrail
+
+
+class BaseGuardrail(ABC):
+    """Base class for different guardrail providers."""
+
+    # TODO: output
+
+    def __init__(self, config: Guardrail) -> None:
+        if not isinstance(config, Guardrail):
+            raise TypeError(
+                f"The Guardrail must be a `Guardrail` schema type, received instead: {type(config)}"
+            )
+        self._guardrail_config = config
+        # config for the specific guardrails type. currently, can only be guardrails_hub config
+        self._instance_config: dict[str, Any] = None
+
+    @abstractmethod
+    def validate(self, input: str) -> bool:
+        """Used for validating user input, or LLM output."""
+        pass

idun_agent_engine/guardrails/guardrails_hub/guardrails_hub.py

@@ -0,0 +1,101 @@
+"""Guardrails."""
+
+from guardrails import Guard
+from idun_agent_schema.engine.guardrails import Guardrail as GuardrailSchema
+from idun_agent_schema.engine.guardrails_type import (
+    GuardrailType,
+)
+
+from ..base import BaseGuardrail
+
+
+def get_guard_instance(name: str) -> Guard:
+    """Returns a map of guard type -> guard instance."""
+    if name == "BAN_LIST":
+        from guardrails.hub import BanList
+
+        return BanList
+
+    elif name == "NSFW":
+        from guardrails.hub import NSFWText
+
+        return NSFWText
+
+    elif name == "COMPETITOR_CHECK":
+        from guardrails.hub import CompetitorCheck
+
+        return CompetitorCheck
+
+    else:
+        raise ValueError(f"Guard {name} not found.")
+
+
+class GuardrailsHubGuard(BaseGuardrail):
+    """Class for managing guardrails from `guardrailsai`'s hub."""
+
+    def __init__(self, config: GuardrailSchema, position: str) -> None:
+        super().__init__(config)
+
+        self._guard_type = self._guardrail_config.type
+        self._guard_config = self._guardrail_config.config
+
+        if self._guard_type == GuardrailType.GUARDRAILS_HUB:
+            self._guard_url = self._guardrail_config.config["guard_url"]
+
+        self.reject_message: str = self._guard_config["reject_message"]
+        self._install_model()
+        self._guard: Guard | None = self.setup_guard()
+        self.position: str = position
+
+    def _install_model(self) -> None:
+        import subprocess
+
+        from guardrails import install
+
+        try:
+            api_key = self._guardrail_config.config["api_key"]
+            subprocess.run(
+                [
+                    "guardrails",
+                    "configure",
+                    "--token",
+                    api_key,
+                    "--disable-remote-inferencing",  # TODO: maybe provide this as feat
+                    "--disable-metrics",
+                ],
+                check=True,
+            )
+            print(f"Installing model: {self._guard_url}..")
+            install(self._guard_url, quiet=True, install_local_models=True)
+        except Exception as e:
+            raise OSError(f"Cannot install model {self._guard_url}: {e}") from e
+
+    def setup_guard(self) -> Guard | None:
+        """Installs and configures the guard based on its yaml config."""
+        if self._guard_type == GuardrailType.GUARDRAILS_HUB:
+            self._install_model()
+            guard_name = self._guardrail_config.config.get("guard")
+            guard = get_guard_instance(guard_name)
+            if guard is None:
+                raise ValueError(
+                    f"Guard: {self.guard_type} is not yet supported, or does not exist."
+                )
+
+            guard_instance_params = self._guardrail_config.config.get(
+                "guard_config", {}
+            )
+            guard_instance = guard(**guard_instance_params)
+            for param, value in self._guardrail_config.config["guard_config"].items():
+                setattr(guard, param, value)
+            return guard_instance
+        elif self._guard_type == GuardrailType.CUSTOM_LLM:
+            raise NotImplementedError("Support for CUSTOM_LLM not yet provided.")
+
+    def validate(self, input: str) -> bool:
+        """TODO."""
+        main_guard = Guard().use(self._guard)
+        try:
+            main_guard.validate(input)
+            return True
+        except Exception:
+            return False

idun_agent_engine/guardrails/guardrails_hub/utils.py

@@ -0,0 +1 @@
+"""Utils module."""

idun_agent_engine/mcp/__init__.py

@@ -0,0 +1,5 @@
+"""MCP utilities for Idun Agent Engine."""
+
+from .registry import MCPClientRegistry
+from .helpers import get_adk_tools_from_api, get_adk_tools_from_file
+__all__ = ["MCPClientRegistry", "get_adk_tools_from_api", "get_adk_tools_from_file", "get_adk_tools"]

idun_agent_engine/mcp/helpers.py

@@ -0,0 +1,97 @@
+from pathlib import Path
+from typing import Any
+import yaml
+import requests
+import os
+from idun_agent_engine.mcp.registry import MCPClientRegistry
+from idun_agent_schema.engine.mcp_server import MCPServer
+
+def _get_toolsets_from_data(config_data: dict[str, Any]) -> list[Any]:
+    """Internal helper to extract toolsets from config dictionary."""
+    # Handle both snake_case and camelCase for mcp_servers
+    # Note: logic in ConfigBuilder suggests looking inside 'engine_config' if present,
+    # but this helper expects the dictionary containing 'mcp_servers' directly
+    # or performs the search itself.
+
+    mcp_configs_data = config_data.get("mcp_servers") or config_data.get("mcpServers")
+
+    if not mcp_configs_data:
+        return []
+
+    mcp_configs = [MCPServer.model_validate(c) for c in mcp_configs_data]
+    registry = MCPClientRegistry(mcp_configs)
+
+    try:
+        return registry.get_adk_toolsets()
+    except ImportError:
+        raise
+
+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.
+
+    Args:
+        config_path: Path to the configuration YAML file.
+
+    Returns:
+        List of initialized ADK McpToolset instances.
+    """
+    path = Path(config_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Configuration file not found at {path}")
+
+    with open(path) as f:
+        config_data = yaml.safe_load(f)
+
+    # Check if wrapped in engine_config (common pattern in idun)
+    if "engine_config" in config_data:
+        config_data = config_data["engine_config"]
+
+    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.
+
+    Args:
+        agent_api_key: The API key for authentication.
+        manager_url: The base URL of the Idun Manager (e.g. http://localhost:8000).
+
+    Returns:
+        List of initialized ADK McpToolset instances.
+    """
+    api_key = os.environ.get("IDUN_AGENT_API_KEY")
+    manager_host = os.environ.get("IDUN_MANAGER_HOST")
+    headers = {"auth": f"Bearer {api_key}"}
+    url = f"{manager_host.rstrip('/')}/api/v1/agents/config"
+
+    try:
+        response = requests.get(url=url, headers=headers)
+        response.raise_for_status()
+
+        config_data = yaml.safe_load(response.text)
+
+        # Config from API is typically wrapped in engine_config
+        if "engine_config" in config_data:
+            config_data = config_data["engine_config"]
+
+        return _get_toolsets_from_data(config_data)
+
+    except requests.RequestException as e:
+        raise ValueError(f"Failed to fetch config from API: {e}") from e
+    except yaml.YAMLError as e:
+        raise ValueError(f"Failed to parse config YAML: {e}") from e
+
+
+def get_adk_tools() -> list[Any]:
+    """
+    Fetches configuration from the Idun Manager API and returns a list of ADK toolsets.
+
+    Args:
+        agent_api_key: The API key for authentication.
+        manager_url: The base URL of the Idun Manager (e.g. http://localhost:8000).
+
+    Returns:
+        List of initialized ADK McpToolset instances.
+    """
+    return get_adk_tools_from_api()