fix: account for queued subagent content in compaction

Co-Authored-By: Anda Bot <noreply@anda.bot>

Author: zensh

anda_core/src/model.rs

@@ -496,6 +496,40 @@ impl ContentPart {
             Err(Box::new(self))
         }
     }
+
+    /// Estimates the number of tokens in this content part for usage accounting and pruning.
+    pub fn estimated_tokens(&self) -> usize {
+        match self {
+            ContentPart::Text { text } | ContentPart::Reasoning { text } => estimate_tokens(text),
+            ContentPart::FileData {
+                file_uri,
+                mime_type,
+            } => estimate_tokens(file_uri)
+                .saturating_add(mime_type.as_deref().map_or(0, estimate_tokens)),
+            ContentPart::InlineData { mime_type, data } => {
+                estimate_tokens(mime_type).saturating_add((data.len()).saturating_add(3) / 4)
+            }
+            ContentPart::ToolCall {
+                name,
+                args,
+                call_id,
+            } => estimate_tokens(name)
+                .saturating_add(estimate_tokens(&args.to_string()))
+                .saturating_add(call_id.as_deref().map_or(0, estimate_tokens)),
+            ContentPart::ToolOutput {
+                name,
+                output,
+                call_id,
+                ..
+            } => estimate_tokens(name)
+                .saturating_add(estimate_tokens(&output.to_string()))
+                .saturating_add(call_id.as_deref().map_or(0, estimate_tokens)),
+            ContentPart::Action { name, payload, .. } => {
+                estimate_tokens(name).saturating_add(estimate_tokens(&payload.to_string()))
+            }
+            ContentPart::Any(value) => estimate_tokens(&value.to_string()),
+        }
+    }
 }
 
 /// Converts a content part with inline data to a data URL string.
@@ -927,8 +961,8 @@ impl FunctionDefinition {
 }
 
 /// Estimates token count using a small, provider-independent heuristic.
-pub fn estimate_tokens(content: &str) -> usize {
-    content.len() / 3
+pub fn estimate_tokens(text: &str) -> usize {
+    (text.chars().count()).saturating_add(3) / 4
 }
 
 /// A document with metadata and content.

anda_engine/src/context/agent.rs

@@ -257,7 +257,7 @@ impl AgentCtx {
                 let lowercase = definition.name.to_ascii_lowercase();
                 visible_names
                     .insert(lowercase.clone())
-                    .then(|| (lowercase, definition.name))
+                    .then_some((lowercase, definition.name))
             })
             .collect();
         for group in self.agents.groups() {
@@ -1142,6 +1142,11 @@ impl CompletionRunner {
             && self.pending_tool_calls.is_empty()
     }
 
+    /// Returns whether there are no pending tool calls.
+    pub fn no_pending_tool_calls(&self) -> bool {
+        self.pending_tool_calls.is_empty()
+    }
+
     /// Returns the number of turns executed.
     pub fn turns(&self) -> usize {
         self.turns
@@ -1239,6 +1244,11 @@ impl CompletionRunner {
         self.steering_message.extend(content);
     }
 
+    /// Returns the iter over the queued steering message content parts.
+    pub fn steering_message_iter(&'_ self) -> core::slice::Iter<'_, ContentPart> {
+        self.steering_message.iter()
+    }
+
     /// Queue a follow-up message for the next safe user turn.
     /// Delivered with the current pending tool-call results when they finish, or at the next idle
     /// boundary when no tools are pending. Steering still takes priority.
@@ -1258,6 +1268,11 @@ impl CompletionRunner {
         self.follow_up_message.extend(content);
     }
 
+    /// Returns the iter over the queued follow-up message content parts.
+    pub fn follow_up_message_iter(&'_ self) -> std::collections::vec_deque::Iter<'_, ContentPart> {
+        self.follow_up_message.iter()
+    }
+
     /// Drops the current in-flight request after a transport-level model failure.
     ///
     /// This keeps accumulated chat history, usage, artifacts, and queued follow-up messages, but

anda_engine/src/subagent.rs

@@ -790,7 +790,9 @@ impl SubSessionRunner {
     /// own request, so it must run *before* the content is attached or the compaction request would
     /// overflow too.
     async fn compact_if_needed(&mut self, pending_tokens: u64) -> Result<(), BoxError> {
-        if self.runner.is_idle() && needs_compaction_with_pending(&self.runner, pending_tokens) {
+        if self.runner.no_pending_tool_calls()
+            && needs_compaction_with_pending(&self.runner, pending_tokens)
+        {
             self.compact().await?;
         }
 
@@ -897,7 +899,19 @@ impl SubSessionRunner {
         // queue it. Running unconditionally also covers the case where the committed history grew
         // over the threshold without any new input this round.
         let pending_tokens = estimated_content_tokens(&follow_up_batch)
-            .saturating_add(estimated_content_tokens(&steer_batch));
+            .saturating_add(estimated_content_tokens(&steer_batch))
+            .saturating_add(
+                self.runner
+                    .steering_message_iter()
+                    .map(|c| c.estimated_tokens() as u64)
+                    .sum(),
+            )
+            .saturating_add(
+                self.runner
+                    .follow_up_message_iter()
+                    .map(|c| c.estimated_tokens() as u64)
+                    .sum(),
+            );
         self.compact_if_needed(pending_tokens).await?;
         if !follow_up_batch.is_empty() {
             self.runner.follow_up_content(follow_up_batch);
@@ -2217,43 +2231,7 @@ fn estimated_message_tokens(message: &Message) -> u64 {
 }
 
 fn estimated_content_tokens(content: &[ContentPart]) -> u64 {
-    content.iter().map(estimated_content_part_tokens).sum()
-}
-
-fn estimated_content_part_tokens(content: &ContentPart) -> u64 {
-    match content {
-        ContentPart::Text { text } | ContentPart::Reasoning { text } => estimated_text_tokens(text),
-        ContentPart::FileData {
-            file_uri,
-            mime_type,
-        } => estimated_text_tokens(file_uri)
-            .saturating_add(mime_type.as_deref().map_or(0, estimated_text_tokens)),
-        ContentPart::InlineData { mime_type, data } => estimated_text_tokens(mime_type)
-            .saturating_add((data.len() as u64).saturating_add(3) / 4),
-        ContentPart::ToolCall {
-            name,
-            args,
-            call_id,
-        } => estimated_text_tokens(name)
-            .saturating_add(estimated_text_tokens(&args.to_string()))
-            .saturating_add(call_id.as_deref().map_or(0, estimated_text_tokens)),
-        ContentPart::ToolOutput {
-            name,
-            output,
-            call_id,
-            ..
-        } => estimated_text_tokens(name)
-            .saturating_add(estimated_text_tokens(&output.to_string()))
-            .saturating_add(call_id.as_deref().map_or(0, estimated_text_tokens)),
-        ContentPart::Action { name, payload, .. } => {
-            estimated_text_tokens(name).saturating_add(estimated_text_tokens(&payload.to_string()))
-        }
-        ContentPart::Any(value) => estimated_text_tokens(&value.to_string()),
-    }
-}
-
-fn estimated_text_tokens(text: &str) -> u64 {
-    (text.chars().count() as u64).saturating_add(3) / 4
+    content.iter().map(|c| c.estimated_tokens() as u64).sum()
 }
 
 #[cfg(test)]