[CRE] Support frequency_list agg type in simulator

core/capabilities/fakes/consensus_frequency_list.go

@@ -0,0 +1,60 @@
+package fakes
+
+import (
+	sdkpb "github.com/smartcontractkit/chainlink-protos/cre/go/sdk"
+	valuespb "github.com/smartcontractkit/chainlink-protos/cre/go/values/pb"
+)
+
+// applyFrequencyListShape reshapes the observation value to match the output
+// type expected by the consensus descriptor. The simulator runs a single node,
+// so the only transformation needed is for frequency_list aggregation, which
+// turns a single value T into [{value: T, count: 1}]. All other aggregation
+// types have matching input and output types, so the value is returned as-is.
+func applyFrequencyListShape(value *valuespb.Value, descriptor *sdkpb.ConsensusDescriptor) *valuespb.Value {
+	if descriptor == nil {
+		return value
+	}
+
+	switch desc := descriptor.GetDescriptor_().(type) {
+	case *sdkpb.ConsensusDescriptor_Aggregation:
+		if descriptor.GetAggregation() == sdkpb.AggregationType_AGGREGATION_TYPE_FREQUENCY_LIST {
+			return frequencyListSingleton(value)
+		}
+
+	case *sdkpb.ConsensusDescriptor_FieldsMap:
+		if value == nil {
+			return value
+		}
+		if value.GetMapValue() == nil {
+			return value
+		}
+		fields := value.GetMapValue().GetFields()
+		changed := false
+		newFields := make(map[string]*valuespb.Value, len(fields))
+		for k, v := range fields {
+			fieldDesc := desc.FieldsMap.GetFields()[k]
+			if fieldDesc != nil && fieldDesc.GetAggregation() == sdkpb.AggregationType_AGGREGATION_TYPE_FREQUENCY_LIST {
+				newFields[k] = frequencyListSingleton(v)
+				changed = true
+			} else {
+				newFields[k] = v
+			}
+		}
+		if changed {
+			return valuespb.NewMapValue(newFields)
+		}
+	}
+
+	return value
+}
+
+// frequencyListSingleton wraps a single observation value as a one-element
+// frequency list: [{value: value, count: 1}].
+func frequencyListSingleton(value *valuespb.Value) *valuespb.Value {
+	return valuespb.NewListValue([]*valuespb.Value{
+		valuespb.NewMapValue(map[string]*valuespb.Value{
+			"value": value,
+			"count": valuespb.NewInt64Value(1),
+		}),
+	})
+}

core/capabilities/fakes/consensus_nodag.go

@@ -64,8 +64,11 @@ func (fc *fakeConsensusNoDAG) close() error {
 	return nil
 }
 
-// NOTE: This fake capability currently bounces back the request payload, ignoring everything else.
-// When the real NoDAG consensus OCR plugin is ready, it should be used here, similarly to how the V1 fake works.
+// Simple bounces back the observation value, reshaping frequency_list fields
+// to their correct output type. The simulator runs a single node, so there is
+// exactly one observation: frequency_list turns a single value T into
+// [{value: T, count: 1}]. All other aggregation types have matching input and
+// output types, so the raw value is returned unchanged.
 func (fc *fakeConsensusNoDAG) Simple(ctx context.Context, metadata capabilities.RequestMetadata, input *sdkpb.SimpleConsensusInputs) (*capabilities.ResponseAndMetadata[*valuespb.Value], caperrors.Error) {
 	fc.eng.Infow("Executing Fake Consensus NoDAG: Simple()", "input", input, "metadata", metadata)
 
@@ -74,8 +77,9 @@ func (fc *fakeConsensusNoDAG) Simple(ctx context.Context, metadata capabilities.
 		if obs.Value == nil {
 			return nil, caperrors.NewPublicUserError(errors.New("input value cannot be nil"), caperrors.InvalidArgument)
 		}
+		response := applyFrequencyListShape(obs.Value, input.Descriptors)
 		responseAndMetadata := capabilities.ResponseAndMetadata[*valuespb.Value]{
-			Response:         obs.Value,
+			Response:         response,
 			ResponseMetadata: capabilities.ResponseMetadata{},
 		}
 		return &responseAndMetadata, nil