Function computeToolCallsDiff

pkg/cli/audit_diff.go:597–729

computeToolCallsDiff diffs engine-level tool calls from two LogMetrics values. Returns nil when both metrics have no tool call data.

(m1, m2 *LogMetrics)

// computeToolCallsDiff diffs engine-level tool calls from two LogMetrics values.
// Returns nil when both metrics have no tool call data.
func computeToolCallsDiff(m1, m2 *LogMetrics) *ToolCallsDiff {
	run1Tools := make(map[string]ToolCallInfo)
	run2Tools := make(map[string]ToolCallInfo)

	// aggregateToolCall merges a tool call entry into the map, summing call counts and
	// taking the max of size fields to handle duplicate entries across log files.
	aggregateToolCall := func(tools map[string]ToolCallInfo, tc ToolCallInfo) {
		if existing, ok := tools[tc.Name]; ok {
			existing.CallCount += tc.CallCount
			if tc.MaxInputSize > existing.MaxInputSize {
				existing.MaxInputSize = tc.MaxInputSize
			}
			if tc.MaxOutputSize > existing.MaxOutputSize {
				existing.MaxOutputSize = tc.MaxOutputSize
			}
			if tc.MaxDuration > existing.MaxDuration {
				existing.MaxDuration = tc.MaxDuration
			}
			tools[tc.Name] = existing
			return
		}
		tools[tc.Name] = tc
	}

	if m1 != nil {
		for _, tc := range m1.ToolCalls {
			aggregateToolCall(run1Tools, tc)
		}
	}
	if m2 != nil {
		for _, tc := range m2.ToolCalls {
			aggregateToolCall(run2Tools, tc)
		}
	}

	if len(run1Tools) == 0 && len(run2Tools) == 0 {
		return nil
	}

	allNames := make(map[string]struct{})
	for k := range run1Tools {
		allNames[k] = struct{}{}
	}
	for k := range run2Tools {
		allNames[k] = struct{}{}
	}

	sortedNames := sliceutil.SortedKeys(allNames)

	diff := &ToolCallsDiff{}
	var run1Total, run2Total int
	// Collect bash tools during the main iteration to avoid a second traversal in computeBashCommandsDiff.
	bashRun1 := make(map[string]ToolCallInfo)
	bashRun2 := make(map[string]ToolCallInfo)

	for _, name := range sortedNames {
		tc1, inRun1 := run1Tools[name]
		tc2, inRun2 := run2Tools[name]