internal/flow: fix duplicate tool messages emitted after parallel tool execution (#420)

When tools run in parallel their results are merged into one event; the
history reorder step appended that same event once per tool ID, so the
next LLM call saw duplicate tool messages and rejected the request.
Deduplicate response event indices while preserving order so each merged
tool response is emitted exactly once; tightened comments and added a
regression test to lock the behaviour in.

Author: Flash-LHR

internal/flow/processor/content.go

@@ -358,6 +358,21 @@ func (p *ContentRequestProcessor) rearrangeAsyncFuncRespHist(
 					responseEventIndices = append(responseEventIndices, idx)
 				}
 			}
+			// When tools run in parallel they commonly return all results inside one response event.
+			// If we pushed the same event once per tool ID, the LLM would see duplicated tool
+			// messages and reject the request. Keep only the first occurrence of each event index
+			// while preserving their original order.
+			seenIdx := make(map[int]struct{}, len(functionCallIDs))
+			uniqueIndices := responseEventIndices[:0]
+			// Reuse the existing slice to deduplicate in place and maintain the original order.
+			for _, idx := range responseEventIndices {
+				if _, seen := seenIdx[idx]; seen {
+					continue
+				}
+				seenIdx[idx] = struct{}{}
+				uniqueIndices = append(uniqueIndices, idx)
+			}
+			responseEventIndices = uniqueIndices
 
 			resultEvents = append(resultEvents, evt)
 

internal/flow/processor/content_test.go

@@ -154,6 +154,68 @@ func TestContentRequestProcessor_ToolCalls(t *testing.T) {
 	}
 }
 
+func TestContentRequestProcessor_RearrangeAsyncFuncRespHist_DeduplicatesMergedResponses(t *testing.T) {
+	processor := NewContentRequestProcessor()
+
+	toolCallEvent := event.Event{
+		Author: "assistant",
+		Response: &model.Response{
+			Choices: []model.Choice{
+				{
+					Message: model.Message{
+						Role: model.RoleAssistant,
+						ToolCalls: []model.ToolCall{
+							{
+								ID:       "call_0",
+								Function: model.FunctionDefinitionParam{Name: "calculator"},
+							},
+							{
+								ID:       "call_1",
+								Function: model.FunctionDefinitionParam{Name: "calculator"},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	mergedToolResponse := event.Event{
+		Author: "assistant",
+		Response: &model.Response{
+			Choices: []model.Choice{
+				{
+					Message: model.Message{
+						Role:    model.RoleTool,
+						ToolID:  "call_0",
+						Content: "result 0",
+					},
+				},
+				{
+					Message: model.Message{
+						Role:    model.RoleTool,
+						ToolID:  "call_1",
+						Content: "result 1",
+					},
+				},
+			},
+		},
+	}
+
+	result := processor.rearrangeAsyncFuncRespHist([]event.Event{toolCallEvent, mergedToolResponse})
+
+	if len(result) != 2 {
+		t.Fatalf("expected 2 events (tool call + single response), got %d", len(result))
+	}
+
+	toolResultEvent := result[1]
+	resultIDs := toolResultEvent.GetToolResultIDs()
+	assert.ElementsMatch(t, []string{"call_0", "call_1"}, resultIDs,
+		"tool result IDs should match the original tool calls once each")
+	assert.Len(t, toolResultEvent.Response.Choices, 2,
+		"tool response event should contain one choice per tool ID without duplication")
+}
+
 func TestContentRequestProcessor_ToolResponses(t *testing.T) {
 	tests := []struct {
 		name           string