feat: implement cloud synthesis functionality and enhance agent status handling

Author: gitcoder89431

crates/agentic-core/src/cloud.rs

@@ -0,0 +1,80 @@
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+#[derive(Serialize)]
+struct OpenRouterRequest {
+    model: String,
+    messages: Vec<ChatMessage>,
+    max_tokens: u32,
+}
+
+#[derive(Serialize)]
+struct ChatMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Deserialize)]
+struct OpenRouterResponse {
+    choices: Vec<Choice>,
+}
+
+#[derive(Deserialize)]
+struct Choice {
+    message: Message,
+}
+
+#[derive(Deserialize)]
+struct Message {
+    content: String,
+}
+
+pub async fn call_cloud_model(
+    api_key: &str,
+    model: &str,
+    prompt: &str,
+) -> Result<String, anyhow::Error> {
+    let client = Client::builder().timeout(Duration::from_secs(30)).build()?;
+
+    // Optimize prompt for concise responses
+    let optimized_prompt = format!(
+        "Please provide a concise, well-structured response to this inquiry. Keep it informative but focused:\n\n{}",
+        prompt
+    );
+
+    let request_body = OpenRouterRequest {
+        model: model.to_string(),
+        messages: vec![ChatMessage {
+            role: "user".to_string(),
+            content: optimized_prompt,
+        }],
+        max_tokens: 1024, // Reduced from 2048 for more concise responses
+    };
+
+    let response = client
+        .post("https://openrouter.ai/api/v1/chat/completions")
+        .header("Authorization", format!("Bearer {}", api_key))
+        .header("Content-Type", "application/json")
+        .json(&request_body)
+        .send()
+        .await?;
+
+    if !response.status().is_success() {
+        let status = response.status();
+        let error_text = response.text().await.unwrap_or_default();
+        return Err(anyhow::anyhow!(
+            "OpenRouter API error {}: {}",
+            status,
+            error_text
+        ));
+    }
+
+    let openrouter_response: OpenRouterResponse = response.json().await?;
+
+    if let Some(choice) = openrouter_response.choices.first() {
+        Ok(choice.message.content.clone())
+    } else {
+        Err(anyhow::anyhow!("No response choices from OpenRouter API"))
+    }
+}

crates/agentic-core/src/lib.rs

@@ -10,6 +10,7 @@
 //! - `settings`: Application configuration management
 //! - `theme`: UI theming system
 
+pub mod cloud;
 pub mod models;
 pub mod orchestrator;
 pub mod settings;

crates/agentic-tui/src/ui/app.rs

@@ -6,6 +6,7 @@ use super::{
     settings_modal::render_settings_modal,
 };
 use agentic_core::{
+    cloud,
     models::{ModelValidator, OllamaModel, OpenRouterModel},
     orchestrator,
     settings::{Settings, ValidationError},
@@ -49,6 +50,8 @@ pub enum AgentStatus {
     LocalEndpointError,
     CloudEndpointError,
     Orchestrating,
+    Searching,
+    Complete,
 }
 
 #[derive(Debug)]
@@ -63,6 +66,7 @@ pub enum ValidationMessage {
 pub enum AgentMessage {
     ProposalsGenerated(Result<Vec<String>, anyhow::Error>),
     RevisedProposalGenerated(Result<String, anyhow::Error>),
+    CloudSynthesisComplete(Result<String, anyhow::Error>),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -119,6 +123,8 @@ pub struct App {
     proposals: Vec<String>,
     current_proposal_index: usize,
     final_prompt: String,
+    cloud_response: String,
+    synthesis_scroll: u16,
 }
 
 impl App {
@@ -144,6 +150,8 @@ impl App {
             proposals: Vec::new(),
             current_proposal_index: 0,
             final_prompt: String::new(),
+            cloud_response: String::new(),
+            synthesis_scroll: 0,
         }
     }
 
@@ -202,7 +210,7 @@ impl App {
                 // Clean up the proposal text - remove template artifacts
                 let proposal_text = proposal
                     .replace("Context statement: ", "")
-                    .replace("Another context: ", "")  
+                    .replace("Another context: ", "")
                     .replace("Third context: ", "")
                     .replace("Context statement - ", "")
                     .replace("Another context - ", "")
@@ -226,8 +234,7 @@ impl App {
 
         let proposals_paragraph = Paragraph::new(proposal_lines)
             .style(self.theme.ratatui_style(Element::Text))
-            .wrap(Wrap { trim: true })
-            .scroll((self.current_proposal_index as u16 * 3, 0)); // Scroll to selected proposal
+            .wrap(Wrap { trim: true });
 
         frame.render_widget(proposals_paragraph, chunks[1]);
 
@@ -241,11 +248,7 @@ impl App {
     }
 
     fn render_coaching_tip_modal(&self, frame: &mut ratatui::Frame, area: Rect) {
-        use ratatui::{
-            prelude::Alignment,
-            text::{Line, Span},
-            widgets::Paragraph,
-        };
+        use ratatui::{prelude::Alignment, text::Line, widgets::Paragraph};
 
         let block = Block::default()
             .title(" Coaching Tip ")
@@ -267,8 +270,9 @@ impl App {
         // Main coaching message with tips
         let message_text = vec![
             Line::from(""),
-            Line::from("Ruixen is having a tough time with this abstract query. Smaller"),
-            Line::from("local models work best with clear and concrete questions."),
+            Line::from("Ruixen is having a tough time with this abstract query."),
+            Line::from(""),
+            Line::from(":: Smaller local models work best with clear and concrete questions."),
             Line::from(""),
             Line::from(":: Try a more direct question, add specific context, or break"),
             Line::from("   the query down into smaller steps."),
@@ -463,10 +467,13 @@ impl App {
                 frame.render_widget(Clear, modal_area);
                 self.render_coaching_tip_modal(frame, modal_area);
             } else if self.mode == AppMode::Complete {
-                let block = Block::default().title("Final Prompt").borders(Borders::ALL);
-                let paragraph = Paragraph::new(self.final_prompt.as_str())
+                let block = Block::default()
+                    .title("Synthesis Complete")
+                    .borders(Borders::ALL);
+                let paragraph = Paragraph::new(self.cloud_response.as_str())
                     .block(block)
-                    .wrap(Wrap { trim: true });
+                    .wrap(Wrap { trim: true })
+                    .scroll((self.synthesis_scroll, 0));
                 frame.render_widget(paragraph, app_chunks[1]);
             } else {
                 render_chat(
@@ -600,6 +607,16 @@ impl App {
                 // TODO: Set error state and display to user
                 self.agent_status = AgentStatus::Ready;
             }
+            AgentMessage::CloudSynthesisComplete(Ok(response)) => {
+                self.cloud_response = response;
+                self.mode = AppMode::Complete;
+                self.agent_status = AgentStatus::Complete;
+            }
+            AgentMessage::CloudSynthesisComplete(Err(_e)) => {
+                // Show coaching tip for cloud API failures
+                self.mode = AppMode::CoachingTip;
+                self.agent_status = AgentStatus::Ready;
+            }
         }
     }
 
@@ -841,12 +858,12 @@ impl App {
                                 }
                             }
                             KeyCode::Enter => {
-                                // Synthesize - use selected proposal
+                                // Synthesize - send proposal to cloud for synthesis
                                 if let Some(proposal) =
                                     self.proposals.get(self.current_proposal_index)
                                 {
                                     self.final_prompt = proposal.clone();
-                                    self.mode = AppMode::Complete;
+                                    self.handle_cloud_synthesis();
                                 }
                             }
                             KeyCode::Char('e') => {
@@ -879,11 +896,20 @@ impl App {
                             _ => {}
                         },
                         AppMode::Complete => match key.code {
+                            KeyCode::Up => {
+                                self.synthesis_scroll = self.synthesis_scroll.saturating_sub(1);
+                            }
+                            KeyCode::Down => {
+                                self.synthesis_scroll = self.synthesis_scroll.saturating_add(1);
+                            }
                             KeyCode::Enter | KeyCode::Esc => {
                                 self.mode = AppMode::Normal;
                                 self.final_prompt.clear();
                                 self.proposals.clear();
                                 self.current_proposal_index = 0;
+                                self.cloud_response.clear();
+                                self.synthesis_scroll = 0;
+                                self.agent_status = AgentStatus::Ready;
                             }
                             _ => {}
                         },
@@ -947,6 +973,21 @@ impl App {
         self.edit_buffer.clear();
     }
 
+    fn handle_cloud_synthesis(&mut self) {
+        // Set status to searching and trigger cloud API call
+        self.agent_status = AgentStatus::Searching;
+
+        let prompt = self.final_prompt.clone();
+        let api_key = self.settings.api_key.clone();
+        let model = self.settings.cloud_model.clone();
+        let tx = self.agent_tx.clone();
+
+        tokio::spawn(async move {
+            let result = cloud::call_cloud_model(&api_key, &model, &prompt).await;
+            let _ = tx.send(AgentMessage::CloudSynthesisComplete(result));
+        });
+    }
+
     fn handle_slash_command(&mut self, command: &str) {
         match command {
             "/setting" | "/settings" => {

crates/agentic-tui/src/ui/header.rs

@@ -103,6 +103,12 @@ fn build_smart_status_with_color(status: AgentStatus, settings: &Settings) -> (S
         AgentStatus::Orchestrating => {
             format!("Ruixen :: [ORCHESTRATING] :: {}", cloud_display)
         }
+        AgentStatus::Searching => {
+            format!("Ruixen :: ☁️🔍 :: [SEARCHING] :: {}", cloud_display)
+        }
+        AgentStatus::Complete => {
+            format!("Ruixen :: ✨ :: [SYNTHESIS COMPLETE] :: {}", cloud_display)
+        }
     };
 
     let color = match status {
@@ -117,6 +123,8 @@ fn build_smart_status_with_color(status: AgentStatus, settings: &Settings) -> (S
         }
         AgentStatus::ValidatingLocal | AgentStatus::ValidatingCloud => Color::Yellow, // Testing in progress
         AgentStatus::Orchestrating => Color::Cyan,
+        AgentStatus::Searching => Color::Blue, // Cloud synthesis in progress
+        AgentStatus::Complete => Color::Green, // Success!
         AgentStatus::LocalEndpointError | AgentStatus::CloudEndpointError => Color::Red, // Connection failed
         _ => Color::Red, // Other validation failed
     };