flwr-nightly 1.17.0.dev20250319__py3-none-any.whl → 1.17.0.dev20250321__py3-none-any.whl

flwr/server/superlink/fleet/vce/vce_api.py

@@ -130,9 +130,7 @@ def worker(
                 e_code = ErrorCode.UNKNOWN
 
             reason = str(type(ex)) + ":<'" + str(ex) + "'>"
-            out_mssg = message.create_error_reply(
-                error=Error(code=e_code, reason=reason)
-            )
+            out_mssg = Message(Error(code=e_code, reason=reason), reply_to=message)
 
         finally:
             if out_mssg:

flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -32,7 +32,7 @@ from flwr.common.constant import (
     SUPERLINK_NODE_ID,
     Status,
 )
-from flwr.common.record import ConfigsRecord
+from flwr.common.record import ConfigRecord
 from flwr.common.typing import Run, RunStatus, UserConfig
 from flwr.server.superlink.linkstate.linkstate import LinkState
 from flwr.server.utils import validate_message
@@ -69,7 +69,7 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         # Map run_id to RunRecord
         self.run_ids: dict[int, RunRecord] = {}
         self.contexts: dict[int, Context] = {}
-        self.federation_options: dict[int, ConfigsRecord] = {}
+        self.federation_options: dict[int, ConfigRecord] = {}
         self.message_ins_store: dict[UUID, Message] = {}
         self.message_res_store: dict[UUID, Message] = {}
         self.message_ins_id_to_message_res_id: dict[UUID, UUID] = {}
@@ -158,7 +158,7 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         res_metadata = message.metadata
         with self.lock:
             # Check if the Message it is replying to exists and is valid
-            msg_ins_id = res_metadata.reply_to_message
+            msg_ins_id = res_metadata.reply_to_message_id
             msg_ins = self.message_ins_store.get(UUID(msg_ins_id))
 
             # Ensure that dst_node_id of original Message matches the src_node_id of
@@ -399,7 +399,7 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         fab_version: Optional[str],
         fab_hash: Optional[str],
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> int:
         """Create a new run for the specified `fab_hash`."""
         # Sample a random int64 as run_id
@@ -528,7 +528,7 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
 
         return pending_run_id
 
-    def get_federation_options(self, run_id: int) -> Optional[ConfigsRecord]:
+    def get_federation_options(self, run_id: int) -> Optional[ConfigRecord]:
         """Retrieve the federation options for the specified `run_id`."""
         with self.lock:
             if run_id not in self.run_ids:

flwr/server/superlink/linkstate/linkstate.py

@@ -20,7 +20,7 @@ from typing import Optional
 from uuid import UUID
 
 from flwr.common import Context, Message
-from flwr.common.record import ConfigsRecord
+from flwr.common.record import ConfigRecord
 from flwr.common.typing import Run, RunStatus, UserConfig
 
 
@@ -164,7 +164,7 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
         fab_version: Optional[str],
         fab_hash: Optional[str],
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> int:
         """Create a new run for the specified `fab_hash`."""
 
@@ -236,7 +236,7 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
         """
 
     @abc.abstractmethod
-    def get_federation_options(self, run_id: int) -> Optional[ConfigsRecord]:
+    def get_federation_options(self, run_id: int) -> Optional[ConfigRecord]:
         """Retrieve the federation options for the specified `run_id`.
 
         Parameters
@@ -246,7 +246,7 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
 
         Returns
         -------
-        Optional[ConfigsRecord]
+        Optional[ConfigRecord]
             The federation options for the run if it exists; None otherwise.
         """
 

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -35,18 +35,19 @@ from flwr.common.constant import (
     SUPERLINK_NODE_ID,
     Status,
 )
-from flwr.common.record import ConfigsRecord
+from flwr.common.message import make_message
+from flwr.common.record import ConfigRecord
 from flwr.common.serde import (
     error_from_proto,
     error_to_proto,
-    recordset_from_proto,
-    recordset_to_proto,
+    recorddict_from_proto,
+    recorddict_to_proto,
 )
 from flwr.common.typing import Run, RunStatus, UserConfig
 
 # pylint: disable=E0611
 from flwr.proto.error_pb2 import Error as ProtoError
-from flwr.proto.recordset_pb2 import RecordSet as ProtoRecordSet
+from flwr.proto.recorddict_pb2 import RecordDict as ProtoRecordDict
 
 # pylint: enable=E0611
 from flwr.server.utils.validator import validate_message
@@ -54,8 +55,8 @@ from flwr.server.utils.validator import validate_message
 from .linkstate import LinkState
 from .utils import (
     check_node_availability_for_in_message,
-    configsrecord_from_bytes,
-    configsrecord_to_bytes,
+    configrecord_from_bytes,
+    configrecord_to_bytes,
     context_from_bytes,
     context_to_bytes,
     convert_sint64_to_uint64,
@@ -131,7 +132,7 @@ CREATE TABLE IF NOT EXISTS message_ins(
     run_id                  INTEGER,
     src_node_id             INTEGER,
     dst_node_id             INTEGER,
-    reply_to_message        TEXT,
+    reply_to_message_id     TEXT,
     created_at              REAL,
     delivered_at            TEXT,
     ttl                     REAL,
@@ -150,7 +151,7 @@ CREATE TABLE IF NOT EXISTS message_res(
     run_id                  INTEGER,
     src_node_id             INTEGER,
     dst_node_id             INTEGER,
-    reply_to_message        TEXT,
+    reply_to_message_id     TEXT,
     created_at              REAL,
     delivered_at            TEXT,
     ttl                     REAL,
@@ -373,7 +374,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             return None
 
         res_metadata = message.metadata
-        msg_ins_id = res_metadata.reply_to_message
+        msg_ins_id = res_metadata.reply_to_message_id
         msg_ins = self.get_valid_message_ins(msg_ins_id)
         if msg_ins is None:
             log(
@@ -495,7 +496,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         query = f"""
             SELECT *
             FROM message_res
-            WHERE reply_to_message IN ({",".join(["?"] * len(message_ids))})
+            WHERE reply_to_message_id IN ({",".join(["?"] * len(message_ids))})
             AND delivered_at = "";
         """
         rows = self.query(query, tuple(str(message_id) for message_id in message_ids))
@@ -568,7 +569,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         # Delete reply Message
         query_2 = f"""
             DELETE FROM message_res
-            WHERE reply_to_message IN ({placeholders});
+            WHERE reply_to_message_id IN ({placeholders});
         """
 
         with self.conn:
@@ -726,7 +727,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         fab_version: Optional[str],
         fab_hash: Optional[str],
         override_config: UserConfig,
-        federation_options: ConfigsRecord,
+        federation_options: ConfigRecord,
     ) -> int:
         """Create a new run for the specified `fab_id` and `fab_version`."""
         # Sample a random int64 as run_id
@@ -752,7 +753,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
                 fab_version,
                 fab_hash,
                 override_config_json,
-                configsrecord_to_bytes(federation_options),
+                configrecord_to_bytes(federation_options),
             ]
             data += [
                 now().isoformat(),
@@ -910,7 +911,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         return pending_run_id
 
-    def get_federation_options(self, run_id: int) -> Optional[ConfigsRecord]:
+    def get_federation_options(self, run_id: int) -> Optional[ConfigRecord]:
         """Retrieve the federation options for the specified `run_id`."""
         # Convert the uint64 value to sint64 for SQLite
         sint64_run_id = convert_uint64_to_sint64(run_id)
@@ -923,7 +924,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             return None
 
         row = rows[0]
-        return configsrecord_from_bytes(row["federation_options"])
+        return configrecord_from_bytes(row["federation_options"])
 
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat.
@@ -1064,7 +1065,7 @@ def message_to_dict(message: Message) -> dict[str, Any]:
         "run_id": message.metadata.run_id,
         "src_node_id": message.metadata.src_node_id,
         "dst_node_id": message.metadata.dst_node_id,
-        "reply_to_message": message.metadata.reply_to_message,
+        "reply_to_message_id": message.metadata.reply_to_message_id,
         "created_at": message.metadata.created_at,
         "delivered_at": message.metadata.delivered_at,
         "ttl": message.metadata.ttl,
@@ -1074,7 +1075,7 @@ def message_to_dict(message: Message) -> dict[str, Any]:
     }
 
     if message.has_content():
-        result["content"] = recordset_to_proto(message.content).SerializeToString()
+        result["content"] = recorddict_to_proto(message.content).SerializeToString()
     else:
         result["error"] = error_to_proto(message.error).SerializeToString()
 
@@ -1085,20 +1086,15 @@ def dict_to_message(message_dict: dict[str, Any]) -> Message:
     """Transform dict to Message."""
     content, error = None, None
     if (b_content := message_dict.pop("content")) is not None:
-        content = recordset_from_proto(ProtoRecordSet.FromString(b_content))
+        content = recorddict_from_proto(ProtoRecordDict.FromString(b_content))
     if (b_error := message_dict.pop("error")) is not None:
         error = error_from_proto(ProtoError.FromString(b_error))
 
     # Metadata constructor doesn't allow passing created_at. We set it later
     metadata = Metadata(
-        **{
-            k: v
-            for k, v in message_dict.items()
-            if k not in ["created_at", "delivered_at"]
-        }
+        **{k: v for k, v in message_dict.items() if k not in ["delivered_at"]}
     )
-    msg = Message(metadata=metadata, content=content, error=error)
-    msg.metadata.__dict__["_created_at"] = message_dict["created_at"]
+    msg = make_message(metadata=metadata, content=content, error=error)
     msg.metadata.delivered_at = message_dict["delivered_at"]
     return msg
 

flwr/server/superlink/linkstate/utils.py

@@ -19,7 +19,7 @@ from os import urandom
 from typing import Optional
 from uuid import UUID, uuid4
 
-from flwr.common import ConfigsRecord, Context, Error, Message, Metadata, now, serde
+from flwr.common import ConfigRecord, Context, Error, Message, Metadata, now, serde
 from flwr.common.constant import (
     SUPERLINK_NODE_ID,
     ErrorCode,
@@ -27,11 +27,12 @@ from flwr.common.constant import (
     Status,
     SubStatus,
 )
+from flwr.common.message import make_message
 from flwr.common.typing import RunStatus
 
 # pylint: disable=E0611
 from flwr.proto.message_pb2 import Context as ProtoContext
-from flwr.proto.recordset_pb2 import ConfigsRecord as ProtoConfigsRecord
+from flwr.proto.recorddict_pb2 import ConfigRecord as ProtoConfigRecord
 
 # pylint: enable=E0611
 VALID_RUN_STATUS_TRANSITIONS = {
@@ -171,15 +172,15 @@ def context_from_bytes(context_bytes: bytes) -> Context:
     return serde.context_from_proto(ProtoContext.FromString(context_bytes))
 
 
-def configsrecord_to_bytes(configs_record: ConfigsRecord) -> bytes:
-    """Serialize a `ConfigsRecord` to bytes."""
-    return serde.configs_record_to_proto(configs_record).SerializeToString()
+def configrecord_to_bytes(config_record: ConfigRecord) -> bytes:
+    """Serialize a `ConfigRecord` to bytes."""
+    return serde.config_record_to_proto(config_record).SerializeToString()
 
 
-def configsrecord_from_bytes(configsrecord_bytes: bytes) -> ConfigsRecord:
-    """Deserialize `ConfigsRecord` from bytes."""
-    return serde.configs_record_from_proto(
-        ProtoConfigsRecord.FromString(configsrecord_bytes)
+def configrecord_from_bytes(configrecord_bytes: bytes) -> ConfigRecord:
+    """Deserialize `ConfigRecord` from bytes."""
+    return serde.config_record_from_proto(
+        ProtoConfigRecord.FromString(configrecord_bytes)
     )
 
 
@@ -247,13 +248,14 @@ def create_message_error_unavailable_res_message(
         message_id=str(uuid4()),
         src_node_id=SUPERLINK_NODE_ID,
         dst_node_id=SUPERLINK_NODE_ID,
-        reply_to_message=ins_metadata.message_id,
+        reply_to_message_id=ins_metadata.message_id,
         group_id=ins_metadata.group_id,
         message_type=ins_metadata.message_type,
+        created_at=current_time,
         ttl=ttl,
     )
 
-    return Message(
+    return make_message(
         metadata=metadata,
         error=Error(
             code=(
@@ -270,7 +272,7 @@ def create_message_error_unavailable_res_message(
     )
 
 
-def create_message_error_unavailable_ins_message(reply_to_message: UUID) -> Message:
+def create_message_error_unavailable_ins_message(reply_to_message_id: UUID) -> Message:
     """Error to indicate that the enquired Message had expired before reply arrived or
     that it isn't found."""
     metadata = Metadata(
@@ -278,13 +280,14 @@ def create_message_error_unavailable_ins_message(reply_to_message: UUID) -> Mess
         message_id=str(uuid4()),
         src_node_id=SUPERLINK_NODE_ID,
         dst_node_id=SUPERLINK_NODE_ID,
-        reply_to_message=str(reply_to_message),
+        reply_to_message_id=str(reply_to_message_id),
         group_id="",  # Unknown
         message_type=MessageType.SYSTEM,
+        created_at=now().timestamp(),
         ttl=0,
     )
 
-    return Message(
+    return make_message(
         metadata=metadata,
         error=Error(
             code=ErrorCode.MESSAGE_UNAVAILABLE,
@@ -372,7 +375,7 @@ def verify_found_message_replies(
     ret_dict: dict[UUID, Message] = {}
     current = current_time if current_time else now().timestamp()
     for message_res in found_message_res_list:
-        message_ins_id = UUID(message_res.metadata.reply_to_message)
+        message_ins_id = UUID(message_res.metadata.reply_to_message_id)
         if update_set:
             inquired_message_ids.remove(message_ins_id)
         # Check if the reply Message has expired

flwr/server/superlink/serverappio/serverappio_servicer.py

@@ -22,7 +22,7 @@ from uuid import UUID
 
 import grpc
 
-from flwr.common import ConfigsRecord, Message
+from flwr.common import ConfigRecord, Message
 from flwr.common.constant import SUPERLINK_NODE_ID, Status
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -127,7 +127,7 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
             request.fab_version,
             fab_hash,
             user_config_from_proto(request.override_config),
-            ConfigsRecord(),
+            ConfigRecord(),
         )
         return CreateRunResponse(run_id=run_id)
 
@@ -206,7 +206,7 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
 
         # Delete the instruction Messages and their replies if found
         message_ins_ids_to_delete = {
-            UUID(msg_res.metadata.reply_to_message) for msg_res in messages_res
+            UUID(msg_res.metadata.reply_to_message_id) for msg_res in messages_res
         }
 
         state.delete_messages(message_ins_ids=message_ins_ids_to_delete)

flwr/server/superlink/simulation/simulationio_servicer.py

@@ -24,7 +24,7 @@ from grpc import ServicerContext
 from flwr.common.constant import Status
 from flwr.common.logger import log
 from flwr.common.serde import (
-    configs_record_to_proto,
+    config_record_to_proto,
     context_from_proto,
     context_to_proto,
     fab_to_proto,
@@ -182,5 +182,5 @@ class SimulationIoServicer(simulationio_pb2_grpc.SimulationIoServicer):
             )
             return GetFederationOptionsResponse()
         return GetFederationOptionsResponse(
-            federation_options=configs_record_to_proto(federation_options)
+            federation_options=config_record_to_proto(federation_options)
         )

flwr/server/utils/validator.py

@@ -68,8 +68,8 @@ def validate_message(message: Message, is_reply_message: bool) -> list[str]:
 
     # Link respose to original message
     if not is_reply_message:
-        if metadata.reply_to_message != "":
-            validation_errors.append("`metadata.reply_to_message` MUST not be set.")
+        if metadata.reply_to_message_id != "":
+            validation_errors.append("`metadata.reply_to_message_id` MUST not be set.")
         if metadata.src_node_id != SUPERLINK_NODE_ID:
             validation_errors.append(
                 f"`metadata.src_node_id` is not {SUPERLINK_NODE_ID} (SuperLink node ID)"
@@ -79,8 +79,8 @@ def validate_message(message: Message, is_reply_message: bool) -> list[str]:
                 f"`metadata.dst_node_id` is {SUPERLINK_NODE_ID} (SuperLink node ID)"
             )
     else:
-        if metadata.reply_to_message == "":
-            validation_errors.append("`metadata.reply_to_message` MUST be set.")
+        if metadata.reply_to_message_id == "":
+            validation_errors.append("`metadata.reply_to_message_id` MUST be set.")
         if metadata.src_node_id == SUPERLINK_NODE_ID:
             validation_errors.append(
                 f"`metadata.src_node_id` is {SUPERLINK_NODE_ID} (SuperLink node ID)"

flwr/server/workflow/default_workflows.py

@@ -20,15 +20,16 @@ import timeit
 from logging import INFO, WARN
 from typing import Optional, Union, cast
 
-import flwr.common.recordset_compat as compat
+import flwr.common.recorddict_compat as compat
 from flwr.common import (
+    ArrayRecord,
     Code,
-    ConfigsRecord,
+    ConfigRecord,
     Context,
     EvaluateRes,
     FitRes,
     GetParametersIns,
-    ParametersRecord,
+    Message,
     log,
 )
 from flwr.common.constant import MessageType, MessageTypeLegacy
@@ -77,9 +78,9 @@ class DefaultWorkflow:
 
         # Run federated learning for num_rounds
         start_time = timeit.default_timer()
-        cfg = ConfigsRecord()
+        cfg = ConfigRecord()
         cfg[Key.START_TIME] = start_time
-        context.state.configs_records[MAIN_CONFIGS_RECORD] = cfg
+        context.state.config_records[MAIN_CONFIGS_RECORD] = cfg
 
         for current_round in range(1, context.config.num_rounds + 1):
             log(INFO, "")
@@ -129,21 +130,19 @@ def default_init_params_workflow(grid: Grid, context: Context) -> None:
     )
     if parameters is not None:
         log(INFO, "Using initial global parameters provided by strategy")
-        paramsrecord = compat.parameters_to_parametersrecord(
-            parameters, keep_input=True
-        )
+        arr_record = compat.parameters_to_arrayrecord(parameters, keep_input=True)
     else:
         # Get initial parameters from one of the clients
         log(INFO, "Requesting initial parameters from one random client")
         random_client = context.client_manager.sample(1)[0]
         # Send GetParametersIns and get the response
-        content = compat.getparametersins_to_recordset(GetParametersIns({}))
+        content = compat.getparametersins_to_recorddict(GetParametersIns({}))
         messages = grid.send_and_receive(
             [
-                grid.create_message(
+                Message(
                     content=content,
-                    message_type=MessageTypeLegacy.GET_PARAMETERS,
                     dst_node_id=random_client.node_id,
+                    message_type=MessageTypeLegacy.GET_PARAMETERS,
                     group_id="0",
                 )
             ]
@@ -152,26 +151,26 @@ def default_init_params_workflow(grid: Grid, context: Context) -> None:
 
         if (
             msg.has_content()
-            and compat._extract_status_from_recordset(  # pylint: disable=W0212
+            and compat._extract_status_from_recorddict(  # pylint: disable=W0212
                 "getparametersres", msg.content
             ).code
             == Code.OK
         ):
             log(INFO, "Received initial parameters from one random client")
-            paramsrecord = next(iter(msg.content.parameters_records.values()))
+            arr_record = next(iter(msg.content.array_records.values()))
         else:
             log(
                 WARN,
                 "Failed to receive initial parameters from the client."
                 " Empty initial parameters will be used.",
             )
-            paramsrecord = ParametersRecord()
+            arr_record = ArrayRecord()
 
-    context.state.parameters_records[MAIN_PARAMS_RECORD] = paramsrecord
+    context.state.array_records[MAIN_PARAMS_RECORD] = arr_record
 
     # Evaluate initial parameters
     log(INFO, "Starting evaluation of initial global parameters")
-    parameters = compat.parametersrecord_to_parameters(paramsrecord, keep_input=True)
+    parameters = compat.arrayrecord_to_parameters(arr_record, keep_input=True)
     res = context.strategy.evaluate(0, parameters=parameters)
     if res is not None:
         log(
@@ -192,13 +191,13 @@ def default_centralized_evaluation_workflow(_: Grid, context: Context) -> None:
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
     # Retrieve current_round and start_time from the context
-    cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+    cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
     current_round = cast(int, cfg[Key.CURRENT_ROUND])
     start_time = cast(float, cfg[Key.START_TIME])
 
     # Centralized evaluation
-    parameters = compat.parametersrecord_to_parameters(
-        record=context.state.parameters_records[MAIN_PARAMS_RECORD],
+    parameters = compat.arrayrecord_to_parameters(
+        record=context.state.array_records[MAIN_PARAMS_RECORD],
         keep_input=True,
     )
     res_cen = context.strategy.evaluate(current_round, parameters=parameters)
@@ -224,12 +223,10 @@ def default_fit_workflow(grid: Grid, context: Context) -> None:  # pylint: disab
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
     # Get current_round and parameters
-    cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+    cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
     current_round = cast(int, cfg[Key.CURRENT_ROUND])
-    parametersrecord = context.state.parameters_records[MAIN_PARAMS_RECORD]
-    parameters = compat.parametersrecord_to_parameters(
-        parametersrecord, keep_input=True
-    )
+    arr_record = context.state.array_records[MAIN_PARAMS_RECORD]
+    parameters = compat.arrayrecord_to_parameters(arr_record, keep_input=True)
 
     # Get clients and their respective instructions from strategy
     client_instructions = context.strategy.configure_fit(
@@ -253,10 +250,10 @@ def default_fit_workflow(grid: Grid, context: Context) -> None:  # pylint: disab
 
     # Build out messages
     out_messages = [
-        grid.create_message(
-            content=compat.fitins_to_recordset(fitins, True),
-            message_type=MessageType.TRAIN,
+        Message(
+            content=compat.fitins_to_recorddict(fitins, True),
             dst_node_id=proxy.node_id,
+            message_type=MessageType.TRAIN,
             group_id=str(current_round),
         )
         for proxy, fitins in client_instructions
@@ -282,7 +279,7 @@ def default_fit_workflow(grid: Grid, context: Context) -> None:  # pylint: disab
     for msg in messages:
         if msg.has_content():
             proxy = node_id_to_proxy[msg.metadata.src_node_id]
-            fitres = compat.recordset_to_fitres(msg.content, False)
+            fitres = compat.recorddict_to_fitres(msg.content, False)
             if fitres.status.code == Code.OK:
                 results.append((proxy, fitres))
             else:
@@ -295,10 +292,8 @@ def default_fit_workflow(grid: Grid, context: Context) -> None:  # pylint: disab
 
     # Update the parameters and write history
     if parameters_aggregated:
-        paramsrecord = compat.parameters_to_parametersrecord(
-            parameters_aggregated, True
-        )
-        context.state.parameters_records[MAIN_PARAMS_RECORD] = paramsrecord
+        arr_record = compat.parameters_to_arrayrecord(parameters_aggregated, True)
+        context.state.array_records[MAIN_PARAMS_RECORD] = arr_record
         context.history.add_metrics_distributed_fit(
             server_round=current_round, metrics=metrics_aggregated
         )
@@ -311,12 +306,10 @@ def default_evaluate_workflow(grid: Grid, context: Context) -> None:
         raise TypeError(f"Expect a LegacyContext, but get {type(context).__name__}.")
 
     # Get current_round and parameters
-    cfg = context.state.configs_records[MAIN_CONFIGS_RECORD]
+    cfg = context.state.config_records[MAIN_CONFIGS_RECORD]
     current_round = cast(int, cfg[Key.CURRENT_ROUND])
-    parametersrecord = context.state.parameters_records[MAIN_PARAMS_RECORD]
-    parameters = compat.parametersrecord_to_parameters(
-        parametersrecord, keep_input=True
-    )
+    arr_record = context.state.array_records[MAIN_PARAMS_RECORD]
+    parameters = compat.arrayrecord_to_parameters(arr_record, keep_input=True)
 
     # Get clients and their respective instructions from strategy
     client_instructions = context.strategy.configure_evaluate(
@@ -339,10 +332,10 @@ def default_evaluate_workflow(grid: Grid, context: Context) -> None:
 
     # Build out messages
     out_messages = [
-        grid.create_message(
-            content=compat.evaluateins_to_recordset(evalins, True),
-            message_type=MessageType.EVALUATE,
+        Message(
+            content=compat.evaluateins_to_recorddict(evalins, True),
             dst_node_id=proxy.node_id,
+            message_type=MessageType.EVALUATE,
             group_id=str(current_round),
         )
         for proxy, evalins in client_instructions
@@ -368,7 +361,7 @@ def default_evaluate_workflow(grid: Grid, context: Context) -> None:
     for msg in messages:
         if msg.has_content():
             proxy = node_id_to_proxy[msg.metadata.src_node_id]
-            evalres = compat.recordset_to_evaluateres(msg.content)
+            evalres = compat.recorddict_to_evaluateres(msg.content)
             if evalres.status.code == Code.OK:
                 results.append((proxy, evalres))
             else: