@pheem49/mint 1.16.0 → 1.17.0

package/crates/mint-core/src/orchestration/context_render.rs

@@ -20,7 +20,13 @@ pub(super) fn render_messages_as_text(messages: &[ChatMessage]) -> String {
                     ContentBlock::ToolUse { name, input, .. } => {
                         format!("Called {name} with {input}")
                     }
-                    ContentBlock::ToolResult { content, .. } => format!("Result: {content}"),
+                    ContentBlock::ToolResult { content, .. } => {
+                        let truncated = super::truncation::head_tail_truncate(
+                            content,
+                            super::truncation::TruncationConfig::COMPACT,
+                        );
+                        format!("Result: {truncated}")
+                    }
                     ContentBlock::Image { .. } => "[image]".to_string(),
                     ContentBlock::Audio { .. } => "[audio]".to_string(),
                     ContentBlock::Video { .. } => "[video]".to_string(),
@@ -45,17 +51,12 @@ pub(super) fn render_messages_as_text(messages: &[ChatMessage]) -> String {
 /// special-casing needed elsewhere.
 ///
 /// `Ok(None)` means there was nothing worth compacting yet (too little history)
-/// — not a failure, just a no-op. `Err` means compaction was attempted but the
-/// summarization call itself failed; compaction is a best-effort optimization,
-/// so callers should fall back to the uncompacted messages rather than failing
-/// the agent run, but may want to surface the failure differently than a
-/// routine no-op.
+/// — not a failure, just a no-op.
 ///
-/// `Ok(Some((_, fallback_provider)))`'s second element names the provider
-/// actually used to generate the summary when it differs from the caller's
-/// primary (`send_chat_with_fallback` silently retries on another configured
-/// provider if the primary fails) — surfaced rather than discarded so a
-/// summary quietly written by a different model isn't invisible to the user.
+/// If LLM-based summarization fails (e.g. timeout, rate limit, provider error),
+/// this function falls back to deterministic structural truncation via
+/// [`hard_truncate_native_messages`] to guarantee that context is reduced and
+/// the agent loop does not crash from context overflow.
 pub(super) async fn compact_native_messages(
     config: &MintConfig,
     messages: &[ChatMessage],
@@ -78,7 +79,7 @@ pub(super) async fn compact_native_messages(
          the log.\n\n{transcript}"
     );
 
-    let (summary_response, fallback_provider) = send_chat_with_fallback(
+    let summary_result = send_chat_with_fallback(
         config,
         &ChatRequest {
             message: summary_prompt,
@@ -99,34 +100,118 @@ pub(super) async fn compact_native_messages(
             ..Default::default()
         },
     )
-    .await?;
+    .await;
+
+    match summary_result {
+        Ok((summary_response, fallback_provider)) => {
+            let mut compacted = Vec::with_capacity(messages.len() - compact_message_count + 3);
+            compacted.push(messages[0].clone());
+            compacted.push(ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::Text {
+                    text: format!(
+                        "[Summary of earlier steps 1-{compact_pairs}, compacted to save context]\n{}",
+                        summary_response.text.trim()
+                    ),
+                }],
+            });
+            compacted.push(ChatMessage {
+                role: ChatRole::User,
+                content: vec![ContentBlock::Text {
+                    text: "Continue the task using the summary above and the recent steps below."
+                        .into(),
+                }],
+            });
+            compacted.extend_from_slice(&messages[1 + compact_message_count..]);
+            Ok(Some((compacted, fallback_provider)))
+        }
+        Err(err) => {
+            // LLM summarization failed (timeout, rate limit 429, provider offline, or context limit).
+            // Rather than returning Err and leaving native_messages uncompacted (which causes the next
+            // agent turn to crash with context window exceeded), fall back to deterministic hard-truncation.
+            let truncated =
+                hard_truncate_native_messages(messages, compact_pairs, &err.to_string());
+            Ok(Some((
+                truncated,
+                Some(format!("hard-truncate fallback ({err})")),
+            )))
+        }
+    }
+}
+
+pub(super) fn hard_truncate_native_messages(
+    messages: &[ChatMessage],
+    compact_pairs: usize,
+    error_reason: &str,
+) -> Vec<ChatMessage> {
+    let compact_message_count = compact_pairs * 2;
+    let compacted_range = if messages.len() > 1 {
+        let end = (1 + compact_message_count).min(messages.len());
+        &messages[1..end]
+    } else {
+        &[]
+    };
+
+    let mut actions = Vec::new();
+    for chunk in compacted_range.chunks(2) {
+        if let Some(assistant_msg) = chunk.get(0) {
+            for block in &assistant_msg.content {
+                if let ContentBlock::ToolUse { name, input, .. } = block {
+                    let input_summary = match input {
+                        serde_json::Value::Object(map) => {
+                            if let Some(path) = map.get("path").and_then(|v| v.as_str()) {
+                                format!("path: {path}")
+                            } else if let Some(cmd) = map.get("command").and_then(|v| v.as_str()) {
+                                format!("command: {cmd}")
+                            } else if let Some(query) = map.get("query").and_then(|v| v.as_str()) {
+                                format!("query: {query}")
+                            } else {
+                                let s = input.to_string();
+                                truncate_for_context(&s, 60)
+                            }
+                        }
+                        _ => {
+                            let s = input.to_string();
+                            truncate_for_context(&s, 60)
+                        }
+                    };
+                    actions.push(format!("- {name} ({input_summary})"));
+                }
+            }
+        }
+    }
+
+    let actions_text = if actions.is_empty() {
+        "(no explicit tool calls recorded)".to_string()
+    } else {
+        actions.join("\n")
+    };
 
-    let mut compacted = Vec::with_capacity(messages.len() - compact_message_count + 3);
-    compacted.push(messages[0].clone());
+    let summary_content = format!(
+        "[Summary of steps 1-{compact_pairs} — compacted via deterministic hard-truncation fallback due to summarization failure: {error_reason}]\nActions performed in earlier steps:\n{actions_text}\n[Detailed tool outputs omitted to preserve context window. Recent steps continue below.]"
+    );
+
+    let mut compacted =
+        Vec::with_capacity(messages.len().saturating_sub(compact_message_count) + 3);
+    if !messages.is_empty() {
+        compacted.push(messages[0].clone());
+    }
     compacted.push(ChatMessage {
         role: ChatRole::Assistant,
-        content: vec![ContentBlock::ToolUse {
-            id: "call_compacted_summary".into(),
-            name: "conversation_summary".into(),
-            input: serde_json::json!({
-                "summary": format!("Summary of steps 1-{compact_pairs}")
-            }),
-            thought_signature: None,
+        content: vec![ContentBlock::Text {
+            text: summary_content,
         }],
     });
     compacted.push(ChatMessage {
-        role: ChatRole::Tool,
-        content: vec![ContentBlock::ToolResult {
-            tool_use_id: "call_compacted_summary".into(),
-            content: format!(
-                "[Summary of steps 1-{compact_pairs}, compacted to save context]\n{}",
-                summary_response.text.trim()
-            ),
-            is_error: false,
+        role: ChatRole::User,
+        content: vec![ContentBlock::Text {
+            text: "Continue the task using the summary above and the recent steps below.".into(),
         }],
     });
-    compacted.extend_from_slice(&messages[1 + compact_message_count..]);
-    Ok(Some((compacted, fallback_provider)))
+    if messages.len() > 1 + compact_message_count {
+        compacted.extend_from_slice(&messages[1 + compact_message_count..]);
+    }
+    compacted
 }
 
 pub(super) fn initial_observation(task: &str, root: &Path, skills: &str) -> String {
@@ -215,6 +300,58 @@ pub(super) fn format_trajectory_step(
     s
 }
 
+/// Keeps full `ContentBlock::Image` payloads only for the most recent
+/// `max_retained_steps` tool turns. Older tool turns have their `ContentBlock::Image`
+/// removed and their tool result text updated to indicate historical pixels
+/// were pruned to reduce prompt cache and token bloat.
+///
+/// Returns the number of `ContentBlock::Image` entries pruned.
+pub(super) fn prune_historic_images_from_native_messages(
+    messages: &mut [ChatMessage],
+    max_retained_steps: usize,
+) -> usize {
+    if messages.is_empty() {
+        return 0;
+    }
+    let mut tool_count = 0;
+    let mut pruned_count = 0;
+
+    for message in messages.iter_mut().rev() {
+        if message.role == ChatRole::Tool {
+            tool_count += 1;
+            if tool_count > max_retained_steps {
+                let had_image = message
+                    .content
+                    .iter()
+                    .any(|block| matches!(block, ContentBlock::Image { .. }));
+                if had_image {
+                    message.content.retain(|block| {
+                        if matches!(block, ContentBlock::Image { .. }) {
+                            pruned_count += 1;
+                            false
+                        } else {
+                            true
+                        }
+                    });
+                    for block in &mut message.content {
+                        if let ContentBlock::ToolResult { content, .. } = block {
+                            if content.contains("— see attached image") {
+                                *content = content.replace(
+                                    "— see attached image",
+                                    "— historical image pixels pruned from context",
+                                );
+                            } else if !content.contains("pruned from context") {
+                                content.push_str(" [historical image pixels pruned from context]");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    pruned_count
+}
+
 /// Sends a lifecycle around the actual summarizer await; callers retain the
 /// original messages on failure. Short histories do not enter this UI state.
 pub(super) async fn report_context_compaction<F>(
@@ -240,7 +377,13 @@ where
         Ok(Some((_, fallback))) => {
             let fallback_note = fallback
                 .as_ref()
-                .map(|p| format!("; summary generated via fallback provider {p}"))
+                .map(|p| {
+                    if p.starts_with("hard-truncate") {
+                        format!("; {p}")
+                    } else {
+                        format!("; summary generated via fallback provider {p}")
+                    }
+                })
                 .unwrap_or_default();
             (
                 "completed",
@@ -317,4 +460,278 @@ mod compaction_progress_tests {
             matches!(&events.borrow()[1], AgentProgress::ContextCompaction { status, message, .. } if status == "failed" && message.contains("offline") && message.contains("original context"))
         );
     }
+
+    #[test]
+    fn test_prune_historic_images_empty_messages() {
+        let mut messages = Vec::new();
+        assert_eq!(
+            prune_historic_images_from_native_messages(&mut messages, 2),
+            0
+        );
+    }
+
+    #[test]
+    fn test_prune_historic_images_keeps_within_retention_window() {
+        let mut messages = vec![
+            ChatMessage {
+                role: ChatRole::User,
+                content: vec![ContentBlock::Text {
+                    text: "task".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::Text {
+                    text: "call 1".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![
+                    ContentBlock::ToolResult {
+                        tool_use_id: "c1".into(),
+                        content: "[Image loaded — see attached image]".into(),
+                        is_error: false,
+                    },
+                    ContentBlock::Image {
+                        data_uri: "data:image/png;base64,img1".into(),
+                    },
+                ],
+            },
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::Text {
+                    text: "call 2".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![
+                    ContentBlock::ToolResult {
+                        tool_use_id: "c2".into(),
+                        content: "[Image loaded — see attached image]".into(),
+                        is_error: false,
+                    },
+                    ContentBlock::Image {
+                        data_uri: "data:image/png;base64,img2".into(),
+                    },
+                ],
+            },
+        ];
+
+        // Retention is 2, and there are 2 tool messages, so none should be pruned.
+        let pruned = prune_historic_images_from_native_messages(&mut messages, 2);
+        assert_eq!(pruned, 0);
+        assert_eq!(messages[2].content.len(), 2);
+        assert_eq!(messages[4].content.len(), 2);
+    }
+
+    #[test]
+    fn test_prune_historic_images_prunes_older_than_retention_window() {
+        let mut messages = vec![
+            ChatMessage {
+                role: ChatRole::User,
+                content: vec![ContentBlock::Text {
+                    text: "task".into(),
+                }],
+            },
+            // Step 1
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::Text {
+                    text: "step 1".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![
+                    ContentBlock::ToolResult {
+                        tool_use_id: "c1".into(),
+                        content: "[Image loaded — see attached image]".into(),
+                        is_error: false,
+                    },
+                    ContentBlock::Image {
+                        data_uri: "data:image/png;base64,img1".into(),
+                    },
+                ],
+            },
+            // Step 2
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::Text {
+                    text: "step 2".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![
+                    ContentBlock::ToolResult {
+                        tool_use_id: "c2".into(),
+                        content: "[Image loaded — see attached image]".into(),
+                        is_error: false,
+                    },
+                    ContentBlock::Image {
+                        data_uri: "data:image/png;base64,img2".into(),
+                    },
+                ],
+            },
+            // Step 3
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::Text {
+                    text: "step 3".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![
+                    ContentBlock::ToolResult {
+                        tool_use_id: "c3".into(),
+                        content: "[Image loaded — see attached image]".into(),
+                        is_error: false,
+                    },
+                    ContentBlock::Image {
+                        data_uri: "data:image/png;base64,img3".into(),
+                    },
+                ],
+            },
+        ];
+
+        // Retention is 2: Step 3 (most recent) and Step 2 are kept; Step 1 is pruned.
+        let pruned = prune_historic_images_from_native_messages(&mut messages, 2);
+        assert_eq!(pruned, 1);
+
+        // Step 1: Image removed, ToolResult updated
+        assert_eq!(messages[2].content.len(), 1);
+        match &messages[2].content[0] {
+            ContentBlock::ToolResult { content, .. } => {
+                assert!(content.contains("historical image pixels pruned from context"));
+                assert!(!content.contains("— see attached image"));
+            }
+            _ => panic!("Expected ToolResult block"),
+        }
+
+        // Step 2: Image kept
+        assert_eq!(messages[4].content.len(), 2);
+        assert!(matches!(messages[4].content[1], ContentBlock::Image { .. }));
+
+        // Step 3: Image kept
+        assert_eq!(messages[6].content.len(), 2);
+        assert!(matches!(messages[6].content[1], ContentBlock::Image { .. }));
+    }
+
+    fn sample_step_pair(index: usize) -> [ChatMessage; 2] {
+        [
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::ToolUse {
+                    id: format!("call{index}"),
+                    name: "read_file".into(),
+                    input: serde_json::json!({"path": format!("file{index}.rs")}),
+                    thought_signature: None,
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![ContentBlock::ToolResult {
+                    tool_use_id: format!("call{index}"),
+                    content: format!("contents of file{index}.rs"),
+                    is_error: false,
+                }],
+            },
+        ]
+    }
+
+    #[test]
+    fn render_messages_as_text_truncates_oversized_tool_results() {
+        let long_content = "x".repeat(10_000);
+        let messages = vec![
+            ChatMessage {
+                role: ChatRole::User,
+                content: vec![ContentBlock::Text {
+                    text: "task".into(),
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Assistant,
+                content: vec![ContentBlock::ToolUse {
+                    id: "c1".into(),
+                    name: "cat_huge_file".into(),
+                    input: serde_json::json!({}),
+                    thought_signature: None,
+                }],
+            },
+            ChatMessage {
+                role: ChatRole::Tool,
+                content: vec![ContentBlock::ToolResult {
+                    tool_use_id: "c1".into(),
+                    content: long_content,
+                    is_error: false,
+                }],
+            },
+        ];
+        let rendered = render_messages_as_text(&messages);
+        assert!(rendered.contains("Truncated"));
+        assert!(rendered.len() < 3000);
+    }
+
+    #[test]
+    fn hard_truncate_native_messages_preserves_task_and_role_alternation() {
+        let mut messages = vec![ChatMessage::text(ChatRole::User, "initial task")];
+        for i in 0..5 {
+            messages.extend(sample_step_pair(i));
+        }
+        // 5 step pairs total (11 messages). Compact 2 pairs (steps 0 and 1), keeping steps 2, 3, 4 (3 pairs = 6 msgs).
+        let truncated = hard_truncate_native_messages(&messages, 2, "mock provider failure");
+
+        assert_eq!(truncated.len(), 1 + 2 + 6);
+        assert_eq!(truncated[0].role, ChatRole::User);
+        assert_eq!(truncated[1].role, ChatRole::Assistant);
+        assert_eq!(truncated[2].role, ChatRole::User);
+
+        // Verify summary contains key info
+        match &truncated[1].content[0] {
+            ContentBlock::Text { text } => {
+                assert!(text.contains("mock provider failure"));
+                assert!(text.contains("read_file"));
+                assert!(text.contains("file0.rs"));
+                assert!(text.contains("file1.rs"));
+            }
+            _ => panic!("Expected Text block in summary"),
+        }
+
+        // Verify role sequence after compaction:
+        // [0] User (initial task)
+        // [1] Assistant (compacted summary)
+        // [2] User (continuation prompt)
+        // [3..] Alternating Assistant (ToolUse) and Tool (ToolResult)
+        for (i, msg) in truncated.iter().enumerate().skip(3) {
+            let expected_role = if i % 2 == 1 {
+                ChatRole::Assistant
+            } else {
+                ChatRole::Tool
+            };
+            assert_eq!(msg.role, expected_role);
+        }
+    }
+
+    #[tokio::test]
+    async fn compact_native_messages_falls_back_to_hard_truncate_on_error() {
+        let mut messages = vec![ChatMessage::text(ChatRole::User, "initial task")];
+        // 5 step pairs = 2 to compact (since KEEP_RECENT = 3)
+        for i in 0..5 {
+            messages.extend(sample_step_pair(i));
+        }
+        let config = MintConfig {
+            ai_provider: "non_existent_provider_that_will_fail".into(),
+            ..Default::default()
+        };
+        let result = compact_native_messages(&config, &messages).await.unwrap();
+        assert!(result.is_some());
+        let (compacted, fallback) = result.unwrap();
+        assert_eq!(compacted.len(), 1 + 2 + 6);
+        assert_eq!(compacted[1].role, ChatRole::Assistant);
+        assert_eq!(compacted[2].role, ChatRole::User);
+        assert!(fallback.as_deref().unwrap_or("").contains("hard-truncate"));
+    }
 }

package/crates/mint-core/src/orchestration/decision_parsing.rs

@@ -29,7 +29,11 @@ pub(super) fn action_fingerprint(decision: &AgentDecision) -> String {
         "create_plan" | "update_plan" => format!("{}:{}", decision.action, input.steps.join("\n")),
         "request_user_approval" => format!("request_user_approval:{}", input.summary.trim()),
         "ask_user" => format!("ask_user:{}", input.query.trim()),
-        "view_image" => format!("view_image:{}", input.path.trim()),
+        "view_image" => format!(
+            "view_image:{}:{}",
+            input.path.trim(),
+            input.artifact_id.trim()
+        ),
         "run_shell" => format!("run_shell:{}", input.command.trim()),
         "verify" => format!("verify:{}", input.commands.join("\n")),
         "apply_patch" => input
@@ -134,28 +138,6 @@ pub(super) fn reject_native_finish(
     });
 }
 
-/// Maximum number of `dispatch_subagent` calls run concurrently when a single
-/// model turn requests several of them at once (see `orchestrate_agent_loop`'s
-/// parallel-dispatch branch). Kept low: each subagent makes its own AI-provider
-/// API calls, so a higher cap risks tripping the configured provider's rate
-/// limit, and most tasks don't naturally decompose into more than a couple of
-/// truly independent pieces anyway.
-pub(super) const PARALLEL_SUBAGENT_LIMIT: usize = 2;
-
-/// Whether this step's decisions should run as a concurrency-limited batch of
-/// subagent dispatches instead of the normal one-at-a-time loop: 2 or more
-/// decisions, every one of them a `dispatch_subagent` call with nothing else
-/// mixed in. A lone subagent call, or one mixed with other actions, stays on
-/// the sequential path — keeps ordering between subagent results and other
-/// tool results simple, and avoids parallelizing tools that were never
-/// verified to be safe to run concurrently.
-pub(super) fn decisions_are_parallel_subagent_batch(decisions: &[(String, AgentDecision)]) -> bool {
-    decisions.len() >= 2
-        && decisions
-            .iter()
-            .all(|(_, d)| d.action == "dispatch_subagent")
-}
-
 /// Maximum number of read-only tools run concurrently when a single model turn
 /// requests several of them at once.
 pub(super) const PARALLEL_READ_ONLY_LIMIT: usize = 6;