idun-agent-engine 0.3.5__tar.gz → 0.3.6__tar.gz

{idun_agent_engine-0.3.5 → idun_agent_engine-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idun-agent-engine
-Version: 0.3.5
+Version: 0.3.6
 Summary: Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability.
 Project-URL: Homepage, https://github.com/geoffreyharrazi/idun-agent-platform
 Project-URL: Repository, https://github.com/geoffreyharrazi/idun-agent-platform

{idun_agent_engine-0.3.5 → idun_agent_engine-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "idun-agent-engine"
-version = "0.3.5"
+version = "0.3.6"
 description = "Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability."
 authors = [{ name = "Geoffrey HARRAZI", email = "geoffreyharrazi@gmail.com" }]
 requires-python = ">=3.12,<3.14"

{idun_agent_engine-0.3.5 → idun_agent_engine-0.3.6}/src/idun_agent_engine/_version.py

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

{idun_agent_engine-0.3.5 → idun_agent_engine-0.3.6}/src/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
 
@@ -24,6 +25,7 @@ from yaml import YAMLError
 
 from ..agent.base import BaseAgent
 from .engine_config import AgentConfig, EngineConfig, ServerConfig
+from idun_agent_schema.manager.guardrail_configs import convert_guardrail
 
 
 class ConfigBuilder:
@@ -119,10 +121,14 @@ class ConfigBuilder:
                     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)
+                guardrails_data = yaml_config.get("engine_config", {}).get("guardrails")
+
+                if not guardrails_data:
                     self._guardrails = None
+                else:
+                    converted_data = convert_guardrail(guardrails_data)
+                    self._guardrails = Guardrails.model_validate(converted_data)
+
             except Exception as e:
                 raise YAMLError(f"Failed to parse yaml file for Guardrails: {e}") from e
 

{idun_agent_engine-0.3.5 → idun_agent_engine-0.3.6}/src/idun_agent_engine/guardrails/base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Any
 
-from idun_agent_schema.engine.guardrails import Guardrail
+from idun_agent_schema.engine.guardrails_v2 import GuardrailConfig as Guardrail
 
 
 class BaseGuardrail(ABC):

idun_agent_engine-0.3.6/src/idun_agent_engine/guardrails/guardrails_hub/guardrails_hub.py

@@ -0,0 +1,106 @@
+"""Guardrails."""
+
+from guardrails import Guard
+from idun_agent_schema.engine.guardrails import Guardrail as GuardrailSchema
+from idun_agent_schema.engine.guardrails_v2 import GuardrailConfigId
+
+from ..base import BaseGuardrail
+
+
+def get_guard_instance(name: GuardrailConfigId) -> Guard:
+    """Returns a map of guard type -> guard instance."""
+    if name.value == "ban_list":
+        from guardrails.hub import BanList
+
+        return BanList
+
+    elif name.value == "detect_pii":
+        from guardrails.hub import DetectPII
+
+        return DetectPII
+
+    elif name.value == "nsfw":
+        from guardrails.hub import NSFWText
+
+        return NSFWText
+
+    elif name.value == "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_id = self._guardrail_config.config_id
+        self._guard_url = self._guardrail_config.guard_url
+        self.reject_message: str = self._guardrail_config.reject_message
+        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.api_key
+
+            print("Configuring guardrails with token...")
+            result = subprocess.run(
+                [
+                    "guardrails",
+                    "configure",
+                    "--token",
+                    api_key,
+                    "--disable-remote-inferencing",
+                    "--disable-metrics",
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            print(f"Configure output: {result.stdout}")
+            if result.stderr:
+                print(f"Configure stderr: {result.stderr}")
+            print(f"Installing model: {self._guard_url}..")
+            install(self._guard_url, quiet=False, install_local_models=True)
+            print(f"Successfully installed: {self._guard_url}")
+        except subprocess.CalledProcessError as e:
+            raise OSError(
+                f"Cannot configure guardrails: stdout={e.stdout}, stderr={e.stderr}"
+            ) from e
+        except Exception as e:
+            raise e
+
+    def setup_guard(self) -> Guard | None:
+        """Installs and configures the guard based on its yaml config."""
+        self._install_model()
+        guard_name = self.guard_id
+        guard = get_guard_instance(guard_name)
+        if guard is None:
+            raise ValueError(
+                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
+
+    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-0.3.5 → idun_agent_engine-0.3.6}/src/idun_agent_engine/server/lifespan.py

@@ -22,7 +22,7 @@ def _parse_guardrails(guardrails_obj: Guardrails) -> Sequence[BaseGuardrail]:
 
     from ..guardrails.guardrails_hub.guardrails_hub import GuardrailsHubGuard as GHGuard
 
-    if not guardrails_obj.enabled:
+    if not guardrails_obj:
         return []
 
     return [GHGuard(guard, position="input") for guard in guardrails_obj.input] + [

{idun_agent_engine-0.3.5 → idun_agent_engine-0.3.6}/src/idun_agent_engine/server/routers/agent.py

@@ -95,6 +95,7 @@ async def stream(
 ):
     """Process a message with the agent, streaming ag-ui events."""
     try:
+
         async def event_stream():
             message = {"query": request.query, "session_id": request.session_id}
             async for event in agent.stream(message):
@@ -114,6 +115,11 @@ async def copilotkit_stream(
     ],
 ):
     """Process a message with the agent, streaming ag-ui events."""
+    guardrails = getattr(request.app.state, "guardrails", [])
+    if guardrails:
+        _run_guardrails(
+            guardrails, message=input_data.messages[-1].content, position="input"
+        )
     if isinstance(copilotkit_agent, LangGraphAGUIAgent):
         try:
             # Get the accept header from the request

idun_agent_engine-0.3.5/src/idun_agent_engine/guardrails/guardrails_hub/guardrails_hub.py

@@ -1,101 +0,0 @@
-"""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