idun-agent-engine 0.3.9__py3-none-any.whl → 0.4.1__py3-none-any.whl

idun_platform_cli/tui/utils/config.py

@@ -0,0 +1,182 @@
+from pathlib import Path
+from typing import Any
+
+import yaml
+from idun_agent_schema.engine.guardrails_v2 import GuardrailsV2
+from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
+from pydantic import ValidationError
+
+from idun_platform_cli.tui.schemas.create_agent import (
+    TUIAgentConfig,
+)
+
+
+class ConfigManager:
+    def __init__(self):
+        self.idun_dir = Path.home() / ".idun"
+        self.agent_path = None
+        try:
+            self.idun_dir.mkdir(exist_ok=True)
+
+        except OSError as e:
+            raise ValueError(
+                f"Error while preparing `.idun` config file: {e}\nNote: This file is used to store config and env data"
+            ) from e
+
+    def _sanitize_agent_name(self, agent_name: str) -> str:
+        return agent_name.lstrip().replace("-", "_").replace(" ", "_")
+
+    def _validate_data(
+        self, config: dict[str, Any]
+    ) -> tuple[TUIAgentConfig | None, str]:
+        try:
+            return TUIAgentConfig.model_validate(config), "valid"
+        except Exception as e:
+            return None, f"Error: cannot validate config: {e}"
+
+    def save_config(self, config: dict) -> tuple[bool, str]:
+        try:
+            raw_agent_name: str = config["name"]
+        except KeyError as e:
+            raise ValueError(
+                "Agent name is not defined! Make sure you specify a name for your agent!"
+            ) from e
+        sanitized_agent_name = self._sanitize_agent_name(raw_agent_name)
+        self.agent_path = (self.idun_dir / sanitized_agent_name).with_suffix(".yaml")
+
+        with self.agent_path.open("w") as f:
+            serialized, msg = self._validate_data(config)
+            if serialized is None:
+                return False, msg
+            with self.agent_path.open("w") as f:
+                yaml.dump(serialized.to_engine_config(), f, default_flow_style=False)
+            return True, "Valid"
+
+    def load_draft(self) -> dict | None:
+        if self.agent_path is None or not self.agent_path.exists():
+            raise ValueError(
+                "No agent config file found. Make sure you have saved agent configs."
+            )
+        with self.agent_path.open("r") as f:
+            return yaml.safe_load(f) or {}
+
+    def save_partial(
+        self, section: str, data: dict | Any, agent_name: str = None
+    ) -> tuple[bool, str]:
+        try:
+            from idun_agent_engine.core.engine_config import EngineConfig
+
+            if agent_name:
+                sanitized_agent_name = self._sanitize_agent_name(agent_name)
+                self.agent_path = (self.idun_dir / sanitized_agent_name).with_suffix(
+                    ".yaml"
+                )
+
+            if self.agent_path is None:
+                return False, "Agent name not set. Save identity section first."
+
+            existing_config = {}
+            if self.agent_path.exists():
+                with self.agent_path.open("r") as f:
+                    existing_config = yaml.safe_load(f) or {}
+
+            if section == "identity":
+                from idun_platform_cli.tui.schemas.create_agent import TUIAgentConfig
+
+                tui_config = TUIAgentConfig.model_validate(data)
+                engine_config_dict = tui_config.to_engine_config()
+                existing_config["server"] = engine_config_dict["server"]
+                existing_config["agent"] = engine_config_dict["agent"]
+            elif section == "observability":
+                if isinstance(data, ObservabilityConfig):
+                    obs_dict = {
+                        "provider": data.provider.value,
+                        "enabled": data.enabled,
+                        "config": data.config.model_dump(by_alias=False),
+                    }
+                    existing_config["observability"] = [obs_dict]
+                else:
+                    existing_config["observability"] = [data]
+            elif section == "guardrails":
+                if isinstance(data, GuardrailsV2):
+                    guardrails_dict = {
+                        "input": [
+                            g.model_dump(by_alias=False, mode="json")
+                            for g in data.input
+                        ],
+                        "output": [
+                            g.model_dump(by_alias=False, mode="json")
+                            for g in data.output
+                        ],
+                    }
+                    existing_config["guardrails"] = guardrails_dict
+                else:
+                    existing_config["guardrails"] = data
+            elif section == "mcp_servers":
+                if isinstance(data, list):
+                    mcp_servers_list = []
+                    for server in data:
+                        if hasattr(server, "model_dump"):
+                            mcp_servers_list.append(
+                                server.model_dump(
+                                    by_alias=True, mode="json", exclude_none=True
+                                )
+                            )
+                        else:
+                            mcp_servers_list.append(server)
+                    existing_config["mcp_servers"] = mcp_servers_list
+                else:
+                    existing_config["mcp_servers"] = data
+            elif section == "memory":
+                from idun_agent_schema.engine.langgraph import CheckpointConfig
+
+                if "agent" not in existing_config:
+                    return False, "Agent configuration not found. Save identity first."
+
+                agent_type = existing_config.get("agent", {}).get("type")
+                if agent_type != "LANGGRAPH":
+                    return (
+                        True,
+                        "Checkpoint configuration skipped for non-LANGGRAPH agents",
+                    )
+
+                if isinstance(data, CheckpointConfig):
+                    checkpoint_dict = data.model_dump(by_alias=False, mode="json")
+
+                    if "config" not in existing_config["agent"]:
+                        existing_config["agent"]["config"] = {}
+
+                    existing_config["agent"]["config"]["checkpointer"] = checkpoint_dict
+                else:
+                    return False, "Invalid checkpoint configuration type"
+            else:
+                existing_config[section] = data
+
+            EngineConfig.model_validate(existing_config)
+
+            with self.agent_path.open("w") as f:
+                yaml.dump(existing_config, f, default_flow_style=False)
+
+            return True, "Saved successfully"
+
+        except ValidationError as e:
+            return False, f"Validation error: {e}"
+        except Exception as e:
+            return False, f"Error saving config: {e}"
+
+    def load_config(self, agent_name: str = None) -> dict:
+        try:
+            if agent_name:
+                sanitized_agent_name = self._sanitize_agent_name(agent_name)
+                self.agent_path = (self.idun_dir / sanitized_agent_name).with_suffix(
+                    ".yaml"
+                )
+
+            if self.agent_path is None or not self.agent_path.exists():
+                return {}
+
+            with self.agent_path.open("r") as f:
+                return yaml.safe_load(f) or {}
+
+        except Exception as e:
+            return {}

idun_platform_cli/tui/validators/guardrails.py

@@ -0,0 +1,88 @@
+"""Guardrails validation logic."""
+
+from idun_agent_schema.engine.guardrails_v2 import (
+    GuardrailConfigId,
+    BiasCheckConfig,
+    ToxicLanguageConfig,
+    CompetitionCheckConfig,
+    BanListConfig,
+    DetectPIIConfig,
+)
+
+
+def validate_guardrail(guardrail_id: str, config: dict) -> tuple[any, str]:
+    try:
+        match guardrail_id:
+            case "bias_check":
+                threshold = float(config.get("threshold", 0.5))
+                validated = BiasCheckConfig(
+                    config_id=GuardrailConfigId.BIAS_CHECK,
+                    api_key=config.get("api_key", ""),
+                    reject_message=config.get("reject_message", "Bias detected"),
+                    threshold=threshold
+                )
+                return validated, "ok"
+
+            case "toxic_language":
+                threshold = float(config.get("threshold", 0.5))
+                validated = ToxicLanguageConfig(
+                    config_id=GuardrailConfigId.TOXIC_LANGUAGE,
+                    api_key=config.get("api_key", ""),
+                    reject_message=config.get("reject_message", "Toxic language detected"),
+                    threshold=threshold
+                )
+                return validated, "ok"
+
+            case "competition_check":
+                competitors = config.get("competitors", [])
+                if isinstance(competitors, str):
+                    competitors = [
+                        c.strip() for c in competitors.split(",") if c.strip()
+                    ]
+                validated = CompetitionCheckConfig(
+                    config_id=GuardrailConfigId.COMPETITION_CHECK,
+                    api_key=config.get("api_key", ""),
+                    reject_message=config.get("reject_message", "Competitor mentioned"),
+                    competitors=competitors,
+                )
+                return validated, "ok"
+
+            case "ban_list":
+                banned_words = config.get("banned_words", [])
+                if isinstance(banned_words, str):
+                    banned_words = [
+                        w.strip() for w in banned_words.split(",") if w.strip()
+                    ]
+
+                validated = BanListConfig(
+                    config_id=GuardrailConfigId.BAN_LIST,
+                    api_key=config.get("api_key", ""),
+                    reject_message=config.get("reject_message", ""),
+                    guard_params={"banned_words": banned_words},
+                )
+                return validated, "ok"
+
+            case "detect_pii":
+                pii_entities = config.get("pii_entities", [])
+                if isinstance(pii_entities, str):
+                    pii_entities = [
+                        e.strip() for e in pii_entities.split(",") if e.strip()
+                    ]
+
+                validated = DetectPIIConfig(
+                    config_id=GuardrailConfigId.DETECT_PII,
+                    api_key=config.get("api_key", ""),
+                    reject_message=config.get("reject_message", ""),
+                    guard_params={"pii_entities": pii_entities, "on_fail": "exception"},
+                )
+                return validated, "ok"
+
+            case _:
+                return None, f"Unknown guardrail type: {guardrail_id}"
+
+    except Exception as e:
+        error_msg = str(e)
+        if len(error_msg) > 100:
+            error_msg = error_msg[:100] + "..."
+        error_msg = error_msg.replace("<", "").replace(">", "")
+        return None, f"Validation error for {guardrail_id}: {error_msg}"

idun_platform_cli/tui/validators/mcps.py

@@ -0,0 +1,84 @@
+"""MCPs validation logic."""
+
+from idun_agent_schema.engine.mcp_server import MCPServer
+
+
+def validate_mcp_servers(
+    mcp_servers_data: list[dict],
+) -> tuple[list[MCPServer] | None, str]:
+    if not mcp_servers_data:
+        return [], "ok"
+
+    try:
+        validated_servers = []
+        seen_names = set()
+
+        for idx, server_data in enumerate(mcp_servers_data):
+            name = server_data.get("name", "")
+            if not name:
+                return None, f"Server {idx + 1}: Name is required"
+
+            if name in seen_names:
+                return None, f"Duplicate server name: {name}"
+            seen_names.add(name)
+
+            transport = server_data.get("transport", "streamable_http")
+
+            if transport == "stdio":
+                if not server_data.get("command"):
+                    return (
+                        None,
+                        f"Server '{name}': command is required for stdio transport",
+                    )
+            elif transport in ["sse", "streamable_http", "websocket"]:
+                if not server_data.get("url"):
+                    return (
+                        None,
+                        f"Server '{name}': url is required for {transport} transport",
+                    )
+
+            args = server_data.get("args", [])
+            if isinstance(args, str):
+                args = [a.strip() for a in args.split("\n") if a.strip()]
+
+            headers = server_data.get("headers", {})
+            if isinstance(headers, str):
+                import json
+
+                try:
+                    headers = json.loads(headers) if headers.strip() else {}
+                except json.JSONDecodeError:
+                    return None, f"Server '{name}': Invalid JSON for headers"
+
+            env = server_data.get("env", {})
+            if isinstance(env, str):
+                import json
+
+                try:
+                    env = json.loads(env) if env.strip() else {}
+                except json.JSONDecodeError:
+                    return None, f"Server '{name}': Invalid JSON for env"
+
+            server_config = {
+                "name": name,
+                "transport": transport,
+            }
+
+            if server_data.get("url"):
+                server_config["url"] = server_data["url"]
+            if headers:
+                server_config["headers"] = headers
+            if server_data.get("command"):
+                server_config["command"] = server_data["command"]
+            if args:
+                server_config["args"] = args
+            if env:
+                server_config["env"] = env
+
+            validated_server = MCPServer.model_validate(server_config)
+            validated_servers.append(validated_server)
+
+        return validated_servers, "ok"
+
+    except Exception as e:
+        return None, f"Validation error: {str(e)}"

idun_platform_cli/tui/validators/observability.py

@@ -0,0 +1,65 @@
+from idun_agent_schema.engine.observability_v2 import (
+    ObservabilityConfig,
+    ObservabilityProvider,
+)
+
+
+def validate_observability(
+    provider: ObservabilityProvider, config
+) -> tuple[ObservabilityConfig | None, str]:
+    match provider:
+        case ObservabilityProvider.LANGFUSE:
+            from idun_agent_schema.engine.observability_v2 import LangfuseConfig
+
+            try:
+                config = LangfuseConfig(**config)
+                return ObservabilityConfig(
+                    provider=provider, config=config, enabled=True
+                ), "ok"
+            except Exception as e:
+                return None, f"Error validating Langfuse config: {e}"
+
+        case ObservabilityProvider.PHOENIX:
+            from idun_agent_schema.engine.observability_v2 import PhoenixConfig
+
+            try:
+                config = PhoenixConfig(**config)
+                return ObservabilityConfig(
+                    provider=provider, config=config, enabled=True
+                ), "ok"
+            except Exception as e:
+                return None, f"Error validating Phoenix config: {e}"
+
+        case ObservabilityProvider.GCP_LOGGING:
+            from idun_agent_schema.engine.observability_v2 import GCPLoggingConfig
+
+            try:
+                config = GCPLoggingConfig(**config)
+                return ObservabilityConfig(
+                    provider=provider, config=config, enabled=True
+                ), "ok"
+            except Exception as e:
+                return None, f"Error validating GCP logging config: {e}"
+
+        case ObservabilityProvider.GCP_TRACE:
+            from idun_agent_schema.engine.observability_v2 import GCPTraceConfig
+
+            try:
+                config = GCPTraceConfig(**config)
+                return ObservabilityConfig(
+                    provider=provider, config=config, enabled=True
+                ), "ok"
+            except Exception as e:
+                return None, f"Error validating GCP trace config: {e}"
+
+        case ObservabilityProvider.LANGSMITH:
+            from idun_agent_schema.engine.observability_v2 import LangsmithConfig
+
+            try:
+                config = LangsmithConfig(**config)
+
+                return ObservabilityConfig(
+                    provider=provider, config=config, enabled=True
+                ), "ok"
+            except Exception as e:
+                return None, f"Error validating Langsmith config: {e}"

idun_platform_cli/tui/widgets/__init__.py

@@ -0,0 +1,19 @@
+"""Widget components for the agent configuration screens."""
+
+from .chat_widget import ChatWidget
+from .guardrails_widget import GuardrailsWidget
+from .identity_widget import IdentityWidget
+from .mcps_widget import MCPsWidget
+from .memory_widget import MemoryWidget
+from .observability_widget import ObservabilityWidget
+from .serve_widget import ServeWidget
+
+__all__ = [
+    "ChatWidget",
+    "GuardrailsWidget",
+    "IdentityWidget",
+    "MCPsWidget",
+    "MemoryWidget",
+    "ObservabilityWidget",
+    "ServeWidget",
+]

idun_platform_cli/tui/widgets/chat_widget.py

@@ -0,0 +1,153 @@
+"""Chat widget for interacting with running agent."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Button, Input, Label, LoadingIndicator, RichLog
+
+
+class ChatWidget(Widget):
+    server_running = reactive(False)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.config_data = {}
+        self.server_port = None
+        self.agent_name = ""
+
+    def compose(self) -> ComposeResult:
+        chat_container = Vertical(classes="chat-history-container")
+        chat_container.border_title = "Conversation"
+        with chat_container:
+            yield RichLog(id="chat_history", highlight=True, markup=True, wrap=True)
+
+        thinking_container = Horizontal(classes="chat-thinking-container", id="chat_thinking")
+        thinking_container.display = False
+        with thinking_container:
+            yield LoadingIndicator(id="chat_spinner")
+            yield Label("Thinking...", id="thinking_label")
+
+        input_container = Horizontal(classes="chat-input-container")
+        with input_container:
+            yield Input(
+                placeholder="Type your message...",
+                id="chat_input",
+                classes="chat-input",
+            )
+            yield Button("Send", id="send_button", classes="send-btn")
+
+    def load_config(self, config: dict) -> None:
+        self.config_data = config
+        server_config = config.get("server", {})
+        api_config = server_config.get("api", {})
+        self.server_port = api_config.get("port", 8008)
+
+        agent_config = config.get("agent", {}).get("config", {})
+        self.agent_name = agent_config.get("name", "Agent")
+
+        self.run_worker(self._check_server_status())
+
+    def on_mount(self) -> None:
+        chat_log = self.query_one("#chat_history", RichLog)
+        chat_log.write("[dim]Start chatting with your agent...[/dim]")
+        chat_log.write(
+            "[dim]Make sure the agent server is running from the Serve page.[/dim]"
+        )
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "send_button":
+            self._handle_send()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "chat_input":
+            self._handle_send()
+
+    def _handle_send(self) -> None:
+        input_widget = self.query_one("#chat_input", Input)
+        message = input_widget.value.strip()
+
+        if not message:
+            return
+
+        if not self.server_port:
+            self.app.notify("Server not configured", severity="error")
+            return
+
+        input_widget.value = ""
+
+        chat_log = self.query_one("#chat_history", RichLog)
+        chat_log.write(f"[cyan]You:[/cyan] {message}")
+
+        thinking_container = self.query_one("#chat_thinking")
+        thinking_container.display = True
+
+        self.run_worker(self._send_message(message))
+
+    async def _send_message(self, message: str) -> None:
+        import httpx
+
+        chat_log = self.query_one("#chat_history", RichLog)
+        thinking_container = self.query_one("#chat_thinking")
+
+        try:
+            url = f"http://localhost:{self.server_port}/agent/invoke"
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                response = await client.post(
+                    url, json={"session_id": "123", "query": message}
+                )
+                result = response.json()
+
+                agent_response = result.get(
+                    "output", result.get("response", "No response")
+                )
+                thinking_container.display = False
+                chat_log.write(f"[green]{self.agent_name}:[/green] {agent_response}")
+
+        except httpx.ConnectError:
+            thinking_container.display = False
+            chat_log.write("[red]Error:[/red] Cannot connect to server. Is it running?")
+            self.app.notify(
+                "Server not reachable. Start it from the Serve page.", severity="error"
+            )
+        except httpx.TimeoutException:
+            thinking_container.display = False
+            chat_log.write("[red]Error:[/red] Request timed out")
+            self.app.notify("Request timed out", severity="error")
+        except Exception as e:
+            thinking_container.display = False
+            chat_log.write(f"[red]Error:[/red] Failed to send message: {e}")
+            self.app.notify(
+                "Failed to send message. Check server connection.", severity="error"
+            )
+
+    async def _check_server_status(self) -> None:
+        import httpx
+
+        if not self.server_port:
+            return
+
+        try:
+            url = f"http://localhost:{self.server_port}/health"
+            async with httpx.AsyncClient(timeout=2.0) as client:
+                response = await client.get(url)
+                self.server_running = response.status_code == 200
+
+                if self.server_running:
+                    chat_log = self.query_one("#chat_history", RichLog)
+                    chat_log.write(
+                        f"[green]✓ Connected to server on port {self.server_port}[/green]"
+                    )
+        except Exception:
+            self.server_running = False
+
+    def watch_server_running(self, is_running: bool) -> None:
+        input_widget = self.query_one("#chat_input", Input)
+        send_button = self.query_one("#send_button", Button)
+
+        if is_running:
+            input_widget.disabled = False
+            send_button.disabled = False
+        else:
+            input_widget.disabled = True
+            send_button.disabled = True