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

idun_platform_cli/tui/widgets/chat_widget.py

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

@@ -1,11 +1,11 @@
 """Guardrails configuration widget."""
 
+from idun_agent_schema.engine.guardrails_v2 import GuardrailsV2
 from textual.app import ComposeResult
-from textual.containers import Horizontal, Vertical, Grid
-from textual.widgets import Static, Input, Switch, RadioSet, RadioButton, TextArea
+from textual.containers import Grid, Horizontal, Vertical
 from textual.widget import Widget
+from textual.widgets import Input, RadioButton, RadioSet, Static, Switch, TextArea
 
-from idun_agent_schema.engine.guardrails_v2 import GuardrailsV2
 from idun_platform_cli.tui.validators.guardrails import validate_guardrail
 
 
@@ -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 = {}

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

@@ -2,11 +2,18 @@
 
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
-from textual.widgets import Static, Input, Button, RadioSet, RadioButton, TextArea, OptionList
 from textual.widget import Widget
+from textual.widgets import (
+    Button,
+    Input,
+    OptionList,
+    RadioButton,
+    RadioSet,
+    Static,
+    TextArea,
+)
 from textual.widgets.option_list import Option
 
-
 MCP_TEMPLATES = {
     "time": {
         "name": "time-reference",
@@ -34,14 +41,24 @@ class MCPsWidget(Widget):
         templates_row = Horizontal(classes="templates-row")
         templates_row.compose_add_child(Static("Select template:", classes="mcp-label"))
         option_list = OptionList(id="template_selector", classes="template-selector")
-        for template_name in MCP_TEMPLATES.keys():
+        for template_name in MCP_TEMPLATES:
             option_list.add_option(Option(template_name.title(), id=template_name))
         templates_row.compose_add_child(option_list)
-        templates_row.compose_add_child(Button("Add from Template", id="add_from_template_button", classes="add-template-btn"))
+        templates_row.compose_add_child(
+            Button(
+                "Add from Template",
+                id="add_from_template_button",
+                classes="add-template-btn",
+            )
+        )
         templates_section.compose_add_child(templates_row)
         yield templates_section
 
-        yield Button("+ Add Custom MCP Server", id="add_custom_mcp_button", classes="add-custom-btn")
+        yield Button(
+            "+ Add Custom MCP Server",
+            id="add_custom_mcp_button",
+            classes="add-custom-btn",
+        )
 
         yield Vertical(id="mcps_container", classes="mcps-container")
 
@@ -67,7 +84,9 @@ class MCPsWidget(Widget):
     def _add_from_template(self) -> None:
         template_selector = self.query_one("#template_selector", OptionList)
         if template_selector.highlighted is not None:
-            option_id = template_selector.get_option_at_index(template_selector.highlighted).id
+            option_id = template_selector.get_option_at_index(
+                template_selector.highlighted
+            ).id
             if option_id and str(option_id) in MCP_TEMPLATES:
                 template_data = MCP_TEMPLATES[str(option_id)].copy()
                 self._add_mcp_server(template_data)
@@ -95,52 +114,109 @@ class MCPsWidget(Widget):
 
         header = Horizontal(classes="mcp-header")
         name_value = template_data.get("name", "") if template_data else ""
-        header.compose_add_child(Static(name_value or f"Server {index + 1}", id=f"mcp_name_display_{index}", classes="mcp-name-display"))
-        header.compose_add_child(Button("Remove", id=f"remove_mcp_{index}", classes="remove-mcp-btn"))
+        header.compose_add_child(
+            Static(
+                name_value or f"Server {index + 1}",
+                id=f"mcp_name_display_{index}",
+                classes="mcp-name-display",
+            )
+        )
+        header.compose_add_child(
+            Button("Remove", id=f"remove_mcp_{index}", classes="remove-mcp-btn")
+        )
         card.compose_add_child(header)
 
         name_row = Horizontal(classes="mcp-field-row")
         name_row.compose_add_child(Static("Name:", classes="mcp-label"))
-        name_row.compose_add_child(Input(value=name_value, placeholder="server-name", id=f"mcp_name_{index}", classes="mcp-input"))
+        name_row.compose_add_child(
+            Input(
+                value=name_value,
+                placeholder="server-name",
+                id=f"mcp_name_{index}",
+                classes="mcp-input",
+            )
+        )
         card.compose_add_child(name_row)
 
         transport_row = Horizontal(classes="mcp-field-row")
         transport_row.compose_add_child(Static("Transport:", classes="mcp-label"))
         radio_set = RadioSet(id=f"mcp_transport_{index}")
 
-        transport_value = template_data.get("transport", "streamable_http") if template_data else "streamable_http"
-        radio_set.compose_add_child(RadioButton("stdio", id="stdio", value=(transport_value == "stdio")))
-        radio_set.compose_add_child(RadioButton("sse", id="sse", value=(transport_value == "sse")))
-        radio_set.compose_add_child(RadioButton("streamable_http", id="streamable_http", value=(transport_value == "streamable_http")))
-        radio_set.compose_add_child(RadioButton("websocket", id="websocket", value=(transport_value == "websocket")))
+        transport_value = (
+            template_data.get("transport", "streamable_http")
+            if template_data
+            else "streamable_http"
+        )
+        radio_set.compose_add_child(
+            RadioButton("stdio", id="stdio", value=(transport_value == "stdio"))
+        )
+        radio_set.compose_add_child(
+            RadioButton("sse", id="sse", value=(transport_value == "sse"))
+        )
+        radio_set.compose_add_child(
+            RadioButton(
+                "streamable_http",
+                id="streamable_http",
+                value=(transport_value == "streamable_http"),
+            )
+        )
+        radio_set.compose_add_child(
+            RadioButton(
+                "websocket", id="websocket", value=(transport_value == "websocket")
+            )
+        )
         transport_row.compose_add_child(radio_set)
         card.compose_add_child(transport_row)
 
-        http_fields = Vertical(id=f"mcp_http_fields_{index}", classes="http-fields-container")
+        http_fields = Vertical(
+            id=f"mcp_http_fields_{index}", classes="http-fields-container"
+        )
         http_fields.border_title = "HTTP Configuration"
 
         url_row = Horizontal(classes="mcp-field-row")
         url_row.compose_add_child(Static("URL:", classes="mcp-label"))
         url_value = template_data.get("url", "") if template_data else ""
-        url_row.compose_add_child(Input(value=url_value, placeholder="https://api.example.com/mcp", id=f"mcp_url_{index}", classes="mcp-input"))
+        url_row.compose_add_child(
+            Input(
+                value=url_value,
+                placeholder="https://api.example.com/mcp",
+                id=f"mcp_url_{index}",
+                classes="mcp-input",
+            )
+        )
         http_fields.compose_add_child(url_row)
 
         headers_row = Horizontal(classes="mcp-field-row")
         headers_row.compose_add_child(Static("Headers (JSON):", classes="mcp-label"))
         headers_value = template_data.get("headers", "") if template_data else ""
-        headers_row.compose_add_child(TextArea(text=str(headers_value) if headers_value else "", id=f"mcp_headers_{index}", classes="mcp-textarea"))
+        headers_row.compose_add_child(
+            TextArea(
+                text=str(headers_value) if headers_value else "",
+                id=f"mcp_headers_{index}",
+                classes="mcp-textarea",
+            )
+        )
         http_fields.compose_add_child(headers_row)
 
         http_fields.display = transport_value in ["sse", "streamable_http", "websocket"]
         card.compose_add_child(http_fields)
 
-        stdio_fields = Vertical(id=f"mcp_stdio_fields_{index}", classes="stdio-fields-container")
+        stdio_fields = Vertical(
+            id=f"mcp_stdio_fields_{index}", classes="stdio-fields-container"
+        )
         stdio_fields.border_title = "Stdio Configuration"
 
         command_row = Horizontal(classes="mcp-field-row")
         command_row.compose_add_child(Static("Command:", classes="mcp-label"))
         command_value = template_data.get("command", "") if template_data else ""
-        command_row.compose_add_child(Input(value=command_value, placeholder="npx", id=f"mcp_command_{index}", classes="mcp-input"))
+        command_row.compose_add_child(
+            Input(
+                value=command_value,
+                placeholder="npx",
+                id=f"mcp_command_{index}",
+                classes="mcp-input",
+            )
+        )
         stdio_fields.compose_add_child(command_row)
 
         args_row = Horizontal(classes="mcp-field-row")
@@ -150,7 +226,9 @@ class MCPsWidget(Widget):
             args_list = template_data["args"]
             if isinstance(args_list, list):
                 args_value = "\n".join(args_list)
-        args_textarea = TextArea(text=args_value, id=f"mcp_args_{index}", classes="mcp-textarea")
+        args_textarea = TextArea(
+            text=args_value, id=f"mcp_args_{index}", classes="mcp-textarea"
+        )
         args_textarea.placeholder = "run\n-i\n--rm"
         args_row.compose_add_child(args_textarea)
         stdio_fields.compose_add_child(args_row)
@@ -160,8 +238,11 @@ class MCPsWidget(Widget):
         env_value = ""
         if template_data and "env" in template_data:
             import json
+
             env_value = json.dumps(template_data["env"], indent=2)
-        env_row.compose_add_child(TextArea(text=env_value, id=f"mcp_env_{index}", classes="mcp-textarea"))
+        env_row.compose_add_child(
+            TextArea(text=env_value, id=f"mcp_env_{index}", classes="mcp-textarea")
+        )
         stdio_fields.compose_add_child(env_row)
 
         stdio_fields.display = transport_value == "stdio"
@@ -189,7 +270,9 @@ class MCPsWidget(Widget):
                 name = name_input.value
 
                 if not name:
-                    self.app.notify(f"Server {server_id + 1}: Name is required", severity="error")
+                    self.app.notify(
+                        f"Server {server_id + 1}: Name is required", severity="error"
+                    )
                     return None
 
                 radio_set = self.query_one(f"#mcp_transport_{server_id}", RadioSet)
@@ -206,7 +289,9 @@ class MCPsWidget(Widget):
                     url_input = self.query_one(f"#mcp_url_{server_id}", Input)
                     server_config["url"] = url_input.value
 
-                    headers_textarea = self.query_one(f"#mcp_headers_{server_id}", TextArea)
+                    headers_textarea = self.query_one(
+                        f"#mcp_headers_{server_id}", TextArea
+                    )
                     if headers_textarea.text.strip():
                         server_config["headers"] = headers_textarea.text.strip()
 
@@ -223,8 +308,11 @@ 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