Add agent registration to main event loop and update API state

- Introduced a new channel for registering newly created agents in the main event loop, enhancing the agent management system.
- Updated the `ApiState` structure to include a sender for agent registration, allowing agents to be sent from the API to the main loop.
- Modified the `create_agent` function to send newly created agents to the main loop, improving the integration of agent lifecycle management.

Author: jamiepine

src/api/server.rs

@@ -899,11 +899,25 @@ async fn create_agent(
         );
     }
 
+    // Build the Agent and send to main loop so it can receive messages
+    let sqlite_pool = db.sqlite.clone();
+    let mut deps_with_cron = deps.clone();
+    deps_with_cron.cron_tool = Some(cron_tool);
+    let agent = crate::Agent {
+        id: arc_agent_id.clone(),
+        config: agent_config.clone(),
+        db,
+        deps: deps_with_cron,
+    };
+    if let Err(error) = state.agent_tx.send(agent).await {
+        tracing::error!(%error, "failed to send new agent to main loop");
+    }
+
     // Update all ArcSwap-based API state maps
     {
         // Agent pools
         let mut pools = (**state.agent_pools.load()).clone();
-        pools.insert(agent_id.clone(), db.sqlite.clone());
+        pools.insert(agent_id.clone(), sqlite_pool);
         state.agent_pools.store(std::sync::Arc::new(pools));
 
         // Memory searches

src/api/state.rs

@@ -82,6 +82,8 @@ pub struct ApiState {
     pub prompt_engine: RwLock<Option<PromptEngine>>,
     /// Instance-level defaults for resolving new agent configs.
     pub defaults_config: RwLock<Option<DefaultsConfig>>,
+    /// Sender to register newly created agents with the main event loop.
+    pub agent_tx: mpsc::Sender<crate::Agent>,
 }
 
 /// Events sent to SSE clients. Wraps ProcessEvents with agent context.
@@ -163,7 +165,10 @@ pub enum ApiEvent {
 }
 
 impl ApiState {
-    pub fn new_with_provider_sender(provider_setup_tx: mpsc::Sender<crate::ProviderSetupEvent>) -> Self {
+    pub fn new_with_provider_sender(
+        provider_setup_tx: mpsc::Sender<crate::ProviderSetupEvent>,
+        agent_tx: mpsc::Sender<crate::Agent>,
+    ) -> Self {
         let (event_tx, _) = broadcast::channel(512);
         Self {
             started_at: Instant::now(),
@@ -190,6 +195,7 @@ impl ApiState {
             embedding_model: RwLock::new(None),
             prompt_engine: RwLock::new(None),
             defaults_config: RwLock::new(None),
+            agent_tx,
         }
     }
 

src/main.rs

@@ -478,9 +478,11 @@ async fn run(
 
     // Create the provider setup channel so API handlers can signal the main loop
     let (provider_tx, mut provider_rx) = mpsc::channel::<spacebot::ProviderSetupEvent>(1);
+    // Channel for newly created agents to be registered in the main event loop
+    let (agent_tx, mut agent_rx) = mpsc::channel::<spacebot::Agent>(8);
 
     // Start HTTP API server if enabled
-    let api_state = Arc::new(spacebot::api::ApiState::new_with_provider_sender(provider_tx));
+    let api_state = Arc::new(spacebot::api::ApiState::new_with_provider_sender(provider_tx, agent_tx));
 
     // Start background update checker
     spacebot::update::spawn_update_checker(api_state.update_status.clone());
@@ -842,6 +844,10 @@ async fn run(
                     }
                 }
             }
+            Some(agent) = agent_rx.recv() => {
+                tracing::info!(agent_id = %agent.id, "registering new agent in main loop");
+                agents.insert(agent.id.clone(), agent);
+            }
             Some(_event) = provider_rx.recv(), if !agents_initialized => {
                 tracing::info!("provider keys configured, initializing agents");