private Mono<List<Map.Entry<ToolUseBlock, ToolResultBlock>>> executeToolCalls(
        List<ToolUseBlock> toolCalls) {
    return toolkit.callTools(toolCalls, toolExecutionConfig, this, toolExecutionContext)
            .map(results -> IntStream.range(0, toolCalls.size())
                    .mapToObj(i -> Map.entry(toolCalls.get(i), results.get(i)))
                    .toList())
            // NEW: Error recovery - generate error results instead of failing
            .onErrorResume(error -> {
                log.error("Tool execution failed, generating error results for {} tool calls: {}",
                        toolCalls.size(), error.getMessage());
                List<Map.Entry<ToolUseBlock, ToolResultBlock>> errorResults = toolCalls.stream()
                        .map(toolCall -> {
                            ToolResultBlock errorResult = ToolResultBlock.builder()
                                    .id(toolCall.getId())
                                    .output(List.of(TextBlock.builder()
                                            .text("[ERROR] Tool execution failed: " + error.getMessage())
                                            .build()))
                                    .build();
                            return Map.entry(toolCall, errorResult);
                        })
                        .toList();
                return Mono.just(errorResults);
            });
}

@Override
protected Mono<Msg> doCall(List<Msg> msgs) {
    Set<String> pendingIds = getPendingToolUseIds();

    if (pendingIds.isEmpty()) {
        addToMemory(msgs);
        return executeIteration(0);
    }

    // NEW: Check if user provided tool results
    List<ToolResultBlock> providedResults = msgs == null ? List.of() :
            msgs.stream()
                    .flatMap(m -> m.getContentBlocks(ToolResultBlock.class).stream())
                    .toList();

    if (providedResults.isEmpty()) {
        // NEW: Auto-generate error results for orphaned pending calls
        log.warn("Pending tool calls detected without results, auto-generating error results. Pending IDs: {}", pendingIds);
        generateAndAddErrorToolResults(pendingIds);
        addToMemory(msgs);
        return executeIteration(0);
    }

    validateAndAddToolResults(msgs, pendingIds);
    return hasPendingToolUse() ? acting(0) : executeIteration(0);
}

/**
 * Generate error tool results for pending tool calls and add them to memory.
 * This is used to recover from situations where tool execution failed without
 * properly writing results to memory.
 */
private void generateAndAddErrorToolResults(Set<String> pendingIds) {
    Msg lastAssistant = findLastAssistantMsg();
    if (lastAssistant == null) {
        return;
    }

    List<ToolUseBlock> pendingToolCalls = lastAssistant.getContentBlocks(ToolUseBlock.class).stream()
            .filter(toolUse -> pendingIds.contains(toolUse.getId()))
            .toList();

    for (ToolUseBlock toolCall : pendingToolCalls) {
        ToolResultBlock errorResult = ToolResultBlock.builder()
                .id(toolCall.getId())
                .output(List.of(TextBlock.builder()
                        .text("[ERROR] Previous tool execution failed or was interrupted. Tool: " + toolCall.getName())
                        .build()))
                .build();
        Msg toolResultMsg = ToolResultMessageBuilder.buildToolResultMsg(errorResult, toolCall, getName());
        memory.addMessage(toolResultMsg);
        log.info("Auto-generated error result for pending tool call: {} ({})", toolCall.getName(), toolCall.getId());
    }
}