idun-agent-engine 0.4.1__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.1"
+__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):

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

@@ -51,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
@@ -260,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.
@@ -269,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
@@ -320,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)
@@ -335,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
@@ -365,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
@@ -392,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

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,13 @@
+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."""
@@ -89,8 +91,7 @@ def _fetch_config_from_api() -> dict[str, Any]:
 
 
 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.
@@ -103,8 +104,7 @@ def get_adk_tools_from_file(config_path: str | Path) -> list[Any]:
 
 
 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.
@@ -114,8 +114,7 @@ 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, from IDUN_CONFIG_PATH env var, or 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
@@ -144,24 +143,21 @@ def get_adk_tools(config_path: str | Path | None = None) -> list[Any]:
 
 
 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, from IDUN_CONFIG_PATH env var, or 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

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,

idun_agent_engine/server/lifespan.py

@@ -8,19 +8,15 @@ from collections.abc import Sequence
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
+from idun_agent_schema.engine.guardrails import Guardrails
 
 from ..core.config_builder import ConfigBuilder
-from ..mcp import MCPClientRegistry
-
-from idun_agent_schema.engine.guardrails import Guardrails, Guardrail
-
 from ..guardrails.base import BaseGuardrail
 from ..telemetry import get_telemetry, sanitize_telemetry_config
 
 
 def _parse_guardrails(guardrails_obj: Guardrails) -> Sequence[BaseGuardrail]:
     """Adds the position of the guardrails (input/output) and returns the lift of updated guardrails."""
-
     from ..guardrails.guardrails_hub.guardrails_hub import GuardrailsHubGuard as GHGuard
 
     if not guardrails_obj:
@@ -70,8 +66,8 @@ async def configure_app(app: FastAPI, engine_config):
     print(f"✅ Agent '{agent_name}' initialized and ready to serve!")
 
     # Setup AGUI routes if the agent is a LangGraph agent
-    from ..agent.langgraph.langgraph import LanggraphAgent
     from ..agent.adk.adk import AdkAgent
+    from ..agent.langgraph.langgraph import LanggraphAgent
     # from ..server.routers.agui import setup_agui_router
 
     if isinstance(agent_instance, (LanggraphAgent, AdkAgent)):
@@ -91,7 +87,6 @@ async def configure_app(app: FastAPI, engine_config):
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """FastAPI lifespan context to initialize and teardown the agent."""
-
     # Load config and initialize agent on startup
     print("Server starting up...")
     if not app.state.engine_config:

idun_agent_engine/server/routers/agent.py

@@ -84,6 +84,8 @@ async def invoke(
             )
         return ChatResponse(session_id=message["session_id"], response=response_content)
 
+    except HTTPException:
+        raise
     except Exception as e:  # noqa: BLE001
         raise HTTPException(status_code=500, detail=str(e)) from e
 
@@ -142,7 +144,6 @@ async def copilotkit_stream(
         try:
             # Get the accept header from the request
             accept_header = request.headers.get("accept")
-            agent_id = request.url.path.lstrip("/")
 
             # Create an event encoder to properly format SSE events
             encoder = EventEncoder(accept=accept_header or "")

idun_agent_engine/server/routers/base.py

@@ -1,8 +1,8 @@
 """Base routes for service health and landing info."""
 
 import os
-from typing import Optional
-from fastapi import APIRouter, Request, HTTPException
+
+from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
 from ..._version import __version__
@@ -15,7 +15,7 @@ base_router = APIRouter()
 class ReloadRequest(BaseModel):
     """Request body for reload endpoint."""
 
-    path: Optional[str] = None
+    path: str | None = None
 
 
 @base_router.get("/health")
@@ -25,9 +25,8 @@ def health_check():
 
 
 @base_router.post("/reload")
-async def reload_config(request: Request, body: Optional[ReloadRequest] = None):
+async def reload_config(request: Request, body: ReloadRequest | None = None):
     """Reload the agent configuration from the manager or a file."""
-
     try:
         if body and body.path:
             print(f"🔄 Reloading configuration from file: {body.path}...")
@@ -60,6 +59,9 @@ async def reload_config(request: Request, body: Optional[ReloadRequest] = None):
             "message": "Agent configuration reloaded successfully",
         }
 
+    except HTTPException:
+        raise
+
     except Exception as e:
         print(f"❌ Error reloading configuration: {e}")
         raise HTTPException(

idun_agent_engine/telemetry/__init__.py

@@ -9,7 +9,6 @@ _telemetry_singleton: IdunTelemetry | None = None
 
 def get_telemetry() -> IdunTelemetry:
     """Return the process-wide telemetry singleton."""
-
     global _telemetry_singleton
     if _telemetry_singleton is None:
         _telemetry_singleton = IdunTelemetry()

idun_agent_engine/telemetry/config.py

@@ -13,7 +13,6 @@ def telemetry_enabled(environ: dict[str, str] | None = None) -> bool:
     Telemetry is ON by default. Users can disable it by setting the environment
     variable `IDUN_TELEMETRY_ENABLED` to a falsy value (e.g. "false", "0", "no").
     """
-
     env = os.environ if environ is None else environ
     raw = env.get(IDUN_TELEMETRY_ENABLED_ENV)
     if raw is None: