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

idun_platform_cli/tui/main.py

@@ -59,14 +59,14 @@ class IdunApp(App):
             )
 
             yield Static("IDUN AGENT PLATFORM", classes="platform")
-            yield Static("Deploy, guard and monitor any agent", classes="tagline")
-            yield Static("Built with ❤️ by Idun Group", classes="built-by")
+            yield Static("Deploy, guard and monitor your agents.", classes="tagline")
+            yield Static("Built with 💜 by Idun Group", classes="built-by")
             yield Static(f"v{__version__}", classes="version")
             with Horizontal(classes="link-container"):
                 yield Link("⭐️ Github", url=self.REPO, classes="links")
                 yield Link("📚 Docs", url=self.DOCS, classes="links")
+                yield Link("🌐 Website", url=self.DOCS, classes="links")
 
-            yield Static("What do you want to do?", classes="question_prompt")
             yield MainPageActions()
         yield Footer()
 

idun_platform_cli/tui/schemas/create_agent.py

@@ -21,7 +21,7 @@ agent:
 # we need to map the graph_definition, pipeline_definition, agent_definition fields based on framework
 AGENT_SOURCE_KEY_MAPPING: dict[str, str] = dict(
     {
-        "HAYSTACK": "pipeline_definition",
+        "HAYSTACK": "component_definition",
         "LANGGRAPH": "graph_definition",
         "ADK": "agent",
     }
@@ -35,21 +35,25 @@ class TUIAgentConfig(BaseModel):
     graph_definition: str
 
     @field_validator("*", mode="after")
-    def validate_not_null(cls, value: str | Any | None) -> str:
+    def validate_not_null(cls, value: str | Any | None) -> str:  # noqa: N805
         if value is None or value == "":
             raise ValueError("Cannot have empty fields!")
         return value
 
     def to_engine_config(self) -> dict[str, Any]:
+        sanitized_name = self.name.replace("-", "_").replace(" ", "_")
+
         agent_config = {
-            "name": self.name,
+            "name": sanitized_name if self.framework == "ADK" else self.name,
             AGENT_SOURCE_KEY_MAPPING[self.framework]: self.graph_definition,
         }
 
         if self.framework == "ADK":
-            agent_config["app_name"] = self.name.replace("-", "_").replace(" ", "_")
+            agent_config["app_name"] = sanitized_name
             agent_config["session_service"] = {"type": "in_memory"}
             agent_config["memory_service"] = {"type": "in_memory"}
+        elif self.framework == "HAYSTACK":
+            agent_config["component_type"] = "pipeline"
 
         return {
             "server": {"api": {"port": self.port}},

idun_platform_cli/tui/screens/create_agent.py

@@ -7,15 +7,17 @@ from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical
 from textual.reactive import reactive
 from textual.screen import Screen
-from textual.widgets import Button, Footer, Label, RichLog, Static
+from textual.widgets import Button, Label, RichLog, Static
 
 from idun_platform_cli.tui.css.create_agent import CREATE_AGENT_CSS
 from idun_platform_cli.tui.schemas.create_agent import TUIAgentConfig
 from idun_platform_cli.tui.utils.config import ConfigManager
 from idun_platform_cli.tui.widgets import (
+    ChatWidget,
     GuardrailsWidget,
     IdentityWidget,
     MCPsWidget,
+    MemoryWidget,
     ObservabilityWidget,
     ServeWidget,
 )
@@ -32,10 +34,12 @@ class CreateAgentScreen(Screen):
     active_section = reactive("identity")
     nav_panes = [
         "nav-identity",
+        "nav-memory",
         "nav-observability",
         "nav-guardrails",
         "nav-mcps",
         "nav-serve",
+        "nav-chat",
     ]
     current_nav_index = 0
     focus_on_nav = True  # Track if focus is on nav or content
@@ -48,6 +52,39 @@ class CreateAgentScreen(Screen):
         self.server_process = None
         self.server_running = False
 
+    def on_unmount(self) -> None:
+        if self.server_process:
+            import os
+            import signal
+            import subprocess
+
+            try:
+                pgid = os.getpgid(self.server_process.pid)
+                os.killpg(pgid, signal.SIGKILL)
+            except (ProcessLookupError, OSError, AttributeError, PermissionError):
+                try:
+                    self.server_process.kill()
+                except:
+                    pass
+
+            try:
+                config = self.config_manager.load_config()
+                if config:
+                    port = config.get("server", {}).get("api", {}).get("port", 8008)
+                    pids = (
+                        subprocess.check_output(["lsof", "-ti", f":{port}"], text=True)
+                        .strip()
+                        .split("\n")
+                    )
+                    for pid in pids:
+                        if pid:
+                            try:
+                                os.kill(int(pid), signal.SIGKILL)
+                            except:
+                                pass
+            except:
+                pass
+
     def watch_active_section(self, new_section: str) -> None:
         for section_id, widget in self.widgets_map.items():
             if section_id == new_section:
@@ -67,12 +104,20 @@ class CreateAgentScreen(Screen):
                         severity="warning",
                     )
 
+        if new_section == "chat":
+            config = self.config_manager.load_config()
+            chat_widget = self.widgets_map.get("chat")
+            if chat_widget and config:
+                chat_widget.load_config(config)
+
         for pane_id in [
             "nav-identity",
+            "nav-memory",
             "nav-observability",
             "nav-guardrails",
             "nav-mcps",
             "nav-serve",
+            "nav-chat",
         ]:
             pane = self.query_one(f"#{pane_id}")
             if pane_id == f"nav-{new_section}":
@@ -101,6 +146,18 @@ class CreateAgentScreen(Screen):
                 nav_identity.can_focus = True
                 yield nav_identity
 
+                nav_memory = Vertical(
+                    Label(
+                        "Configure agent\ncheckpointing",
+                        id="nav-memory-label",
+                    ),
+                    classes="nav-pane",
+                    id="nav-memory",
+                )
+                nav_memory.border_title = "Memory"
+                nav_memory.can_focus = True
+                yield nav_memory
+
                 nav_observability = Vertical(
                     Label(
                         "Setup monitoring\nand tracing",
@@ -140,6 +197,15 @@ class CreateAgentScreen(Screen):
                 nav_serve.can_focus = True
                 yield nav_serve
 
+                nav_chat = Vertical(
+                    Label("Chat with your\nrunning agent"),
+                    classes="nav-pane",
+                    id="nav-chat",
+                )
+                nav_chat.border_title = "Chat"
+                nav_chat.can_focus = True
+                yield nav_chat
+
                 with Horizontal(classes="action-buttons"):
                     yield Button("Back", id="back_button", classes="action-btn")
                     yield Button("Next", id="next_button", classes="action-btn")
@@ -147,6 +213,9 @@ class CreateAgentScreen(Screen):
             with Vertical(classes="content-area"):
                 identity = IdentityWidget(id="widget-identity", classes="section")
 
+                memory = MemoryWidget(id="widget-memory", classes="section")
+                memory.border_title = "Memory & Checkpointing"
+
                 observability = ObservabilityWidget(
                     id="widget-observability", classes="section"
                 )
@@ -161,26 +230,38 @@ class CreateAgentScreen(Screen):
                 serve = ServeWidget(id="widget-serve", classes="section")
                 serve.border_title = "Validate & Run"
 
+                chat = ChatWidget(id="widget-chat", classes="section")
+                chat.border_title = "Chat"
+
                 self.widgets_map = {
                     "identity": identity,
+                    "memory": memory,
                     "observability": observability,
                     "guardrails": guardrails,
                     "mcps": mcps,
                     "serve": serve,
+                    "chat": chat,
                 }
 
+                memory.display = False
                 observability.display = False
                 guardrails.display = False
                 mcps.display = False
                 serve.display = False
+                chat.display = False
 
                 yield identity
+                yield memory
                 yield observability
                 yield guardrails
                 yield mcps
                 yield serve
+                yield chat
 
-        footer = Static("💡 Press Next to save section", classes="custom-footer")
+        footer = Static(
+            "💡 Press Next to save section | Press Ctrl+Q to exit",
+            classes="custom-footer",
+        )
         yield footer
 
     def on_mount(self) -> None:
@@ -201,7 +282,7 @@ class CreateAgentScreen(Screen):
             if active_widget:
                 try:
                     focusable = active_widget.query(
-                        "Input, OptionList, DirectoryTree, Button"
+                        "Input, OptionList, DirectoryTree, Button, RadioSet"
                     ).first()
                     if focusable:
                         focusable.focus()
@@ -288,6 +369,8 @@ class CreateAgentScreen(Screen):
                 return
 
             if section == "identity":
+                if not widget.validate():
+                    return
                 data = widget.get_data()
                 if data is None:
                     self.notify("Please complete all required fields", severity="error")
@@ -307,13 +390,26 @@ class CreateAgentScreen(Screen):
                         return
                     self.validated_sections.add("identity")
                     self._update_nav_checkmark("identity")
-                except ValidationError as e:
+                except ValidationError:
                     self.notify(
-                        f"Validation error: {str(e)}",
+                        "Error validating Identity: make sure all fields are correct.",
                         severity="error",
                     )
                     return
 
+            elif section == "memory":
+                data = widget.get_data()
+                if data is not None:
+                    success, msg = self.config_manager.save_partial("memory", data)
+                    if not success:
+                        self.notify("Memory configuration is invalid", severity="error")
+                        return
+                    self.validated_sections.add("memory")
+                    self._update_nav_checkmark("memory")
+                else:
+                    self.notify("Please configure checkpoint settings", severity="error")
+                    return
+
             elif section == "observability":
                 data = widget.get_data()
                 if data is None:
@@ -356,15 +452,20 @@ class CreateAgentScreen(Screen):
 
                 validated_servers, msg = validate_mcp_servers(data)
                 if validated_servers is None:
-                    error_msg = str(msg).replace("[", "").replace("]", "")
-                    self.notify(f"MCP validation failed: {error_msg[:200]}", severity="error")
+                    self.notify(
+                        "Error validating MCPs: make sure all fields are correct.",
+                        severity="error",
+                    )
                     return
 
                 success, save_msg = self.config_manager.save_partial(
                     "mcp_servers", validated_servers
                 )
                 if not success:
-                    self.notify(f"Failed to save: {save_msg}", severity="error")
+                    self.notify(
+                        "Error saving MCPs: make sure all fields are correct.",
+                        severity="error",
+                    )
                     return
 
                 self.validated_sections.add("mcps")
@@ -378,19 +479,74 @@ class CreateAgentScreen(Screen):
                 section = self.nav_panes[self.current_nav_index].replace("nav-", "")
                 self.active_section = section
 
-        elif event.button.id == "validate_run_button":
+        elif event.button.id == "save_exit_button":
+            if self.server_running and self.server_process:
+                self.notify("Kill Server before exiting", severity="warning")
+                return
+            self.notify("Configuration saved. Exiting...", severity="information")
+            self.app.exit()
+
+        elif event.button.id == "save_run_button":
             if self.server_running and self.server_process:
-                self.server_process.terminate()
+                import os
+                import signal
+                import subprocess
+
+                rich_log = self.query_one("#server_logs", RichLog)
+                rich_log.write("\n[yellow]Stopping server...[/yellow]")
+
+                try:
+                    pgid = os.getpgid(self.server_process.pid)
+                    os.killpg(pgid, signal.SIGTERM)
+                    try:
+                        self.server_process.wait(timeout=3)
+                    except subprocess.TimeoutExpired:
+                        os.killpg(pgid, signal.SIGKILL)
+                        self.server_process.wait(timeout=1)
+                except (ProcessLookupError, OSError, PermissionError):
+                    try:
+                        self.server_process.terminate()
+                        self.server_process.wait(timeout=2)
+                    except subprocess.TimeoutExpired:
+                        self.server_process.kill()
+                        self.server_process.wait(timeout=1)
+                    except:
+                        pass
+
+                config = self.config_manager.load_config()
+                if config:
+                    port = config.get("server", {}).get("api", {}).get("port", 8008)
+                    try:
+                        subprocess.run(
+                            ["lsof", "-ti", f":{port}"],
+                            capture_output=True,
+                            text=True,
+                            check=True,
+                        )
+                        pids = (
+                            subprocess.check_output(
+                                ["lsof", "-ti", f":{port}"], text=True
+                            )
+                            .strip()
+                            .split("\n")
+                        )
+                        for pid in pids:
+                            if pid:
+                                try:
+                                    os.kill(int(pid), signal.SIGKILL)
+                                except:
+                                    pass
+                    except:
+                        pass
+
                 self.server_process = None
                 self.server_running = False
 
-                button = self.query_one("#validate_run_button", Button)
-                button.label = "Validate & Run"
+                button = self.query_one("#save_run_button", Button)
+                button.label = "Save and Run"
                 button.remove_class("kill-mode")
 
-                rich_log = self.query_one("#server_logs", RichLog)
                 rich_log.write("\n[red]Server stopped[/red]")
-
                 self.notify("Server stopped", severity="information")
                 return
 
@@ -424,11 +580,18 @@ class CreateAgentScreen(Screen):
 
             try:
                 process = subprocess.Popen(
-                    ["idun", "agent", "serve", "--source=file", f"--path={config_path}"],
+                    [
+                        "idun",
+                        "agent",
+                        "serve",
+                        "--source=file",
+                        f"--path={config_path}",
+                    ],
                     stdout=subprocess.PIPE,
                     stderr=subprocess.STDOUT,
                     text=True,
                     bufsize=1,
+                    start_new_session=True,
                 )
 
                 fd = process.stdout.fileno()
@@ -438,14 +601,17 @@ class CreateAgentScreen(Screen):
                 self.server_process = process
                 self.server_running = True
 
-                button = self.query_one("#validate_run_button", Button)
+                button = self.query_one("#save_run_button", Button)
                 button.label = "Kill Server"
                 button.add_class("kill-mode")
 
                 self.run_worker(self._stream_logs(process), exclusive=True)
 
-            except Exception as e:
-                self.notify(f"Failed to start server: {e}", severity="error")
+            except Exception:
+                self.notify(
+                    "Failed to start server. Check your configuration.",
+                    severity="error",
+                )
 
     async def _stream_logs(self, process) -> None:
         import asyncio
@@ -469,8 +635,8 @@ class CreateAgentScreen(Screen):
 
                 self.server_running = False
                 self.server_process = None
-                button = self.query_one("#validate_run_button", Button)
-                button.label = "Validate & Run"
+                button = self.query_one("#save_run_button", Button)
+                button.label = "Save and Run"
                 button.remove_class("kill-mode")
                 rich_log.write("\n[yellow]Server exited[/yellow]")
                 break

idun_platform_cli/tui/utils/config.py

@@ -7,7 +7,6 @@ from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
 from pydantic import ValidationError
 
 from idun_platform_cli.tui.schemas.create_agent import (
-    AGENT_SOURCE_KEY_MAPPING,
     TUIAgentConfig,
 )
 
@@ -128,6 +127,28 @@ class ConfigManager:
                     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
 
@@ -157,5 +178,5 @@ class ConfigManager:
             with self.agent_path.open("r") as f:
                 return yaml.safe_load(f) or {}
 
-        except Exception as e:
+        except Exception:
             return {}

idun_platform_cli/tui/validators/guardrails.py

@@ -1,12 +1,12 @@
 """Guardrails validation logic."""
 
 from idun_agent_schema.engine.guardrails_v2 import (
-    GuardrailConfigId,
+    BanListConfig,
     BiasCheckConfig,
-    ToxicLanguageConfig,
     CompetitionCheckConfig,
-    BanListConfig,
     DetectPIIConfig,
+    GuardrailConfigId,
+    ToxicLanguageConfig,
 )
 
 
@@ -16,14 +16,22 @@ def validate_guardrail(guardrail_id: str, config: dict) -> tuple[any, str]:
             case "bias_check":
                 threshold = float(config.get("threshold", 0.5))
                 validated = BiasCheckConfig(
-                    config_id=GuardrailConfigId.BIAS_CHECK, threshold=threshold
+                    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, threshold=threshold
+                    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"
 
@@ -35,6 +43,8 @@ def validate_guardrail(guardrail_id: str, config: dict) -> tuple[any, str]:
                     ]
                 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"
@@ -73,4 +83,8 @@ def validate_guardrail(guardrail_id: str, config: dict) -> tuple[any, str]:
                 return None, f"Unknown guardrail type: {guardrail_id}"
 
     except Exception as e:
-        return None, f"Validation error for {guardrail_id}: {str(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

@@ -30,12 +30,15 @@ def validate_mcp_servers(
                         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",
-                    )
+            elif transport in [
+                "sse",
+                "streamable_http",
+                "websocket",
+            ] and 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):

idun_platform_cli/tui/widgets/__init__.py

@@ -1,15 +1,19 @@
 """Widget components for the agent configuration screens."""
 
-from .identity_widget import IdentityWidget
-from .observability_widget import ObservabilityWidget
+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__ = [
-    "IdentityWidget",
-    "ObservabilityWidget",
+    "ChatWidget",
     "GuardrailsWidget",
+    "IdentityWidget",
     "MCPsWidget",
+    "MemoryWidget",
+    "ObservabilityWidget",
     "ServeWidget",
 ]