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

idun_platform_cli/tui/widgets/identity_widget.py

@@ -25,6 +25,7 @@ class IdentityWidget(Widget):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.selected_file_path = ""
+        self.selected_variable = ""
 
     def compose(self) -> ComposeResult:
         agent_info_section = Horizontal(
@@ -115,7 +116,7 @@ class IdentityWidget(Widget):
         import ast
 
         try:
-            with open(file_path, "r") as f:
+            with open(file_path) as f:
                 tree = ast.parse(f.read())
 
             variables = []
@@ -127,21 +128,28 @@ class IdentityWidget(Widget):
 
             var_list = self.query_one("#variable_list", OptionList)
             var_list.clear_options()
+            self.selected_variable = ""
 
             if variables:
                 for var in variables:
                     var_list.add_option(Option(var, id=var))
-                var_list.highlighted = 0
             else:
                 var_list.add_option(Option("No variables found", id="none"))
 
-        except Exception as e:
-            self.app.notify(f"Error parsing file: {str(e)}", severity="error")
+        except Exception:
+            self.app.notify(
+                "Error parsing file. Make sure it's a valid Python file.",
+                severity="error",
+            )
 
     def on_option_list_option_highlighted(
         self, event: OptionList.OptionHighlighted
     ) -> None:
         if event.option_list.id == "variable_list":
+            var_list = self.query_one("#variable_list", OptionList)
+            if var_list.highlighted is not None:
+                variable_option = var_list.get_option_at_index(var_list.highlighted)
+                self.selected_variable = str(variable_option.id)
             self._update_full_definition()
         elif event.option_list.id == "framework_select":
             self._update_section_labels()
@@ -149,7 +157,9 @@ class IdentityWidget(Widget):
     def _update_section_labels(self) -> None:
         framework_select = self.query_one("#framework_select", OptionList)
         if framework_select.highlighted is not None:
-            framework_option = framework_select.get_option_at_index(framework_select.highlighted)
+            framework_option = framework_select.get_option_at_index(
+                framework_select.highlighted
+            )
             framework = str(framework_option.id)
 
             graph_section = self.query_one(".graph-definition-section", Vertical)
@@ -192,14 +202,22 @@ class IdentityWidget(Widget):
             self.app.notify("Agent name and port are required!", severity="error")
             return False
 
-        var_list = self.query_one("#variable_list", OptionList)
-        var_index = var_list.highlighted
+        if not self.selected_file_path:
+            self.query_one("#identity_error", Static).update(
+                "Please select a Python file"
+            )
+            self.app.notify(
+                "Graph definition incomplete! Select a file.", severity="error"
+            )
+            return False
 
-        if not self.selected_file_path or var_index is None:
+        if not self.selected_variable or self.selected_variable == "none":
             self.query_one("#identity_error", Static).update(
-                "Please select a file and variable"
+                "Please select a variable from the list"
+            )
+            self.app.notify(
+                "Graph definition incomplete! Select a variable.", severity="error"
             )
-            self.app.notify("Graph definition incomplete!", severity="error")
             return False
 
         return True

idun_platform_cli/tui/widgets/mcps_widget.py

@@ -223,8 +223,8 @@ class MCPsWidget(Widget):
 
                 servers_data.append(server_config)
 
-            except Exception as e:
-                self.app.notify(f"Error reading server {server_id + 1}: {str(e)}", severity="error")
+            except Exception:
+                self.app.notify(f"Error reading MCP server {server_id + 1}: check your configuration.", severity="error")
                 return None
 
         return servers_data

idun_platform_cli/tui/widgets/memory_widget.py

@@ -0,0 +1,195 @@
+"""Memory and checkpoint configuration widget."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import ValidationError
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.css.query import NoMatches
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Input, RadioButton, RadioSet, Static
+
+if TYPE_CHECKING:
+    from idun_agent_schema.engine.langgraph import CheckpointConfig
+
+
+class MemoryWidget(Widget):
+    selected_type = reactive("memory")
+
+    def compose(self) -> ComposeResult:
+        main_section = Vertical(classes="memory-main")
+        main_section.border_title = "Checkpoint Configuration"
+
+        with main_section, Horizontal(classes="field-row framework-row"):
+            yield Static("Type:", classes="field-label")
+            with RadioSet(id="checkpoint_type_select"):
+                yield RadioButton("In-Memory", id="memory", value=True)
+                yield RadioButton("SQLite", id="sqlite")
+                yield RadioButton("PostgreSQL", id="postgres")
+
+        config_container = Vertical(
+            classes="checkpoint-config-container",
+            id="checkpoint_config",
+        )
+        yield config_container
+
+    def on_mount(self) -> None:
+        self._update_checkpoint_config()
+
+    def on_radio_set_changed(self, event: RadioSet.Changed) -> None:
+        if event.radio_set.id == "checkpoint_type_select":
+            self.selected_type = str(event.pressed.id)
+            self._update_checkpoint_config()
+
+    def _update_checkpoint_config(self) -> None:
+        try:
+            config_container = self.query_one("#checkpoint_config", Vertical)
+            config_container.remove_children()
+
+            if self.selected_type == "memory":
+                pass
+            elif self.selected_type == "sqlite":
+                self._render_sqlite_config(config_container)
+            elif self.selected_type == "postgres":
+                self._render_postgres_config(config_container)
+        except Exception:
+            pass
+
+    def _render_sqlite_config(self, container: Vertical) -> None:
+        config_section = Vertical(
+            Horizontal(
+                Static("DB URL:", classes="field-label"),
+                Input(
+                    placeholder="sqlite:///./checkpoints.db",
+                    id="sqlite_db_url",
+                    classes="field-input",
+                ),
+                classes="field-row",
+            ),
+            classes="checkpoint-fields-section",
+        )
+        config_section.border_title = "SQLite Configuration"
+        container.mount(config_section)
+
+    def _render_postgres_config(self, container: Vertical) -> None:
+        config_section = Vertical(
+            Horizontal(
+                Static("DB URL:", classes="field-label"),
+                Input(
+                    placeholder="postgresql://user:pass@localhost:5432/db",
+                    id="postgres_db_url",
+                    classes="field-input",
+                ),
+                classes="field-row",
+            ),
+            classes="checkpoint-fields-section",
+        )
+        config_section.border_title = "PostgreSQL Configuration"
+        container.mount(config_section)
+
+    def get_data(self) -> CheckpointConfig | None:
+        from idun_agent_schema.engine.langgraph import (
+            CheckpointConfig,
+            InMemoryCheckpointConfig,
+            PostgresCheckpointConfig,
+            SqliteCheckpointConfig,
+        )
+
+        try:
+            radio_set = self.query_one("#checkpoint_type_select", RadioSet)
+
+            checkpoint_type = "memory"
+            if radio_set.pressed_button:
+                checkpoint_type = str(radio_set.pressed_button.id)
+
+            if checkpoint_type == "memory":
+                return InMemoryCheckpointConfig(type="memory")
+
+            elif checkpoint_type == "sqlite":
+                try:
+                    db_url_input = self.query_one("#sqlite_db_url", Input)
+                    db_url = db_url_input.value.strip()
+                except NoMatches:
+                    self.app.notify(
+                        "Configuration error. Please reselect checkpoint type.",
+                        severity="error",
+                    )
+                    return None
+
+                if not db_url:
+                    self.app.notify(
+                        "SQLite DB URL is required",
+                        severity="error",
+                    )
+                    return None
+
+                if not db_url.startswith("sqlite:///"):
+                    self.app.notify(
+                        "SQLite URL must start with 'sqlite:///'",
+                        severity="error",
+                    )
+                    return None
+
+                try:
+                    return SqliteCheckpointConfig(type="sqlite", db_url=db_url)
+                except ValidationError:
+                    self.app.notify(
+                        "Invalid SQLite configuration. Check your URL format.",
+                        severity="error",
+                    )
+                    return None
+
+            elif checkpoint_type == "postgres":
+                try:
+                    db_url_input = self.query_one("#postgres_db_url", Input)
+                    db_url = db_url_input.value.strip()
+                except NoMatches:
+                    self.app.notify(
+                        "Configuration error. Please reselect checkpoint type.",
+                        severity="error",
+                    )
+                    return None
+
+                if not db_url:
+                    self.app.notify(
+                        "PostgreSQL DB URL is required",
+                        severity="error",
+                    )
+                    return None
+
+                if not (
+                    db_url.startswith("postgresql://")
+                    or db_url.startswith("postgres://")
+                ):
+                    self.app.notify(
+                        "PostgreSQL URL must start with 'postgresql://' or 'postgres://'",
+                        severity="error",
+                    )
+                    return None
+
+                try:
+                    return PostgresCheckpointConfig(type="postgres", db_url=db_url)
+                except ValidationError:
+                    self.app.notify(
+                        "Invalid PostgreSQL configuration. Check your URL format.",
+                        severity="error",
+                    )
+                    return None
+
+        except NoMatches:
+            self.app.notify(
+                "Error reading checkpoint configuration",
+                severity="error",
+            )
+            return None
+        except Exception:
+            self.app.notify(
+                "Error validating checkpoint configuration",
+                severity="error",
+            )
+            return None
+
+        return None

idun_platform_cli/tui/widgets/observability_widget.py

@@ -4,7 +4,7 @@ from idun_agent_schema.engine.observability_v2 import (
 )
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
-from textual.widgets import Static, Input, Switch, RadioSet, RadioButton
+from textual.widgets import Static, Input, RadioSet, RadioButton, Switch
 from textual.widget import Widget
 from textual.reactive import reactive
 
@@ -12,21 +12,18 @@ from idun_platform_cli.tui.validators.observability import validate_observabilit
 
 
 class ObservabilityWidget(Widget):
-    selected_provider = reactive("LANGFUSE")
+    selected_provider = reactive("OFF")
 
     def compose(self) -> ComposeResult:
         main_section = Vertical(classes="observability-main")
         main_section.border_title = "Observability"
 
         with main_section:
-            with Horizontal(classes="field-row"):
-                yield Static("Enabled:", classes="field-label")
-                yield Switch(value=True, id="enabled_toggle")
-
             with Horizontal(classes="field-row framework-row"):
                 yield Static("Provider:", classes="field-label")
                 with RadioSet(id="provider_select"):
-                    yield RadioButton("LANGFUSE", id="LANGFUSE", value=True)
+                    yield RadioButton("Off", id="OFF", value=True)
+                    yield RadioButton("LANGFUSE", id="LANGFUSE")
                     yield RadioButton("PHOENIX", id="PHOENIX")
                     yield RadioButton("GCP LOGGING", id="GCP_LOGGING")
                     yield RadioButton("GCP TRACE", id="GCP_TRACE")
@@ -49,7 +46,9 @@ class ObservabilityWidget(Widget):
         config_container = self.query_one("#provider_config", Vertical)
         config_container.remove_children()
 
-        if self.selected_provider == "LANGFUSE":
+        if self.selected_provider == "OFF":
+            pass
+        elif self.selected_provider == "LANGFUSE":
             self._render_langfuse_config(config_container)
         elif self.selected_provider == "PHOENIX":
             self._render_phoenix_config(config_container)
@@ -305,16 +304,15 @@ class ObservabilityWidget(Widget):
     def get_data(self) -> ObservabilityConfig | None:
         radio_set = self.query_one("#provider_select", RadioSet)
 
-        provider = ObservabilityProvider.LANGFUSE
+        provider = "OFF"
         if radio_set.pressed_button:
             provider = str(radio_set.pressed_button.id)
 
-        enabled = self.query_one("#enabled_toggle", Switch).value
-        config = {}
-
-        if not enabled:
+        if provider == "OFF":
             return None
 
+        config = {}
+
         match provider:
             case "LANGFUSE":
                 config = {

idun_platform_cli/tui/widgets/serve_widget.py

@@ -1,7 +1,10 @@
 """Serve configuration widget."""
 
+from typing import Any
+
+from rich.syntax import Syntax
 from textual.app import ComposeResult
-from textual.containers import Vertical
+from textual.containers import Horizontal, Vertical
 from textual.widget import Widget
 from textual.widgets import Button, RichLog, Static
 
@@ -14,23 +17,20 @@ class ServeWidget(Widget):
         self.shell_id = None
 
     def compose(self) -> ComposeResult:
-        summary_container = Vertical(classes="serve-summary")
-        summary_container.border_title = "Configuration Summary"
-
-        with summary_container:
-            agent_box = Vertical(classes="summary-box", id="agent_summary")
-            agent_box.border_title = "Agent"
-            with agent_box:
-                yield Static("Loading...", id="agent_summary_text")
+        yaml_container = Vertical(classes="serve-yaml-display")
+        yaml_container.border_title = "Agent Configuration"
 
-            obs_box = Vertical(classes="summary-box", id="obs_summary")
-            obs_box.border_title = "Observability"
-            with obs_box:
-                yield Static("Loading...", id="obs_summary_text")
+        with yaml_container:
+            yield Static("Loading configuration...", id="yaml_content")
 
-        yield Button(
-            "Validate & Run", id="validate_run_button", classes="validate-run-btn"
-        )
+        button_container = Horizontal(classes="serve-button-container")
+        with button_container:
+            yield Button(
+                "Save and Exit", id="save_exit_button", classes="validate-run-btn"
+            )
+            yield Button(
+                "Save and Run", id="save_run_button", classes="validate-run-btn"
+            )
 
         logs_container = Vertical(classes="serve-logs", id="logs_container")
         logs_container.border_title = "Server Logs"
@@ -40,37 +40,41 @@ class ServeWidget(Widget):
 
     def load_config(self, config: dict) -> None:
         self.config_data = config
-        self._update_summary()
-
-    def _update_summary(self) -> None:
-        from idun_platform_cli.tui.schemas.create_agent import AGENT_SOURCE_KEY_MAPPING
-
-        agent_info = self.config_data.get("agent", {})
-        agent_config = agent_info.get("config", {})
-        agent_type = agent_info.get("type")
-        agent_name = agent_config.get("name")
-
-        server_info = self.config_data.get("server", {})
-        port = server_info.get("api", {}).get("port")
-
-        graph_def_key = AGENT_SOURCE_KEY_MAPPING.get(agent_type, "graph_definition")
-        graph_def = agent_config.get(graph_def_key)
-
-        agent_text = f"Name: {agent_name}\nFramework: {agent_type}\nPort: {port}\nGraph: {graph_def}"
-
-        self.query_one("#agent_summary_text", Static).update(agent_text)
-
-        obs_list = self.config_data.get("observability", [])
-        if obs_list:
-            obs_data = obs_list[0]
-            provider = obs_data.get("provider")
-            enabled = obs_data.get("enabled", False)
-            status = "Enabled" if enabled else "Disabled"
-            obs_text = f"Provider: {provider}\nStatus: {status}"
-        else:
-            obs_text = "Not configured"
-
-        self.query_one("#obs_summary_text", Static).update(obs_text)
+        self._update_yaml_display()
+
+    def _update_yaml_display(self) -> None:
+        import yaml
+
+        if not self.config_data:
+            self.query_one("#yaml_content", Static).update(
+                "[yellow]No configuration loaded yet.[/yellow]\n"
+                "[dim]Complete the previous sections to generate configuration.[/dim]"
+            )
+            return
+
+        try:
+            yaml_string = yaml.dump(
+                self.config_data,
+                default_flow_style=False,
+                sort_keys=False,
+                allow_unicode=True
+            )
+
+            syntax = Syntax(
+                yaml_string,
+                "yaml",
+                theme="monokai",
+                line_numbers=True,
+                word_wrap=False,
+                indent_guides=True,
+                background_color="default"
+            )
+
+            self.query_one("#yaml_content", Static).update(syntax)
+
+        except Exception as e:
+            error_msg = f"[red]Error displaying configuration:[/red]\n{str(e)}"
+            self.query_one("#yaml_content", Static).update(error_msg)
 
     def get_agent_name(self) -> str:
         agent_info = self.config_data.get("agent", {})