Compact tool message history responses (#357)

## Summary
- Add compact history response mode for oversized tool messages.
- Add a full single-message endpoint for lazy detail loading.
- Log compact-list and full-detail metadata for production diagnosis.

## Test Plan
- cargo fmt --all -- --check
- cargo clippy -p aionui-conversation -p aionui-app -- -D warnings
- cargo test -p aionui-conversation
t8_6_compact_mode_truncates_large_tool_content_only_for_list_response --
--nocapture
- cargo test -p aionui-app t8_2 --test message_e2e -- --nocapture
- just push -u origin feat/tool-message-compact

---------

Co-authored-by: zynx <>

Author: piorpua

crates/aionui-api-types/src/conversation.rs

@@ -77,6 +77,7 @@ pub struct ListMessagesQuery {
     pub page: Option<u32>,
     pub page_size: Option<u32>,
     pub order: Option<String>,
+    pub content_mode: Option<String>,
 }
 
 /// Body for `PATCH /api/conversations/:id/artifacts/:artifact_id`.
@@ -377,15 +378,17 @@ mod tests {
         assert!(q.page.is_none());
         assert!(q.page_size.is_none());
         assert!(q.order.is_none());
+        assert!(q.content_mode.is_none());
     }
 
     #[test]
     fn deserialize_messages_query_with_values() {
-        let raw = json!({ "page": 2, "page_size": 30, "order": "ASC" });
+        let raw = json!({ "page": 2, "page_size": 30, "order": "ASC", "content_mode": "compact" });
         let q: ListMessagesQuery = serde_json::from_value(raw).unwrap();
         assert_eq!(q.page, Some(2));
         assert_eq!(q.page_size, Some(30));
         assert_eq!(q.order.as_deref(), Some("ASC"));
+        assert_eq!(q.content_mode.as_deref(), Some("compact"));
     }
 
     // ── SearchMessagesQuery ─────────────────────────────────────────

crates/aionui-app/tests/message_e2e.rs

@@ -50,6 +50,45 @@ async fn insert_message(
         .unwrap();
 }
 
+async fn insert_acp_tool_message(
+    services: &aionui_app::AppServices,
+    conv_id: &str,
+    msg_id: &str,
+    output: &str,
+    created_at: i64,
+) {
+    let repo = aionui_db::SqliteConversationRepository::new(services.database.pool().clone());
+    let msg = aionui_db::models::MessageRow {
+        id: msg_id.into(),
+        conversation_id: conv_id.into(),
+        msg_id: Some(msg_id.into()),
+        r#type: "acp_tool_call".into(),
+        content: serde_json::json!({
+            "session_id": "session-1",
+            "update": {
+                "session_update": "tool_call",
+                "tool_call_id": msg_id,
+                "status": "completed",
+                "title": "rg",
+                "kind": "search",
+                "raw_input": { "pattern": "needle", "path": "." },
+                "content": [{
+                    "type": "content",
+                    "content": { "type": "text", "text": output }
+                }]
+            }
+        })
+        .to_string(),
+        position: Some("left".into()),
+        status: Some("finish".into()),
+        hidden: false,
+        created_at,
+    };
+    aionui_db::IConversationRepository::insert_message(&repo, &msg)
+        .await
+        .unwrap();
+}
+
 async fn upsert_artifact(services: &aionui_app::AppServices, artifact: aionui_db::ConversationArtifactRow) {
     let repo = aionui_db::SqliteConversationRepository::new(services.database.pool().clone());
     aionui_db::IConversationRepository::upsert_artifact(&repo, &artifact)
@@ -123,6 +162,132 @@ async fn t8_2_messages_pagination() {
     assert_eq!(json["data"]["has_more"], false);
 }
 
+#[tokio::test]
+async fn t8_2b_messages_compact_mode_truncates_large_tool_payload() {
+    let (mut app, services) = build_app().await;
+    let (token, csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await;
+    let conv_id = create_conversation(&mut app, &token, &csrf, "Compact Tool Conv").await;
+    let large_output = "match line\n".repeat(10_000);
+
+    insert_acp_tool_message(&services, &conv_id, "tool-big", &large_output, 1000).await;
+
+    let resp = app
+        .clone()
+        .oneshot(get_with_token(
+            &format!("/api/conversations/{conv_id}/messages?content_mode=compact"),
+            &token,
+        ))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::OK);
+    let json = body_json(resp).await;
+    let content = &json["data"]["items"][0]["content"];
+    let preview = content["update"]["content"][0]["content"]["text"].as_str().unwrap();
+
+    assert_eq!(content["_compact"]["truncated"], true);
+    assert!(preview.len() < large_output.len());
+    assert!(!preview.contains(&large_output));
+}
+
+#[tokio::test]
+async fn t8_2c_get_message_returns_full_tool_payload() {
+    let (mut app, services) = build_app().await;
+    let (token, csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await;
+    let conv_id = create_conversation(&mut app, &token, &csrf, "Tool Detail Conv").await;
+    let large_output = "wide rg output\n".repeat(10_000);
+
+    insert_acp_tool_message(&services, &conv_id, "tool-detail", &large_output, 1000).await;
+
+    let resp = app
+        .clone()
+        .oneshot(get_with_token(
+            &format!("/api/conversations/{conv_id}/messages/tool-detail"),
+            &token,
+        ))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::OK);
+    let json = body_json(resp).await;
+
+    assert_eq!(
+        json["data"]["content"]["update"]["content"][0]["content"]["text"]
+            .as_str()
+            .unwrap(),
+        large_output
+    );
+}
+
+#[tokio::test]
+async fn t8_2d_get_message_requires_auth() {
+    let (mut app, services) = build_app().await;
+    let (token, csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await;
+    let conv_id = create_conversation(&mut app, &token, &csrf, "Tool Detail Auth Conv").await;
+
+    let resp = app
+        .oneshot(get_request(&format!(
+            "/api/conversations/{conv_id}/messages/tool-detail"
+        )))
+        .await
+        .unwrap();
+
+    assert_eq!(resp.status(), StatusCode::FORBIDDEN);
+}
+
+#[tokio::test]
+async fn t8_2e_get_message_not_found_returns_specific_error() {
+    let (mut app, services) = build_app().await;
+    let (token, csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await;
+    let conv_id = create_conversation(&mut app, &token, &csrf, "Tool Detail Missing Conv").await;
+
+    let resp = app
+        .oneshot(get_with_token(
+            &format!("/api/conversations/{conv_id}/messages/missing-message"),
+            &token,
+        ))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    let json = body_json(resp).await;
+
+    assert_eq!(json["code"], "NOT_FOUND");
+    assert!(
+        json["error"]
+            .as_str()
+            .unwrap()
+            .contains("Message missing-message not found")
+    );
+}
+
+#[tokio::test]
+async fn t8_2f_get_message_does_not_leak_cross_user_conversation() {
+    let (mut app, services) = build_app().await;
+    let (owner_token, owner_csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await;
+    let owner_conv_id = create_conversation(&mut app, &owner_token, &owner_csrf, "Owner Tool Conv").await;
+    insert_acp_tool_message(&services, &owner_conv_id, "owner-tool", "private output", 1000).await;
+
+    let (other_token, _other_csrf) = setup_and_login(&mut app, &services, "other-user", "StrongP@ss2").await;
+
+    let resp = app
+        .oneshot(get_with_token(
+            &format!("/api/conversations/{owner_conv_id}/messages/owner-tool"),
+            &other_token,
+        ))
+        .await
+        .unwrap();
+    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+    let json = body_json(resp).await;
+
+    assert_eq!(json["code"], "NOT_FOUND");
+    assert!(
+        json["error"]
+            .as_str()
+            .unwrap()
+            .contains(&format!("Conversation {owner_conv_id} not found"))
+    );
+    assert!(!json["error"].as_str().unwrap().contains("owner-tool"));
+    assert!(!json["error"].as_str().unwrap().contains("private output"));
+}
+
 #[tokio::test]
 async fn t8_3_messages_order_asc_default() {
     let (mut app, services) = build_app().await;

crates/aionui-conversation/src/convert.rs

@@ -8,6 +8,9 @@ use aionui_common::{
 use aionui_db::MessageSearchRow;
 use aionui_db::models::{ConversationArtifactRow, ConversationRow, MessageRow};
 
+pub(crate) const TOOL_CONTENT_COMPACT_THRESHOLD_BYTES: usize = 64 * 1024;
+const TOOL_CONTENT_PREVIEW_CHARS: usize = 4096;
+
 /// Convert a database row into an API response DTO.
 ///
 /// Parses string enum fields and JSON text fields back into typed values.
@@ -151,6 +154,58 @@ pub fn row_to_message_response(row: MessageRow) -> Result<MessageResponse, AppEr
     })
 }
 
+/// Convert a message row for history-list use, compacting oversized tool payloads.
+pub fn row_to_message_response_compact(row: MessageRow) -> Result<MessageResponse, AppError> {
+    let original_size = row.content.len();
+    let mut response = row_to_message_response(row)?;
+    if !is_tool_message(response.r#type) || original_size <= TOOL_CONTENT_COMPACT_THRESHOLD_BYTES {
+        return Ok(response);
+    }
+
+    let mut truncated = false;
+    truncate_large_strings(&mut response.content, TOOL_CONTENT_PREVIEW_CHARS, &mut truncated);
+    if truncated && let Some(obj) = response.content.as_object_mut() {
+        obj.insert(
+            "_compact".to_string(),
+            serde_json::json!({
+                "truncated": true,
+                "original_size": original_size,
+                "preview_chars": TOOL_CONTENT_PREVIEW_CHARS
+            }),
+        );
+    }
+
+    Ok(response)
+}
+
+fn is_tool_message(msg_type: MessageType) -> bool {
+    matches!(
+        msg_type,
+        MessageType::ToolCall | MessageType::ToolGroup | MessageType::AcpToolCall
+    )
+}
+
+fn truncate_large_strings(value: &mut serde_json::Value, max_chars: usize, truncated: &mut bool) {
+    match value {
+        serde_json::Value::String(text) if text.chars().count() > max_chars => {
+            let preview: String = text.chars().take(max_chars).collect();
+            *text = format!("{preview}\n...[truncated]");
+            *truncated = true;
+        }
+        serde_json::Value::Array(items) => {
+            for item in items {
+                truncate_large_strings(item, max_chars, truncated);
+            }
+        }
+        serde_json::Value::Object(map) => {
+            for entry in map.values_mut() {
+                truncate_large_strings(entry, max_chars, truncated);
+            }
+        }
+        _ => {}
+    }
+}
+
 /// Convert an artifact database row into an API response DTO.
 pub fn row_to_artifact_response(row: ConversationArtifactRow) -> Result<ConversationArtifactResponse, AppError> {
     let kind = string_to_enum(&row.kind)?;

crates/aionui-conversation/src/routes.rs

@@ -8,8 +8,8 @@ use aionui_api_types::{
     ActiveCountResponse, ApiResponse, ApprovalCheckQuery, ApprovalCheckResponse, CloneConversationRequest,
     ConfirmRequest, ConfirmationListResponse, ConversationArtifactListResponse, ConversationArtifactResponse,
     ConversationListResponse, ConversationResponse, CreateConversationRequest, ListConversationsQuery,
-    ListMessagesQuery, MessageListResponse, MessageSearchResponse, SearchMessagesQuery, SendMessageRequest,
-    SendMessageResponse, UpdateConversationArtifactRequest, UpdateConversationRequest,
+    ListMessagesQuery, MessageListResponse, MessageResponse, MessageSearchResponse, SearchMessagesQuery,
+    SendMessageRequest, SendMessageResponse, UpdateConversationArtifactRequest, UpdateConversationRequest,
 };
 use aionui_auth::CurrentUser;
 use aionui_common::AppError;
@@ -26,6 +26,7 @@ pub fn conversation_routes(state: ConversationRouterState) -> Router {
         .route("/api/conversations/{id}/reset", post(reset))
         .route("/api/conversations/{id}/associated", get(associated))
         .route("/api/conversations/{id}/messages", get(list_msg).post(send_msg))
+        .route("/api/conversations/{id}/messages/{messageId}", get(get_msg))
         .route("/api/conversations/{id}/artifacts", get(list_artifacts))
         .route("/api/conversations/{id}/artifacts/{artifactId}", patch(update_artifact))
         .route("/api/conversations/{id}/cancel", post(cancel))
@@ -128,6 +129,25 @@ async fn list_msg(
     Ok(Json(ApiResponse::ok(result)))
 }
 
+#[derive(serde::Deserialize)]
+struct MessagePathParams {
+    id: String,
+    #[serde(rename = "messageId")]
+    message_id: String,
+}
+
+async fn get_msg(
+    State(state): State<ConversationRouterState>,
+    Extension(user): Extension<CurrentUser>,
+    Path(params): Path<MessagePathParams>,
+) -> Result<Json<ApiResponse<MessageResponse>>, AppError> {
+    let result = state
+        .service
+        .get_message(&user.id, &params.id, &params.message_id)
+        .await?;
+    Ok(Json(ApiResponse::ok(result)))
+}
+
 async fn send_msg(
     State(state): State<ConversationRouterState>,
     Extension(user): Extension<CurrentUser>,