Replace compaction notifications with system notifications

crates/goose-cli/src/session/export.rs

@@ -369,8 +369,8 @@ pub fn message_to_markdown(message: &Message, export_all_content: bool) -> Strin
                 md.push_str("**Thinking:**\n");
                 md.push_str("> *Thinking was redacted*\n\n");
             }
-            MessageContent::ConversationCompacted(summarization) => {
-                md.push_str(&format!("*{}*\n\n", summarization.msg));
+            MessageContent::SystemNotification(notification) => {
+                md.push_str(&format!("*{}*\n\n", notification.msg));
             }
             _ => {
                 md.push_str(

crates/goose-cli/src/session/output.rs

@@ -185,8 +185,18 @@ pub fn render_message(message: &Message, debug: bool) {
                 println!("\n{}", style("Thinking:").dim().italic());
                 print_markdown("Thinking was redacted", theme);
             }
-            MessageContent::ConversationCompacted(summarization) => {
-                println!("\n{}", style(&summarization.msg).yellow());
+            MessageContent::SystemNotification(notification) => {
+                use goose::conversation::message::SystemNotificationType;
+
+                match notification.notification_type {
+                    SystemNotificationType::ThinkingMessage => {
+                        show_thinking();
+                        set_thinking_message(&notification.msg);
+                    }
+                    SystemNotificationType::InlineMessage => {
+                        println!("\n{}", style(&notification.msg).yellow());
+                    }
+                }
             }
             _ => {
                 println!("WARNING: Message content type could not be rendered");

crates/goose-server/src/openapi.rs

@@ -18,8 +18,9 @@ use goose::config::declarative_providers::{
     DeclarativeProviderConfig, LoadedProvider, ProviderEngine,
 };
 use goose::conversation::message::{
-    ConversationCompacted, FrontendToolRequest, Message, MessageContent, MessageMetadata,
-    RedactedThinkingContent, ThinkingContent, ToolConfirmationRequest, ToolRequest, ToolResponse,
+    FrontendToolRequest, Message, MessageContent, MessageMetadata, RedactedThinkingContent,
+    SystemNotificationContent, SystemNotificationType, ThinkingContent, ToolConfirmationRequest,
+    ToolRequest, ToolResponse,
 };
 
 use utoipa::openapi::schema::{
@@ -350,7 +351,6 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::agent::update_router_tool_selector,
         super::routes::reply::confirm_permission,
         super::routes::reply::reply,
-        super::routes::context::manage_context,
         super::routes::session::list_sessions,
         super::routes::session::get_session,
         super::routes::session::get_session_insights,
@@ -393,8 +393,6 @@ derive_utoipa!(Icon as IconSchema);
         super::routes::config_management::UpdateCustomProviderRequest,
         super::routes::reply::PermissionConfirmationRequest,
         super::routes::reply::ChatRequest,
-        super::routes::context::ContextManageRequest,
-        super::routes::context::ContextManageResponse,
         super::routes::session::ImportSessionRequest,
         super::routes::session::SessionListResponse,
         super::routes::session::UpdateSessionDescriptionRequest,
@@ -420,7 +418,8 @@ derive_utoipa!(Icon as IconSchema);
         RedactedThinkingContent,
         FrontendToolRequest,
         ResourceContentsSchema,
-        ConversationCompacted,
+        SystemNotificationType,
+        SystemNotificationContent,
         JsonObjectSchema,
         RoleSchema,
         ProviderMetadata,

crates/goose-server/src/routes/mod.rs

@@ -1,7 +1,6 @@
 pub mod agent;
 pub mod audio;
 pub mod config_management;
-pub mod context;
 pub mod errors;
 pub mod extension;
 pub mod recipe;
@@ -23,7 +22,6 @@ pub fn configure(state: Arc<crate::state::AppState>) -> Router {
         .merge(reply::routes(state.clone()))
         .merge(agent::routes(state.clone()))
         .merge(audio::routes(state.clone()))
-        .merge(context::routes(state.clone()))
         .merge(extension::routes(state.clone()))
         .merge(config_management::routes(state.clone()))
         .merge(recipe::routes(state.clone()))

crates/goose/src/agents/agent.rs

@@ -59,11 +59,13 @@ use super::model_selector::autopilot::AutoPilot;
 use super::platform_tools;
 use super::tool_execution::{ToolCallResult, CHAT_MODE_TOOL_SKIPPED_RESPONSE, DECLINED_RESPONSE};
 use crate::agents::subagent_task_config::TaskConfig;
-use crate::conversation::message::{Message, ToolRequest};
+use crate::conversation::message::{Message, MessageContent, SystemNotificationType, ToolRequest};
 use crate::session::extension_data::{EnabledExtensionsState, ExtensionState};
 use crate::session::SessionManager;
 
 const DEFAULT_MAX_TURNS: u32 = 1000;
+const COMPACTION_THINKING_TEXT: &str = "goose is compacting the conversation...";
+const MANUAL_COMPACT_TRIGGER: &str = "Please compact this conversation";
 
 /// Context needed for the reply function
 pub struct ReplyContext {
@@ -745,77 +747,99 @@ impl Agent {
         session: Option<SessionConfig>,
         cancel_token: Option<CancellationToken>,
     ) -> Result<BoxStream<'_, Result<AgentEvent>>> {
-        // Try to get session metadata for more accurate token counts
-        let session_metadata = if let Some(session_config) = &session {
-            SessionManager::get_session(&session_config.id, false)
-                .await
-                .ok()
-        } else {
-            None
-        };
-
-        let check_result = crate::context_mgmt::check_if_compaction_needed(
-            self,
-            &unfixed_conversation,
-            None,
-            session_metadata.as_ref(),
-        )
-        .await;
+        let is_manual_compact = unfixed_conversation.messages().last().is_some_and(|msg| {
+            msg.content.iter().any(|c| {
+                if let MessageContent::Text(text) = c {
+                    text.text.trim() == MANUAL_COMPACT_TRIGGER
+                } else {
+                    false
+                }
+            })
+        });
 
-        let (did_compact, compacted_conversation, compaction_error) = match check_result {
-            // TODO(dkatz): send a notification that we are starting compaction here.
-            Ok(true) => {
-                match crate::context_mgmt::compact_messages(self, &unfixed_conversation, false)
+        if !is_manual_compact {
+            let session_metadata = if let Some(session_config) = &session {
+                SessionManager::get_session(&session_config.id, false)
                     .await
-                {
-                    Ok((conversation, _token_counts, _summarization_usage)) => {
-                        (true, conversation, None)
-                    }
-                    Err(e) => (false, unfixed_conversation.clone(), Some(e)),
-                }
+                    .ok()
+            } else {
+                None
+            };
+
+            let needs_auto_compact = crate::context_mgmt::check_if_compaction_needed(
+                self,
+                &unfixed_conversation,
+                None,
+                session_metadata.as_ref(),
+            )
+            .await?;
+
+            if !needs_auto_compact {
+                return self
+                    .reply_internal(unfixed_conversation, session, cancel_token)
+                    .await;
             }
-            Ok(false) => (false, unfixed_conversation, None),
-            Err(e) => (false, unfixed_conversation.clone(), Some(e)),
-        };
+        }
 
-        if did_compact {
-            // Get threshold from config to include in message
-            let config = crate::config::Config::global();
-            let threshold = config
-                .get_param::<f64>("GOOSE_AUTO_COMPACT_THRESHOLD")
-                .unwrap_or(DEFAULT_COMPACTION_THRESHOLD);
-            let threshold_percentage = (threshold * 100.0) as u32;
-
-            let compaction_msg = format!(
-                "Exceeded auto-compact threshold of {}%. Context has been summarized and reduced.\n\n",
-                threshold_percentage
-            );
+        let conversation_to_compact = unfixed_conversation.clone();
+
+        Ok(Box::pin(async_stream::try_stream! {
+            if !is_manual_compact {
+                let config = crate::config::Config::global();
+                let threshold = config
+                    .get_param::<f64>("GOOSE_AUTO_COMPACT_THRESHOLD")
+                    .unwrap_or(DEFAULT_COMPACTION_THRESHOLD);
+                let threshold_percentage = (threshold * 100.0) as u32;
+
+                let inline_msg = format!(
+                    "Exceeded auto-compact threshold of {}%. Performing auto-compaction...",
+                    threshold_percentage
+                );
 
-            Ok(Box::pin(async_stream::try_stream! {
-                // TODO(Douwe): send this before we actually compact:
                 yield AgentEvent::Message(
-                    Message::assistant().with_conversation_compacted(compaction_msg)
+                    Message::assistant().with_system_notification(
+                        SystemNotificationType::InlineMessage,
+                        inline_msg,
+                    )
                 );
-                yield AgentEvent::HistoryReplaced(compacted_conversation.clone());
-                if let Some(session_to_store) = &session {
-                    SessionManager::replace_conversation(&session_to_store.id, &compacted_conversation).await?
-                }
+            }
+
+            yield AgentEvent::Message(
+                Message::assistant().with_system_notification(
+                    SystemNotificationType::ThinkingMessage,
+                    COMPACTION_THINKING_TEXT,
+                )
+            );
+
+            match crate::context_mgmt::compact_messages(self, &conversation_to_compact, false).await {
+                Ok((compacted_conversation, _token_counts, _summarization_usage)) => {
+                    if let Some(session_to_store) = &session {
+                        SessionManager::replace_conversation(&session_to_store.id, &compacted_conversation).await?;
+                    }
+
+                    yield AgentEvent::HistoryReplaced(compacted_conversation.clone());
 
-                let mut reply_stream = self.reply_internal(compacted_conversation, session, cancel_token).await?;
-                while let Some(event) = reply_stream.next().await {
-                    yield event?;
+                    yield AgentEvent::Message(
+                        Message::assistant().with_system_notification(
+                            SystemNotificationType::InlineMessage,
+                            "Compaction complete",
+                        )
+                    );
+
+                    if !is_manual_compact {
+                        let mut reply_stream = self.reply_internal(compacted_conversation, session, cancel_token).await?;
+                        while let Some(event) = reply_stream.next().await {
+                            yield event?;
+                        }
+                    }
                 }
-            }))
-        } else if let Some(error) = compaction_error {
-            Ok(Box::pin(async_stream::try_stream! {
-                yield AgentEvent::Message(Message::assistant().with_text(
-                    format!("Ran into this error trying to auto-compact: {error}.\n\nPlease try again or create a new session")
-                ));
-            }))
-        } else {
-            self.reply_internal(compacted_conversation, session, cancel_token)
-                .await
-        }
+                Err(e) => {
+                    yield AgentEvent::Message(Message::assistant().with_text(
+                        format!("Ran into this error trying to compact: {e}.\n\nPlease try again or create a new session")
+                    ));
+                }
+            }
+        }))
     }
 
     /// Main reply method that handles the actual agent processing
@@ -1138,23 +1162,29 @@ impl Agent {
                             }
                         }
                         Err(ProviderError::ContextLengthExceeded(_error_msg)) => {
-                            info!("Context length exceeded, attempting compaction");
+                            yield AgentEvent::Message(
+                                Message::assistant().with_system_notification(
+                                    SystemNotificationType::InlineMessage,
+                                    "Context limit reached. Compacting to continue conversation...",
+                                )
+                            );
+                            yield AgentEvent::Message(
+                                Message::assistant().with_system_notification(
+                                    SystemNotificationType::ThinkingMessage,
+                                    COMPACTION_THINKING_TEXT,
+                                )
+                            );
 
-                            // TODO(dkatz): send a notification that we are starting compaction here.
                             match crate::context_mgmt::compact_messages(self, &conversation, true).await {
                                 Ok((compacted_conversation, _token_counts, _usage)) => {
+                                    if let Some(session_to_store) = &session {
+                                        SessionManager::replace_conversation(&session_to_store.id, &compacted_conversation).await?
+                                    }
+
                                     conversation = compacted_conversation;
                                     did_recovery_compact_this_iteration = true;
 
-                                    yield AgentEvent::Message(
-                                        Message::assistant().with_conversation_compacted(
-                                            "Context limit reached. Conversation has been automatically compacted to continue."
-                                        )
-                                    );
                                     yield AgentEvent::HistoryReplaced(conversation.clone());
-                                    if let Some(session_to_store) = &session {
-                                        SessionManager::replace_conversation(&session_to_store.id, &conversation).await?
-                                    }
                                     continue;
                                 }
                                 Err(e) => {

crates/goose/src/context_mgmt/mod.rs

@@ -93,14 +93,6 @@ pub async fn compact_messages(
         final_token_counts.push(0);
     }
 
-    // Add the compaction marker (user_visible=true, agent_visible=false)
-    let compaction_marker = Message::assistant()
-        .with_conversation_compacted("Conversation compacted and summarized")
-        .with_metadata(MessageMetadata::user_only());
-    let compaction_marker_tokens: usize = 0; // Not counted since agent_visible=false
-    final_messages.push(compaction_marker);
-    final_token_counts.push(compaction_marker_tokens);
-
     // Add the summary message (agent_visible=true, user_visible=false)
     let summary_msg = summary_message.with_metadata(MessageMetadata::agent_only());
     // For token counting purposes, we use the output tokens (the actual summary content)
@@ -281,7 +273,9 @@ fn format_message_for_compacting(msg: &Message) -> String {
             }
             MessageContent::Thinking(thinking) => format!("thinking: {}", thinking.thinking),
             MessageContent::RedactedThinking(_) => "redacted_thinking".to_string(),
-            MessageContent::ConversationCompacted(compact) => format!("compacted: {}", compact.msg),
+            MessageContent::SystemNotification(notification) => {
+                format!("system_notification: {}", notification.msg)
+            }
         })
         .collect();