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

idun_platform_cli/tui/screens/create_agent.py

@@ -13,9 +13,11 @@ 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,35 @@ 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 +100,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 +142,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 +193,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 +209,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 +226,35 @@ 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 +275,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 +362,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 +383,28 @@ 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 +447,14 @@ 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 +468,68 @@ 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
 
@@ -429,6 +568,7 @@ class CreateAgentScreen(Screen):
                     stderr=subprocess.STDOUT,
                     text=True,
                     bufsize=1,
+                    start_new_session=True,
                 )
 
                 fd = process.stdout.fileno()
@@ -438,14 +578,14 @@ 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 +609,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
 

idun_platform_cli/tui/validators/guardrails.py

@@ -16,14 +16,20 @@ 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 +41,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 +81,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/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",
 ]

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

idun_platform_cli/tui/widgets/guardrails_widget.py

@@ -304,7 +304,15 @@ class GuardrailsWidget(Widget):
             if applies_to in ["output", "both"]:
                 output_guardrails.append(validated_config)
 
-        return GuardrailsV2(input=input_guardrails, output=output_guardrails)
+        try:
+            return GuardrailsV2(input=input_guardrails, output=output_guardrails)
+        except Exception:
+            self.app.notify(
+                "Error validating Guardrails: make sure all fields are correct.",
+                severity="error",
+                timeout=10
+            )
+            return None
 
     def _extract_config(self, guardrail_id: str) -> dict:
         config = {}