🚨 CRITICAL: tool_use blocks missing tool_result blocks - Complete system failure

[VincentJGeisler]

GitHub Issue Content for RooCodeInc/Roo-Code

Issue URL: https://github.com/RooCodeInc/Roo-Code/issues/new?template=bug_report.yml

---

Title

🚨 CRITICAL: tool_use blocks missing tool_result blocks - Complete system failure

Labels

• bug
• critical
• P0
• blocker

---

Bug Description

The Roo agent system is generating malformed API requests to Anthropic's Messages API, causing complete failure of all multi-tool operations. This is a CRITICAL BLOCKER preventing any productive use of the Roo plugin.

Error Message

Error: Unknown Error: The model returned the following errors: 
messages.14: tool_use ids were found without tool_result blocks immediately after: 
  - tooluse_B8gcmu8mnHEeUKh40Sisud
  - tooluse_QY8c3vPo2n5jQqDcTw7MXh
  - tooluse_Uj8iOkWzQsRKrjf7WVd0La
  - tooluse_nIz7ESflVjMzuaHL3cShPH

Each tool_use block must have a corresponding tool_result block in the next message.

---

To Reproduce

Steps:

1. Start Roo agent in Debug mode (or any mode)
2. Issue a request requiring 4+ parallel tool calls (e.g., "search codebase for X and read files Y, Z, W")
3. Wait for tools to execute
4. Error occurs when agent attempts next API call

Frequency: ~100% reproducible with 4+ parallel tools

---

Expected Behavior

All tool_use blocks should have corresponding tool_result blocks in the next user message per Anthropic API requirements.

---

Actual Behavior

The system sends API requests with tool_use blocks but missing or incomplete tool_result blocks, violating Anthropic's API contract and causing immediate failure.

---

Root Cause Analysis

Primary Diagnosis (80% confidence): Message history reconstruction bug

When rebuilding conversation history for the API request:

1. Agent executes 4 tools in parallel ✅
2. All 4 tool_use blocks recorded in assistant message ✅
3. BUG: Tool results missing/incomplete when constructing next user message ❌
4. Malformed API request sent ❌
5. Anthropic API rejects request ❌

---

Impact

• ❌ Complete system failure for multi-tool operations
• ❌ No workaround available to end users
• ❌ 100% blocker for Debug, Code, and Ask modes
• ❌ All users affected when triggering 4+ parallel tools

---

Environment

• OS: Linux 5.15
• VSCode: Remote Server Environment
• Roo Version: Latest (as of 2026-02-27)
• Model: us.anthropic.claude-sonnet-4-5-20250929-v1:0
• Date: 2026-02-27T02:31:57.048Z

---

Proposed Fix

1. Add Message History Validation

function validateMessageHistory(messages: Message[]): void {
  for (let i = 0; i < messages.length - 1; i++) {
    const current = messages[i];
    const next = messages[i + 1];
    
    if (current.role === "assistant") {
      const toolUses = current.content.filter(c => c.type === "tool_use");
      
      if (toolUses.length > 0 && next.role === "user") {
        const toolResults = next.content.filter(c => c.type === "tool_result");
        const toolUseIds = new Set(toolUses.map(t => t.id));
        const toolResultIds = new Set(toolResults.map(r => r.tool_use_id));
        
        // Ensure every tool_use has corresponding tool_result
        for (const id of toolUseIds) {
          if (!toolResultIds.has(id)) {
            throw new Error(`Missing tool_result for tool_use: ${id}`);
          }
        }
      }
    }
  }
}

2. Ensure Complete Result Collection

async function executeToolsAndCollectResults(tools: ToolCall[]): Promise<ToolResult[]> {
  // Wait for ALL tools to complete
  const results = await Promise.all(
    tools.map(tool => executeTool(tool))
  );
  
  // Verify result count matches tool count
  if (results.length !== tools.length) {
    throw new Error(`Tool count mismatch: ${tools.length} tools, ${results.length} results`);
  }
  
  return results;
}

3. Pre-Send API Validation

function validateBeforeSend(apiRequest: AnthropicRequest): void {
  validateMessageHistory(apiRequest.messages);
  
  // Additional validation for pending tool_uses
  const lastAssistant = apiRequest.messages.findLast(m => m.role === "assistant");
  if (lastAssistant) {
    const toolUses = lastAssistant.content.filter(c => c.type === "tool_use");
    if (toolUses.length > 0) {
      const nextMessage = apiRequest.messages[apiRequest.messages.indexOf(lastAssistant) + 1];
      if (!nextMessage || nextMessage.role !== "user") {
        throw new Error("tool_use blocks must be followed by user message with tool_results");
      }
    }
  }
}

---

Additional Context

Full technical analysis available: The user has created a comprehensive 500+ line technical report (ROO_CRITICAL_BUG_REPORT.md) with:

• Detailed root cause analysis
• Complete reproduction steps
• Code examples for fixes
• Testing requirements
• Impact assessment

Tool IDs from error:

• tooluse_B8gcmu8mnHEeUKh40Sisud
• tooluse_QY8c3vPo2n5jQqDcTw7MXh
• tooluse_Uj8iOkWzQsRKrjf7WVd0La
• tooluse_nIz7ESflVjMzuaHL3cShPH

---

Priority Justification

Why P0/CRITICAL:

1. Complete service outage for multi-tool operations
2. No workaround available to users
3. Affects all users (not configuration-specific)
4. System reliability severely impacted
5. In-progress work sessions terminated

Expected Resolution: Immediate (within 24 hours)

---

Attachments

Full detailed report available in project: ROO_CRITICAL_BUG_REPORT.md

[roomote-v0]

I have analyzed this issue and here is my proposed implementation plan:

Root Cause Analysis

The codebase already has validateAndFixToolResultIds() in src/core/task/validateToolResultIds.ts which validates tool_use/tool_result pairing at message insert time (called in addToApiConversationHistory and flushPendingToolResultsToHistory).

However, there is a gap: no final validation occurs just before sending messages to the API. Between insert-time validation and the actual API call, several post-processing steps can introduce new mismatches:

1. getEffectiveApiHistory() filters out condensed messages and orphan tool_results, but could remove tool_results while leaving their tool_use blocks intact (or vice versa)
2. mergeConsecutiveApiMessages() merges consecutive user messages, which could theoretically disrupt pairing
3. buildCleanConversationHistory() transforms messages for the API, potentially altering content

Proposed Fix

1. Add a pre-send validation function in src/core/task/validateToolResultIds.ts

Create a new exported function validateMessageHistoryBeforeSend() that:

• Iterates through the final message array
• For each assistant message containing tool_use blocks, checks the immediately following user message has matching tool_result blocks
• For any missing tool_result, injects a placeholder: { type: "tool_result", tool_use_id: id, content: "Tool execution was interrupted before completion." }
• Reports mismatches to telemetry (using the existing MissingToolResultError pattern)

2. Call the validation in Task.ts just before the API call

In the recursivelyMakeClineRequests method (around line 4193), after buildCleanConversationHistory() but before createMessage() is called, invoke the new validation function on the final cleanConversationHistory array.

3. Add comprehensive tests

• Unit tests for validateMessageHistoryBeforeSend() covering:
  • Normal case (all tool_use have matching tool_result) - no changes
  • Missing tool_result for one or more tool_use blocks - placeholder injected
  • Condensed history where tool_use was filtered but tool_result remains (orphan cleanup)
  • Mixed scenarios with text blocks between tool blocks

This approach is minimal and defensive - it acts as a safety net at the last possible moment before the API call, without modifying any of the existing insert-time validation logic. It catches any issues introduced by post-processing.

Please mention @roomote in a comment saying that you approve this plan, and I will proceed with the implementation.

[drzraf]

@roomote : Yes please. Move on with this implementation plan.

[roomote-v0]

I've seen your comment and will proceed with the implementation plan. I'll add a pre-send validation function that ensures all tool_use blocks have matching tool_result blocks before API calls are made. I'll open a draft PR to share progress shortly.

[roomote-v0]

Opened a draft PR with my attempt at addressing this: #12183

The PR adds a validateMessageHistoryBeforeSend() function that runs as the last step before the API call, ensuring every tool_use block has a matching tool_result. Any missing results get placeholder injections so the request stays valid. All tests pass (34/34). Feedback welcome!