chore: use a Conversation type (#3735)

crates/goose-server/src/openapi.rs

@@ -3,10 +3,6 @@ use goose::agents::extension::ToolInfo;
 use goose::agents::ExtensionConfig;
 use goose::config::permission::PermissionLevel;
 use goose::config::ExtensionEntry;
-use goose::message::{
-    ContextLengthExceeded, FrontendToolRequest, Message, MessageContent, RedactedThinkingContent,
-    SummarizationRequested, ThinkingContent, ToolConfirmationRequest, ToolRequest, ToolResponse,
-};
 use goose::permission::permission_confirmation::PrincipalType;
 use goose::providers::base::{ConfigKey, ModelInfo, ProviderMetadata};
 use goose::session::info::SessionInfo;
@@ -17,6 +13,10 @@ use rmcp::model::{
 };
 use utoipa::{OpenApi, ToSchema};
 
+use goose::conversation::message::{
+    ContextLengthExceeded, FrontendToolRequest, Message, MessageContent, RedactedThinkingContent,
+    SummarizationRequested, ThinkingContent, ToolConfirmationRequest, ToolRequest, ToolResponse,
+};
 use utoipa::openapi::schema::{
     AdditionalProperties, AnyOfBuilder, ArrayBuilder, ObjectBuilder, OneOfBuilder, Schema,
     SchemaFormat, SchemaType,

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

@@ -6,7 +6,7 @@ use axum::{
     routing::post,
     Json, Router,
 };
-use goose::message::Message;
+use goose::conversation::{message::Message, Conversation};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 use utoipa::ToSchema;
@@ -58,7 +58,7 @@ async fn manage_context(
         .await
         .map_err(|_| StatusCode::PRECONDITION_FAILED)?;
 
-    let mut processed_messages: Vec<Message> = vec![];
+    let mut processed_messages = Conversation::new_unvalidated(vec![]);
     let mut token_counts: Vec<usize> = vec![];
 
     if request.manage_action == "truncation" {
@@ -74,7 +74,7 @@ async fn manage_context(
     }
 
     Ok(Json(ContextManageResponse {
-        messages: processed_messages,
+        messages: processed_messages.messages().clone(),
         token_counts,
     }))
 }

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

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use axum::{extract::State, http::StatusCode, routing::post, Json, Router};
-use goose::message::Message;
+use goose::conversation::{message::Message, Conversation};
 use goose::recipe::Recipe;
 use goose::recipe_deeplink;
 use serde::{Deserialize, Serialize};
@@ -83,7 +83,9 @@ async fn create_recipe(
         .map_err(|_| (StatusCode::PRECONDITION_FAILED, Json(error_response)))?;
 
     // Create base recipe from agent state and messages
-    let recipe_result = agent.create_recipe(request.messages).await;
+    let recipe_result = agent
+        .create_recipe(Conversation::new_unvalidated(request.messages))
+        .await;
 
     match recipe_result {
         Ok(mut recipe) => {

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

@@ -9,9 +9,10 @@ use axum::{
 };
 use bytes::Bytes;
 use futures::{stream::StreamExt, Stream};
+use goose::conversation::message::{Message, MessageContent};
+use goose::conversation::Conversation;
 use goose::{
     agents::{AgentEvent, SessionConfig},
-    message::{push_message, Message, MessageContent},
     permission::permission_confirmation::PrincipalType,
 };
 use goose::{
@@ -186,7 +187,7 @@ async fn reply_handler(
     let stream = ReceiverStream::new(rx);
     let cancel_token = CancellationToken::new();
 
-    let messages = request.messages;
+    let messages = Conversation::new_unvalidated(request.messages);
     let session_working_dir = request.session_working_dir.clone();
 
     let session_id = request
@@ -221,12 +222,9 @@ async fn reply_handler(
             retry_config: None,
         };
 
-        // Messages will be auto-compacted in agent.reply() if needed
-        let messages_to_process = messages.clone();
-
         let mut stream = match agent
             .reply(
-                &messages_to_process,
+                messages.clone(),
                 Some(session_config),
                 Some(task_cancel.clone()),
             )
@@ -279,15 +277,15 @@ async fn reply_handler(
                     match response {
                         Ok(Some(Ok(AgentEvent::Message(message)))) => {
                             for content in &message.content {
-                                            track_tool_telemetry(content, &all_messages);
-                                        }
+                                track_tool_telemetry(content, all_messages.messages());
+                            }
 
-                                        push_message(&mut all_messages, message.clone());
-                                        stream_event(MessageEvent::Message { message }, &tx, &cancel_token).await;
+                            all_messages.push(message.clone());
+                            stream_event(MessageEvent::Message { message }, &tx, &cancel_token).await;
                         }
                         Ok(Some(Ok(AgentEvent::HistoryReplaced(new_messages)))) => {
                             // Replace the message history with the compacted messages
-                            all_messages = new_messages;
+                            all_messages = Conversation::new_unvalidated(new_messages);
                             // Note: We don't send this as a stream event since it's an internal operation
                             // The client will see the compaction notification message that was sent before this event
                         }
@@ -518,6 +516,7 @@ pub fn routes(state: Arc<AppState>) -> Router {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use goose::conversation::message::Message;
     use goose::{
         agents::Agent,
         model::ModelConfig,
@@ -558,6 +557,7 @@ mod tests {
     mod integration_tests {
         use super::*;
         use axum::{body::Body, http::Request};
+        use goose::conversation::message::Message;
         use std::sync::Arc;
         use tower::ServiceExt;
 

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

@@ -10,7 +10,7 @@ use axum::{
     routing::{get, put},
     Json, Router,
 };
-use goose::message::Message;
+use goose::conversation::message::Message;
 use goose::session;
 use goose::session::info::{get_valid_sorted_sessions, SessionInfo, SortOrder};
 use goose::session::SessionMetadata;
@@ -137,7 +137,7 @@ async fn get_session_history(
     Ok(Json(SessionHistoryResponse {
         session_id,
         metadata,
-        messages,
+        messages: messages.messages().clone(),
     }))
 }