Response from custom executor doesn't trigger LLM interaction in the following Agent edge

[essimplyioa]

I'm trying to execute the following logical workflow:

• Execute two agents, each using LLM to come up with a response
• Aggregate the results in a custom executor
• Execute the final agent, using LLM to come up with a conclusion based on the aggregation result

However, even though the aggregated message contains expected data, and the final decision-agent is invoked, it doesn't involve LLM, and no output is produced from it.

What am I doing wrong here?

var decisionAgent = openAIClient.GetResponsesClient("gpt-5-chat")
    .AsAIAgent(
    loggerFactory: logger,
    name: "decision-agent",
    instructions:
        """
        You are a traveler who loves photography but hates extreme heat.
        
        Based on your preference for photography and dislike of heat, compare the two provided options and give a final recommendation with a 3-day itinerary outline.
        """
);

var agentTY = openAIClient.GetResponsesClient("gpt-5-chat")
    .AsAIAgent(
    loggerFactory: logger,
    name: "ty-agent",
    instructions:
    """
    Argue exclusively for the benefits of Tokyo. Focus on food, technology, and culture. Response strictly in this format:

    TOKYO
    <your argument here>
    """
    );

var agentRK = openAIClient.GetResponsesClient("gpt-5-chat")
    .AsAIAgent(
    loggerFactory: logger,
    name: "rk-agent",
    instructions:
    """
    Argue exclusively for the benefits of Reykjavik. Focus on food, technology, and culture. Response strictly in this format:
    
    REYKJAVIK
    <your argument here>
    """
    );

var passThrough = new ChatForwardingExecutor("pass-through");
var aggregator = new ConcurrentAggregationExecutor();

var workflow = new WorkflowBuilder(passThrough)
    .AddFanOutEdge(passThrough, [agentTY, agentRK])
    .AddFanInBarrierEdge([agentTY, agentRK], aggregator)
    .AddEdge(aggregator, decisionAgent)
    .WithOutputFrom(decisionAgent)
    .Build();

var run = await InProcessExecution.RunAsync(workflow, new ChatMessage(ChatRole.User, "Begin"));
var result = run.OutgoingEvents.Where(e => e is WorkflowOutputEvent).ToList();

public sealed class ConcurrentAggregationExecutor() :
    Executor<List<ChatMessage>, ChatMessage>("ConcurrentAggregationExecutor"), IResettableExecutor
{
    private readonly List<ChatMessage> _messages = [];

    public override async ValueTask<ChatMessage> HandleAsync(List<ChatMessage> messages, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        foreach (var message in messages.Where(m => m.Role == ChatRole.Assistant && !string.IsNullOrWhiteSpace(m.Text)))
        {
            if (_messages.Contains(message))
                continue;

            _messages.Add(message);
        }

        if (_messages.Count < 2)
            return null;

        var output = string.Join("\n\n", _messages.Select(m => m.Text));
        var outMessage = new ChatMessage(ChatRole.User, output);
        await context.SendMessageAsync(outMessage, cancellationToken);

        return outMessage;
    }

    /// <inheritdoc/>
    public ValueTask ResetAsync()
    {
        _messages.Clear();
        return default;
    }
}

I tried various variations of the above. Some resulted in errors; others didn't trigger the decision-agent at all. For example, the code below throws an exception:

public sealed class ConcurrentAggregationExecutor() :
    Executor<List<ChatMessage>>("ConcurrentAggregationExecutor"), IResettableExecutor
{
    private readonly List<ChatMessage> _messages = [];

    public override async ValueTask HandleAsync(List<ChatMessage> messages, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        foreach (var message in messages.Where(m => m.Role == ChatRole.Assistant && !string.IsNullOrWhiteSpace(m.Text)))
        {
            if (_messages.Contains(message))
                continue;

            _messages.Add(message);
        }

        if (_messages.Count < 2)
            return;

        var output = string.Join("\n\n", _messages.Select(m => m.Text));
        var outMessage = new ChatMessage(ChatRole.User, output);
        
        
        // Throw an exception:
        // Executor 'ConcurrentAggregationExecutor' cannot send messages of type 'Microsoft.Extensions.AI.ChatMessage'.
        await context.SendMessageAsync(outMessage, cancellationToken);
    }

[moonbox3]

Adding @lokitoth to help.

[essimplyioa]

To provide more details, here are other variations of the custom executors that I've tried:

public override async ValueTask<ChatMessage> HandleAsync(List<ChatMessage> messages, IWorkflowContext context, CancellationToken cancellationToken = default)
{
    // ...
    await context.SendMessageAsync(outMessage, cancellationToken);
    return outMessage;
}

public override async ValueTask<ChatMessage> HandleAsync(List<ChatMessage> messages, IWorkflowContext context, CancellationToken cancellationToken = default)
{
    // ...
    return outMessage;
}

public override async ValueTask<List<ChatMessage>> HandleAsync(List<ChatMessage> messages, IWorkflowContext context, CancellationToken cancellationToken = default)
{
    // ...
    return [outMessage];
}

And here are the last events from the workflow: