fix(tui): make agent creation fully automated when using AI generation (#350)

Previously, when creating an agent via the /agents command with AI-assisted
generation, the TUI would:
1. Show a toast notification
2. Put 'Create an agent with this description: ...' in the input box
3. Exit interactive mode, requiring user to manually submit

This was confusing and broke the expected flow. Users wanted the agent
to be generated automatically without additional user interaction.

Changes:
- Add ToolEvent::AgentGenerated and ToolEvent::AgentGenerationFailed events
- Spawn async task in handle_inline_form_submission for AI generation
- Call AgentGenerator directly to generate agent configuration
- Save agent to disk automatically
- Navigate back to /agents list with success message
- Remove toast notification during generation
- Remove the 'Create an agent...' input text injection

Now the flow is:
1. User enters description in the AI form
2. Agent is generated via LLM in background
3. Agent is saved to .cortex/agents/ or ~/.cortex/agents/
4. Success toast shown and /agents list refreshed with new agent

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

Author: echobt

cortex-tui/src/events.rs

@@ -67,6 +67,20 @@ pub enum ToolEvent {
         /// Todo items: (content, status) where status is "pending", "in_progress", or "completed"
         todos: Vec<(String, String)>,
     },
+    /// Agent generation completed successfully.
+    AgentGenerated {
+        /// Agent name/identifier
+        name: String,
+        /// Path where agent was saved
+        path: String,
+        /// Location type (project or global)
+        location: String,
+    },
+    /// Agent generation failed.
+    AgentGenerationFailed {
+        /// Error message
+        error: String,
+    },
 }
 
 /// Events from subagent executions.

cortex-tui/src/runner/event_loop.rs

@@ -3647,6 +3647,48 @@ impl EventLoop {
                     }
                 });
             }
+
+            ToolEvent::AgentGenerated {
+                name,
+                path,
+                location,
+            } => {
+                // Agent was generated and saved successfully
+                tracing::info!(
+                    "Agent generated: {} (location: {}, path: {})",
+                    name,
+                    location,
+                    path
+                );
+
+                // Show success message
+                self.app_state
+                    .toasts
+                    .success(format!("Agent @{} created!", name));
+
+                // Add system message about the created agent
+                self.inject_agent_created_event(&name);
+
+                // Refresh the agents list in interactive mode
+                let cwd = std::env::current_dir().ok();
+                let terminal_height = self.app_state.terminal_size.1;
+                let interactive = crate::interactive::builders::build_agents_selector(
+                    cwd.as_deref(),
+                    Some(terminal_height),
+                );
+                self.app_state.enter_interactive_mode(interactive);
+            }
+
+            ToolEvent::AgentGenerationFailed { error } => {
+                // Agent generation failed
+                tracing::error!("Agent generation failed: {}", error);
+
+                // Show error message
+                self.app_state.toasts.error(&error);
+
+                // Exit interactive mode (user can try again with /agents)
+                self.app_state.exit_interactive_mode();
+            }
         }
     }
 
@@ -6666,6 +6708,7 @@ impl EventLoop {
             }
             action if action.starts_with("agent-ai-create:") => {
                 // AI-assisted agent creation from inline form
+                // Fully automated: generate agent with LLM and save directly
                 let location_str = action.strip_prefix("agent-ai-create:").unwrap_or("project");
                 let description = values.get("description").cloned().unwrap_or_default();
 
@@ -6683,21 +6726,104 @@ impl EventLoop {
                     _ => 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());
+                // Spawn async task for AI agent generation
+                let tx = self.tool_event_tx.clone();
+                let location_clone = location;
+                let description_clone = description.clone();
+
+                tokio::spawn(async move {
+                    use cortex_engine::agent::AgentGenerator;
+
+                    // Generate agent configuration using AI
+                    let generator = AgentGenerator::new().with_model("gpt-4o");
+
+                    match generator.generate(&description_clone).await {
+                        Ok(generated) => {
+                            // Determine save directory based on location
+                            let dir = match location_clone {
+                                AgentLocation::Project => {
+                                    match std::env::current_dir() {
+                                        Ok(cwd) => cwd.join(".cortex/agents"),
+                                        Err(e) => {
+                                            let _ = tx.send(crate::events::ToolEvent::AgentGenerationFailed {
+                                                error: format!("Could not determine current directory: {}", e),
+                                            }).await;
+                                            return;
+                                        }
+                                    }
+                                }
+                                AgentLocation::Global => {
+                                    match dirs::home_dir() {
+                                        Some(home) => home.join(".cortex/agents"),
+                                        None => {
+                                            let _ = tx.send(crate::events::ToolEvent::AgentGenerationFailed {
+                                                error: "Could not determine home directory".to_string(),
+                                            }).await;
+                                            return;
+                                        }
+                                    }
+                                }
+                            };
 
-                // 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);
+                            // Create directory if it doesn't exist
+                            if let Err(e) = std::fs::create_dir_all(&dir) {
+                                let _ = tx
+                                    .send(crate::events::ToolEvent::AgentGenerationFailed {
+                                        error: format!("Failed to create agents directory: {}", e),
+                                    })
+                                    .await;
+                                return;
+                            }
 
-                self.app_state
-                    .toasts
-                    .info("Generating agent configuration...");
+                            // Save agent file
+                            let filepath = dir.join(generated.filename());
+                            let content = generated.to_markdown();
 
-                // Exit interactive mode - the description will be processed
-                false
+                            if let Err(e) = std::fs::write(&filepath, &content) {
+                                let _ = tx
+                                    .send(crate::events::ToolEvent::AgentGenerationFailed {
+                                        error: format!("Failed to save agent file: {}", e),
+                                    })
+                                    .await;
+                                return;
+                            }
+
+                            // Send success event
+                            let _ = tx
+                                .send(crate::events::ToolEvent::AgentGenerated {
+                                    name: generated.identifier.clone(),
+                                    path: filepath.display().to_string(),
+                                    location: match location_clone {
+                                        AgentLocation::Project => "project".to_string(),
+                                        AgentLocation::Global => "global".to_string(),
+                                    },
+                                })
+                                .await;
+                        }
+                        Err(e) => {
+                            let _ = tx
+                                .send(crate::events::ToolEvent::AgentGenerationFailed {
+                                    error: format!("Failed to generate agent: {}", e),
+                                })
+                                .await;
+                        }
+                    }
+                });
+
+                // Clear creation state
+                self.app_state.agent_creation_location = None;
+                self.app_state.agent_creation_mode = None;
+
+                // Stay in interactive mode - will be updated when generation completes
+                // Show a loading state in the agents panel
+                let cwd = std::env::current_dir().ok();
+                let terminal_height = self.app_state.terminal_size.1;
+                let interactive = crate::interactive::builders::build_agents_selector(
+                    cwd.as_deref(),
+                    Some(terminal_height),
+                );
+                self.app_state.enter_interactive_mode(interactive);
+                true // Stay in interactive mode showing agents list
             }
             _ => {
                 tracing::warn!("Unhandled inline form submission: {}", action_id);