cleaned up presentation

src/cli.rs

@@ -67,6 +67,7 @@ impl ChatCLI {
                         if let Err(e) = self.handle_user_message(line).await {
                             self.display.print_error(&format!("Error: {}", e));
                         }
+                        println!(); // Add padding before next prompt
                     }
                 }
                 None => {
@@ -91,6 +92,8 @@ impl ChatCLI {
         let enable_web_search = self.session.enable_web_search;
         let enable_reasoning_summary = self.session.enable_reasoning_summary;
         let reasoning_effort = self.session.reasoning_effort.clone();
+        let enable_extended_thinking = self.session.enable_extended_thinking;
+        let thinking_budget_tokens = self.session.thinking_budget_tokens;
         
         // Check if we should use streaming before getting client
         let should_use_streaming = {
@@ -99,7 +102,8 @@ impl ChatCLI {
         };
         
         if should_use_streaming {
-            print!("{} ", console::style("🤖").magenta());
+            println!(); // Add padding before AI response
+            print!("{}> ", console::style("🤖").magenta());
             use std::io::{self, Write};
             io::stdout().flush().ok();
             
@@ -121,6 +125,8 @@ impl ChatCLI {
                     enable_web_search,
                     enable_reasoning_summary,
                     &reasoning_effort,
+                    enable_extended_thinking,
+                    thinking_budget_tokens,
                     stream_callback,
                 )
                 .await
@@ -148,6 +154,8 @@ impl ChatCLI {
                     enable_web_search,
                     enable_reasoning_summary,
                     &reasoning_effort,
+                    enable_extended_thinking,
+                    thinking_budget_tokens,
                 )
                 .await
             {
@@ -379,15 +387,17 @@ impl ChatCLI {
             
             let web_status = if self.session.enable_web_search { "✓ enabled" } else { "✗ disabled" };
             let reasoning_status = if self.session.enable_reasoning_summary { "✓ enabled" } else { "✗ disabled" };
+            let extended_thinking_status = if self.session.enable_extended_thinking { "✓ enabled" } else { "✗ disabled" };
             
             println!("  Web Search: {}", web_status);
             println!("  Reasoning Summaries: {}", reasoning_status);
             println!("  Reasoning Effort: {}", self.session.reasoning_effort);
+            println!("  Extended Thinking: {}", extended_thinking_status);
+            println!("  Thinking Budget: {} tokens", self.session.thinking_budget_tokens);
             
             // Check model compatibility
             let model = self.session.model.clone();
             let provider = get_provider_for_model(&model);
-            let web_enabled = self.session.enable_web_search;
             let reasoning_enabled = self.session.enable_reasoning_summary;
             
             // Show compatibility warnings based on provider
@@ -396,10 +406,16 @@ impl ChatCLI {
                     if reasoning_enabled {
                         self.display.print_warning("Reasoning summaries are not supported by Anthropic models");
                     }
+                    if self.session.enable_extended_thinking {
+                        // Extended thinking is supported by Anthropic models
+                    }
                     // Web search is now supported by Anthropic models
                 }
                 crate::core::provider::Provider::OpenAI => {
-                    // OpenAI models generally support these features
+                    if self.session.enable_extended_thinking {
+                        self.display.print_warning("Extended thinking is not supported by OpenAI models");
+                    }
+                    // OpenAI models generally support other features
                 }
             }
             
@@ -408,6 +424,8 @@ impl ChatCLI {
                 "Toggle Web Search",
                 "Toggle Reasoning Summaries", 
                 "Set Reasoning Effort",
+                "Toggle Extended Thinking",
+                "Set Thinking Budget",
                 "Done"
             ];
             
@@ -443,6 +461,47 @@ impl ChatCLI {
                         }
                     }
                 }
+                Some("Toggle Extended Thinking") => {
+                    self.session.enable_extended_thinking = !self.session.enable_extended_thinking;
+                    let state = if self.session.enable_extended_thinking { "enabled" } else { "disabled" };
+                    self.display.print_command_result(&format!("Extended thinking {}", state));
+                    
+                    let provider = get_provider_for_model(&self.session.model);
+                    match provider {
+                        crate::core::provider::Provider::OpenAI => {
+                            self.display.print_warning("Extended thinking is not supported by OpenAI models");
+                        }
+                        crate::core::provider::Provider::Anthropic => {
+                            // Supported
+                        }
+                    }
+                }
+                Some("Set Thinking Budget") => {
+                    let budget_options = vec!["1024", "2500", "5000", "10000", "16000"];
+                    let current_budget = self.session.thinking_budget_tokens.to_string();
+                    if let Some(budget_str) = self.input.select_from_list(
+                        "Select thinking budget (tokens):",
+                        &budget_options,
+                        Some(&current_budget),
+                    )? {
+                        if let Ok(budget) = budget_str.parse::<u32>() {
+                            self.session.thinking_budget_tokens = budget;
+                            self.display.print_command_result(&format!("Thinking budget set to {} tokens", budget));
+                            
+                            let provider = get_provider_for_model(&self.session.model);
+                            match provider {
+                                crate::core::provider::Provider::OpenAI => {
+                                    self.display.print_warning("Extended thinking is not supported by OpenAI models");
+                                }
+                                crate::core::provider::Provider::Anthropic => {
+                                    if budget < 1024 {
+                                        self.display.print_warning("Minimum thinking budget is 1024 tokens for Anthropic models");
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
                 Some("Done") | None => {
                     break;
                 }