fix(tui): keep AI-Assisted agent creation flow interactive (#267)

Previously, when selecting 'AI-Assisted' in the agent creation flow,
the TUI would exit interactive mode and show a toast asking the user
to type in the main input box. This was confusing and broke the
interactive flow.

Now, selecting 'AI-Assisted' opens an inline form within the TUI panel
where users can type their agent description directly, keeping the
entire workflow interactive and consistent with other features like
MCP server configuration.

Changes:
- Add build_agent_ai_description_form() function to create inline form
- Export the new function from the builders module
- Update agent_method handler to open inline form instead of exiting
- Add handler for agent-ai-create form submission
- Add unit test for the new form builder

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

cortex-tui/src/interactive/builders/agents.rs

@@ -6,7 +6,9 @@
 
 use std::path::Path;
 
-use crate::interactive::state::{InteractiveAction, InteractiveItem, InteractiveState};
+use crate::interactive::state::{
+    InlineFormField, InlineFormState, InteractiveAction, InteractiveItem, InteractiveState,
+};
 
 /// Agent type for grouping in the list
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -650,6 +652,27 @@ impl NewAgentConfig {
     }
 }
 
+/// Build an inline form for AI-assisted agent creation description.
+///
+/// This form stays in the interactive TUI and allows the user to type
+/// their agent description directly.
+pub fn build_agent_ai_description_form(location: AgentLocation) -> InlineFormState {
+    let location_str = match location {
+        AgentLocation::Project => "project",
+        AgentLocation::Global => "global",
+    };
+
+    InlineFormState::new(
+        "Describe Your Agent",
+        format!("agent-ai-create:{}", location_str),
+    )
+    .with_field(
+        InlineFormField::new("description", "Description")
+            .required()
+            .with_placeholder("Describe what you want the agent to do..."),
+    )
+}
+
 /// Build an interactive state for confirming a new agent configuration
 pub fn build_agent_confirm_selector(config: &NewAgentConfig) -> InteractiveState {
     let mut items = Vec::new();
@@ -777,4 +800,19 @@ mod tests {
         assert_eq!(project.category, AgentCategory::Project);
         assert!(project.source.is_some());
     }
+
+    #[test]
+    fn test_build_agent_ai_description_form() {
+        // Test for project location
+        let form = build_agent_ai_description_form(AgentLocation::Project);
+        assert_eq!(form.title, "Describe Your Agent");
+        assert_eq!(form.action_id, "agent-ai-create:project");
+        assert_eq!(form.fields.len(), 1);
+        assert_eq!(form.fields[0].name, "description");
+        assert!(form.fields[0].required);
+
+        // Test for global location
+        let form_global = build_agent_ai_description_form(AgentLocation::Global);
+        assert_eq!(form_global.action_id, "agent-ai-create:global");
+    }
 }

cortex-tui/src/interactive/builders/mod.rs

@@ -19,8 +19,9 @@ pub mod theme;
 
 pub use agents::{
     AgentCategory, AgentCreationMethod, AgentDisplayInfo, AgentLocation, NewAgentConfig,
-    PermissionPreset, build_agent_confirm_selector, build_agent_location_selector,
-    build_agent_method_selector, build_agents_selector, build_permission_selector,
+    PermissionPreset, build_agent_ai_description_form, build_agent_confirm_selector,
+    build_agent_location_selector, build_agent_method_selector, build_agents_selector,
+    build_permission_selector,
 };
 pub use approval::{build_approval_selector, build_log_level_selector};
 pub use export::build_export_selector;

cortex-tui/src/runner/event_loop.rs

@@ -6169,6 +6169,41 @@ impl EventLoop {
                 self.reopen_mcp_panel();
                 true
             }
+            action if action.starts_with("agent-ai-create:") => {
+                // AI-assisted agent creation from inline form
+                let location_str = action.strip_prefix("agent-ai-create:").unwrap_or("project");
+                let description = values.get("description").cloned().unwrap_or_default();
+
+                if description.is_empty() {
+                    self.app_state
+                        .toasts
+                        .error("Please describe what you want the agent to do");
+                    return true; // Stay in form
+                }
+
+                // Determine location
+                use crate::interactive::builders::AgentLocation;
+                let location = match location_str {
+                    "global" => AgentLocation::Global,
+                    _ => AgentLocation::Project,
+                };
+
+                // Store location for later use
+                self.app_state.agent_creation_location = Some(location);
+                // Set mode to AI and store the description for processing
+                self.app_state.agent_creation_mode = Some("ai".to_string());
+
+                // Insert the description into the input box and trigger AI generation
+                let prompt = format!("Create an agent with this description: {}", description);
+                self.app_state.input.set_text(&prompt);
+
+                self.app_state
+                    .toasts
+                    .info("Generating agent configuration...");
+
+                // Exit interactive mode - the description will be processed
+                false
+            }
             _ => {
                 tracing::warn!("Unhandled inline form submission: {}", action_id);
                 false
@@ -6614,13 +6649,20 @@ impl EventLoop {
                     "agent_method" => {
                         // Handle method selection (AI or manual)
                         if item_id.starts_with("ai:") {
-                            // AI-assisted creation - prompt for description
-                            self.app_state
-                                .toasts
-                                .info("Describe the agent you want to create in the input box");
-                            // Set mode to await AI agent creation
-                            self.app_state.agent_creation_mode = Some("ai".to_string());
-                            return false; // Exit interactive mode, user types description
+                            // AI-assisted creation - show inline form for description
+                            use crate::interactive::builders::{
+                                AgentLocation, build_agent_ai_description_form,
+                            };
+                            let location = self
+                                .app_state
+                                .agent_creation_location
+                                .unwrap_or(AgentLocation::Project);
+                            // Open inline form within the interactive panel
+                            if let Some(state) = self.app_state.input_mode.interactive_mut() {
+                                let form = build_agent_ai_description_form(location);
+                                state.open_form(form);
+                            }
+                            return true; // Stay in interactive mode
                         } else if item_id.starts_with("manual:") {
                             // Manual creation - show permission selector
                             let interactive =