few updates to output format

Author: orual

crates/pattern_cli/src/chat.rs

@@ -515,7 +515,7 @@ pub async fn setup_group(
     let constellation_tracker = Arc::new(
         pattern_core::constellation_memory::ConstellationActivityTracker::with_memory_id(
             tracker_memory_id,
-            50,
+            25,
         ),
     );
 
@@ -1176,7 +1176,7 @@ pub async fn print_group_response_event(
                     .map(|a| a.agent.name())
                     .unwrap_or("Unknown Agent".to_string());
 
-                output.info(&format!("{} reasoning:", agent_name), &text);
+                output.agent_reasoning(&agent_name, &text);
             }
         }
         GroupResponseEvent::ToolCallStarted {
@@ -1228,17 +1228,26 @@ pub async fn print_group_response_event(
             output.tool_call(&fn_name, &args_display);
         }
         GroupResponseEvent::ToolCallCompleted {
-            agent_id: _,
+            agent_id,
             call_id,
             result,
-        } => match result {
-            Ok(result) => {
-                output.tool_result(&result);
-            }
-            Err(error) => {
-                output.error(&format!("Tool error (call {}): {}", call_id, error));
+        } => {
+            // Find agent name
+            let agent_name = agents_with_membership
+                .iter()
+                .find(|a| a.agent.id() == agent_id)
+                .map(|a| a.agent.name())
+                .unwrap_or("Unknown Agent".to_string());
+            output.status(&format!("Tool result {} for {}", call_id, agent_name));
+            match result {
+                Ok(result) => {
+                    output.tool_result(&result);
+                }
+                Err(error) => {
+                    output.error(&format!("Tool error (call {}): {}", call_id, error));
+                }
             }
-        },
+        }
         GroupResponseEvent::AgentCompleted { agent_name, .. } => {
             output.status(&format!("{} completed", agent_name));
         }

crates/pattern_cli/src/output.rs

@@ -7,6 +7,7 @@ use termimad::MadSkin;
 #[derive(Clone)]
 pub struct Output {
     skin: MadSkin,
+    reasoning_skin: MadSkin,
     writer: Option<SharedWriter>,
 }
 
@@ -28,19 +29,43 @@ impl Output {
         skin.code_block.set_fg(termimad::ansi(15)); // bright white text
         // If a global SharedWriter is available (when chat has initialized
         // the readline UI), use it to avoid cursor glitches
+        let mut reasoning_skin = MadSkin::default();
+        // Keep it simple for copy-paste friendliness
+        reasoning_skin.set_headers_fg(termimad::ansi(5)); // purple
+        reasoning_skin.bold.set_fg(termimad::ansi(7)); //  light grey
+
+        // Make inline code stand out with color but no background
+        reasoning_skin.inline_code.set_fg(termimad::ansi(11)); // bright yellow
+        reasoning_skin
+            .inline_code
+            .set_bg(termimad::crossterm::style::Color::Black);
+
+        // Fix code blocks to not have background
+        reasoning_skin
+            .code_block
+            .set_bg(termimad::crossterm::style::Color::Black);
+        reasoning_skin.code_block.set_fg(termimad::ansi(7)); // bright white
+        // If a global SharedWriter is available (when chat has initialized
+        // the readline UI), use it to avoid cursor glitches
         if let Some(shared) = crate::tracing_writer::get_shared_writer() {
             Self {
                 skin,
+                reasoning_skin,
                 writer: Some(shared),
             }
         } else {
-            Self { skin, writer: None }
+            Self {
+                skin,
+                reasoning_skin,
+                writer: None,
+            }
         }
     }
 
     pub fn with_writer(self, writer: SharedWriter) -> Self {
         Self {
             skin: self.skin,
+            reasoning_skin: self.reasoning_skin,
             writer: Some(writer),
         }
     }
@@ -63,16 +88,40 @@ impl Output {
         }
     }
 
+    /// flush the buffer
+    fn flush(&self) {
+        if let Some(ref writer) = self.writer {
+            // Clone the writer to get a mutable version
+            let mut writer = writer.clone();
+            let _ = writer.flush();
+        } else {
+            use std::io::{self, Write};
+            let _ = io::stdout().flush();
+        }
+    }
+
+    /// Helper method to write output either to SharedWriter or stdout
+    fn write_line_noclear(&self, content: &str) {
+        if let Some(ref writer) = self.writer {
+            // Clone the writer to get a mutable version
+            let mut writer = writer.clone();
+            // When using SharedWriter, it handles the synchronization
+            let _ = writeln!(writer, "{}", content);
+        } else {
+            // Fallback to regular println
+            println!("{}", content);
+        }
+    }
+
     /// Print an agent message with markdown formatting
     pub fn agent_message(&self, agent_name: &str, content: &str) {
         // Clear visual separation without box drawing chars
-        self.write_line("");
-        self.write_line(&format!(
+        self.write_line_noclear("");
+        self.write_line_noclear(&format!(
             "{} {}",
             agent_name.bright_cyan().bold(),
             "says:".dimmed()
         ));
-        self.write_line("");
 
         // Use termimad to format the markdown content
         use termimad::FmtText;
@@ -81,7 +130,27 @@ impl Output {
 
         // Write each line through our write_line method
         for line in formatted_string.lines() {
-            self.write_line(line);
+            self.write_line_noclear(line);
+        }
+
+        self.write_line("");
+    }
+
+    /// Print an agent message with markdown formatting
+    pub fn agent_reasoning(&self, agent_name: &str, content: &str) {
+        self.write_line_noclear(&format!(
+            "{} reasoning:",
+            agent_name.bright_magenta().bold()
+        ));
+
+        // Use termimad to format the markdown content
+        use termimad::FmtText;
+        let formatted = FmtText::from(&self.reasoning_skin, content, Some(80));
+        let formatted_string = formatted.to_string();
+
+        // Write each line through our write_line method
+        for line in formatted_string.lines() {
+            self.write_line_noclear(line);
         }
 
         self.write_line("");
@@ -126,7 +195,7 @@ impl Output {
 
     /// Print a tool call
     pub fn tool_call(&self, tool_name: &str, args: &str) {
-        self.write_line(&format!(
+        self.write_line_noclear(&format!(
             "  {} Using tool: {}",
             ">>".bright_blue(),
             tool_name.bright_yellow()
@@ -135,30 +204,32 @@ impl Output {
             // Indent each line of the args for proper alignment
             for (i, line) in args.lines().enumerate() {
                 if i == 0 {
-                    self.write_line(&format!("     Args: {}", line).dimmed().to_string());
+                    self.write_line_noclear(&format!("     Args: {}", line).dimmed().to_string());
                 } else {
-                    self.write_line(&format!("           {}", line).dimmed().to_string());
+                    self.write_line_noclear(&format!("           {}", line).dimmed().to_string());
                 }
             }
         }
+        self.flush();
     }
 
     /// Print a tool result
     pub fn tool_result(&self, result: &str) {
         // Handle multi-line results with proper indentation
         let lines: Vec<&str> = result.lines().collect();
         if lines.len() == 1 {
-            self.write_line(&format!(
+            self.write_line_noclear(&format!(
                 "  {} Tool result: {}",
                 "=>".bright_green(),
                 result.dimmed()
             ));
         } else {
-            self.write_line(&format!("  {} Tool result:", "=>".bright_green()));
+            self.write_line_noclear(&format!("  {} Tool result:", "=>".bright_green()));
             for line in lines {
-                self.write_line(&format!("     {}", line.dimmed()));
+                self.write_line_noclear(&format!("     {}", line.dimmed()));
             }
         }
+        self.flush();
     }
 
     /// Print a "working on it" status message
@@ -196,15 +267,16 @@ impl Output {
 
         // Write each line through our write_line method
         for line in formatted_string.lines() {
-            self.write_line(line);
+            self.write_line_noclear(line);
         }
+        self.flush();
     }
 
     /// Print a table-like header
     #[allow(dead_code)]
     pub fn table_header(&self, columns: &[&str]) {
         let header = columns.join(" | ");
-        self.write_line(&format!("  {}", header.bright_white().bold()));
+        self.write_line_noclear(&format!("  {}", header.bright_white().bold()));
         self.write_line(&format!("  {}", "─".repeat(header.len()).dimmed()));
     }
 

crates/pattern_core/src/message.rs

@@ -976,11 +976,7 @@ impl Message {
                 }
                 ChatRole::User => self.content.clone(),
             },
-            MessageContent::Blocks(_) => {
-                // Blocks are preserved as-is for providers that support them
-                tracing::trace!("Preserving Blocks message with role {:?}", role);
-                self.content.clone()
-            }
+            MessageContent::Blocks(_) => self.content.clone(),
         };
 
         genai::chat::ChatMessage {
@@ -1017,16 +1013,8 @@ pub struct Request {
 }
 
 impl Request {
-    /// Validate that the request has no orphaned tool calls and proper ordering
-    pub fn validate(&mut self) -> crate::Result<()> {
-        Ok(())
-    }
-
     /// Convert this request to a genai ChatRequest
     pub fn as_chat_request(&mut self) -> crate::Result<genai::chat::ChatRequest> {
-        // Validate before converting
-        self.validate()?;
-
         // Fix assistant messages that end with thinking blocks
         for msg in &mut self.messages {
             if msg.role == ChatRole::User || msg.role == ChatRole::System {
@@ -1864,30 +1852,6 @@ impl Message {
             });
         }
 
-        // // If response was empty but had reasoning, create a text message
-        // if messages.is_empty() && response.reasoning.is_some() {
-        //     messages.push(Self {
-        //         id: MessageId::generate(),
-        //         role: ChatRole::Assistant,
-        //         content: MessageContent::Text(response.reasoning.clone().unwrap_or_default()),
-        //         metadata: MessageMetadata {
-        //             user_id: Some(agent_id.to_string()),
-        //             ..Default::default()
-        //         },
-        //         options: MessageOptions::default(),
-        //         created_at: Utc::now(),
-        //         owner_id: None,
-        //         has_tool_calls: false,
-        //         word_count: response
-        //             .reasoning
-        //             .as_ref()
-        //             .map(|r| r.split_whitespace().count() as u32)
-        //             .unwrap_or(0),
-        //         embedding: None,
-        //         embedding_model: None,
-        //     });
-        // }
-
         messages
     }
 
@@ -1943,7 +1907,7 @@ impl Message {
                         }
                     })
                     .collect::<Vec<_>>()
-                    .join(" ")
+                    .join("\n")
             }
             MessageContent::ToolCalls(calls) => {
                 // Just dump the JSON for tool calls
@@ -1958,15 +1922,15 @@ impl Message {
                         )
                     })
                     .collect::<Vec<_>>()
-                    .join(" ")
+                    .join("\n")
             }
             MessageContent::ToolResponses(responses) => {
                 // Include tool response content
                 responses
                     .iter()
                     .map(|resp| format!("[Tool Response] {}", resp.content))
                     .collect::<Vec<_>>()
-                    .join(" ")
+                    .join("\n")
             }
             MessageContent::Blocks(blocks) => {
                 // Extract text from all block types including reasoning
@@ -1996,7 +1960,7 @@ impl Message {
                         }
                     })
                     .collect::<Vec<_>>()
-                    .join(" ")
+                    .join("\n")
             }
         }
     }
@@ -2039,7 +2003,7 @@ impl Message {
     /// Rough estimation of token count for this message
     ///
     /// Uses the approximation of ~4 characters per token
-    /// Images are estimated at 1600 tokens each
+    /// Images are estimated at 1200 tokens each
     pub fn estimate_tokens(&self) -> usize {
         let text_tokens = self.display_content().len() / 4;
 
@@ -2052,7 +2016,7 @@ impl Message {
             _ => 0,
         };
 
-        text_tokens + (image_count * 1600)
+        text_tokens + (image_count * 1200)
     }
 }
 

crates/pattern_core/src/oauth/resolver.rs

@@ -3,18 +3,15 @@
 //! Provides AuthResolver and ServiceTargetResolver implementations that
 //! integrate with Pattern's OAuth token storage.
 
-use crate::db::DbEntity;
 use crate::error::CoreError;
 use crate::id::UserId;
-use crate::oauth::OAuthToken;
 use genai::ModelIden;
 use genai::ServiceTarget;
 use genai::adapter::AdapterKind;
 use genai::resolver::{AuthData, AuthResolver, Result as ResolverResult, ServiceTargetResolver};
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
-use surrealdb::RecordId;
 use surrealdb::{Connection, Surreal};
 
 /// Create an OAuth-aware auth resolver for Pattern