flwr-nightly 1.26.0.dev20260117__tar.gz → 1.26.0.dev20260119__tar.gz

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.26.0.dev20260117
+Version: 1.26.0.dev20260119
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/cli/config_migration.py

@@ -208,7 +208,7 @@ def migrate(
 def migrate_if_legacy_usage(
     superlink: str,
     args: list[str],
-) -> None:
+) -> bool:
     """Migrate legacy TOML configuration to Flower config if legacy usage is
     detected."""
     # Trigger the same typer error when detecting unexpected extra args
@@ -217,9 +217,10 @@ def migrate_if_legacy_usage(
 
     # Skip migration if no legacy usage is detected
     if not _is_legacy_usage(superlink, args):
-        return
+        return False
 
     migrate(
         app=Path(superlink),
         toml_federation=args[0] if len(args) == 1 else None,
     )
+    return True

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/cli/config_utils.py

@@ -307,16 +307,9 @@ def load_certificate_in_connection(
     typer.Exit
         If the configuration is invalid or the certificate file cannot be read.
     """
-    if connection.insecure is None:
-        raise ValueError(
-            f"SuperLink connection '{connection.name}' is missing insecure setting."
-        )
-
-    insecure = connection.insecure
-
     # Process root certificates
     if root_certificates := connection.root_certificates:
-        if insecure:
+        if connection.insecure:
             typer.secho(
                 "❌ `root-certificates` were provided but the `insecure` parameter "
                 "is set to `True`.",

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/cli/flower_config.py

@@ -215,18 +215,19 @@ def serialize_superlink_connection(connection: SuperLinkConnection) -> dict[str,
     dict[str, Any]
         Dictionary representation suitable for TOML serialization.
     """
+    # pylint: disable=protected-access
     conn_dict: dict[str, Any] = {
-        SuperLinkConnectionTomlKey.ADDRESS: connection.address,
-        SuperLinkConnectionTomlKey.ROOT_CERTIFICATES: connection.root_certificates,
-        SuperLinkConnectionTomlKey.INSECURE: connection.insecure,
-        SuperLinkConnectionTomlKey.ENABLE_ACCOUNT_AUTH: connection.enable_account_auth,
-        SuperLinkConnectionTomlKey.FEDERATION: connection.federation,
+        SuperLinkConnectionTomlKey.ADDRESS: connection._address,
+        SuperLinkConnectionTomlKey.ROOT_CERTIFICATES: connection._root_certificates,
+        SuperLinkConnectionTomlKey.INSECURE: connection._insecure,
+        SuperLinkConnectionTomlKey.ENABLE_ACCOUNT_AUTH: connection._enable_account_auth,
+        SuperLinkConnectionTomlKey.FEDERATION: connection._federation,
     }
     # Remove None values
     conn_dict = {k: v for k, v in conn_dict.items() if v is not None}
 
-    if connection.options is not None:
-        options_dict = _serialize_simulation_options(connection.options)
+    if connection._options is not None:
+        options_dict = _serialize_simulation_options(connection._options)
         conn_dict[SuperLinkConnectionTomlKey.OPTIONS] = options_dict
 
     return conn_dict

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/cli/pull.py

@@ -40,10 +40,7 @@ from .utils import flwr_cli_grpc_exc_handler, init_channel, load_cli_auth_plugin
 def pull(  # pylint: disable=R0914
     run_id: Annotated[
         int,
-        typer.Option(
-            "--run-id",
-            help="Run ID to pull artifacts from.",
-        ),
+        typer.Argument(help="Run ID to pull artifacts from."),
     ],
     app: Annotated[
         Path,

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/cli/typing.py

@@ -23,6 +23,8 @@ from flwr.cli.constant import (
     SuperLinkConnectionTomlKey,
 )
 
+_ERROR_MSG_FMT = "SuperLinkConnection.%s is None"
+
 
 @dataclass
 class SimulationClientResources:
@@ -94,59 +96,126 @@ class SuperLinkConnection:
     """SuperLink connection configuration for CLI commands."""
 
     name: str
-    address: str | None = None
-    root_certificates: str | None = None
-    insecure: bool | None = None
-    enable_account_auth: bool | None = None
-    federation: str | None = None
-    options: SuperLinkSimulationOptions | None = None
+    _address: str | None = None
+    _root_certificates: str | None = None
+    _insecure: bool | None = None
+    _enable_account_auth: bool | None = None
+    _federation: str | None = None
+    _options: SuperLinkSimulationOptions | None = None
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(
+        self,
+        name: str,
+        address: str | None = None,
+        root_certificates: str | None = None,
+        insecure: bool | None = None,
+        enable_account_auth: bool | None = None,
+        federation: str | None = None,
+        options: SuperLinkSimulationOptions | None = None,
+    ) -> None:
+        self.name = name
+        self._address = address
+        self._root_certificates = root_certificates
+        self._insecure = insecure
+        self._enable_account_auth = enable_account_auth
+        self._federation = federation
+        self._options = options
+
+        self.__post_init__()
+
+    @property
+    def address(self) -> str:
+        """Return the address."""
+        if self._address is None:
+            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.ADDRESS)
+        return self._address
+
+    @property
+    def root_certificates(self) -> str:
+        """Return the root certificates."""
+        if self._root_certificates is None:
+            raise ValueError(
+                _ERROR_MSG_FMT % SuperLinkConnectionTomlKey.ROOT_CERTIFICATES
+            )
+        return self._root_certificates
+
+    @property
+    def insecure(self) -> bool:
+        """Return the insecure flag."""
+        if self._insecure is None:
+            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.INSECURE)
+        return self._insecure
+
+    @property
+    def enable_account_auth(self) -> bool:
+        """Return the enable_account_auth flag."""
+        if self._enable_account_auth is None:
+            raise ValueError(
+                _ERROR_MSG_FMT % SuperLinkConnectionTomlKey.ENABLE_ACCOUNT_AUTH
+            )
+        return self._enable_account_auth
+
+    @property
+    def federation(self) -> str:
+        """Return the federation."""
+        if self._federation is None:
+            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.FEDERATION)
+        return self._federation
+
+    @property
+    def options(self) -> SuperLinkSimulationOptions:
+        """Return the simulation options."""
+        if self._options is None:
+            raise ValueError(_ERROR_MSG_FMT % SuperLinkConnectionTomlKey.OPTIONS)
+        return self._options
 
     def __post_init__(self) -> None:
         """Validate SuperLink connection configuration."""
         err_prefix = f"Invalid value for key '%s' in connection '{self.name}': "
-        if self.address is not None and not isinstance(self.address, str):
+        if self._address is not None and not isinstance(self._address, str):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.ADDRESS
-                + f"expected str, but got {type(self.address).__name__}."
+                + f"expected str, but got {type(self._address).__name__}."
             )
-        if self.root_certificates is not None and not isinstance(
-            self.root_certificates, str
+        if self._root_certificates is not None and not isinstance(
+            self._root_certificates, str
         ):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.ROOT_CERTIFICATES
-                + f"expected str, but got {type(self.root_certificates).__name__}."
+                + f"expected str, but got {type(self._root_certificates).__name__}."
             )
 
         # Ensure root certificates path is absolute
-        if self.root_certificates is not None:
-            if not Path(self.root_certificates).is_absolute():
+        if self._root_certificates is not None:
+            if not Path(self._root_certificates).is_absolute():
                 raise ValueError(
                     err_prefix % SuperLinkConnectionTomlKey.ROOT_CERTIFICATES
                     + "expected absolute path, but got relative path "
-                    f"'{self.root_certificates}'."
+                    f"'{self._root_certificates}'."
                 )
 
-        if self.insecure is not None and not isinstance(self.insecure, bool):
+        if self._insecure is not None and not isinstance(self._insecure, bool):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.INSECURE
-                + f"expected bool, but got {type(self.insecure).__name__}."
+                + f"expected bool, but got {type(self._insecure).__name__}."
             )
-        if self.enable_account_auth is not None and not isinstance(
-            self.enable_account_auth, bool
+        if self._enable_account_auth is not None and not isinstance(
+            self._enable_account_auth, bool
         ):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.ENABLE_ACCOUNT_AUTH
-                + f"expected bool, but got {type(self.enable_account_auth).__name__}."
+                + f"expected bool, but got {type(self._enable_account_auth).__name__}."
             )
 
-        if self.federation is not None and not isinstance(self.federation, str):
+        if self._federation is not None and not isinstance(self._federation, str):
             raise ValueError(
                 err_prefix % SuperLinkConnectionTomlKey.FEDERATION
-                + f"expected str, but got {type(self.federation).__name__}."
+                + f"expected str, but got {type(self._federation).__name__}."
             )
 
         # The connection needs to have either an address or options (or both).
-        if self.address is None and self.options is None:
+        if self._address is None and self._options is None:
             raise ValueError(
                 "Invalid SuperLink connection format: "
                 f"'{SuperLinkConnectionTomlKey.ADDRESS}' and/or "

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/cli/utils.py

@@ -458,13 +458,17 @@ def init_channel(
     return channel
 
 
-def init_channel_from_connection(connection: SuperLinkConnection) -> grpc.Channel:
+def init_channel_from_connection(
+    connection: SuperLinkConnection, auth_plugin: CliAuthPlugin | None = None
+) -> grpc.Channel:
     """Initialize gRPC channel to the Control API.
 
     Parameters
     ----------
     connection : SuperLinkConnection
         SuperLink connection configuration.
+    auth_plugin : CliAuthPlugin | None (default: None)
+        Authentication plugin instance for handling credentials.
 
     Returns
     -------
@@ -474,18 +478,12 @@ def init_channel_from_connection(connection: SuperLinkConnection) -> grpc.Channe
     root_certificates_bytes = load_certificate_in_connection(connection)
 
     # Load authentication plugin
-    auth_plugin = load_cli_auth_plugin_from_connection(connection)
+    if auth_plugin is None:
+        auth_plugin = load_cli_auth_plugin_from_connection(connection)
 
     # Load tokens
     auth_plugin.load_tokens()
 
-    # Ensure address and insecure are set
-    if connection.address is None or connection.insecure is None:
-        raise ValueError(
-            f"Couldn't create channel. SuperLink connection '{connection.name}'"
-            " is missing address or insecure setting."
-        )
-
     # Create the gRPC channel
     channel = create_channel(
         server_address=connection.address,

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/supercore/constant.py

@@ -64,6 +64,16 @@ MESSAGE_TIME_ENTRY_MAX_AGE_SECONDS = 3600
 # System message type
 SYSTEM_MESSAGE_TYPE = "system"
 
+# SQLite PRAGMA settings for optimal performance and correctness
+SQLITE_PRAGMAS = (
+    ("journal_mode", "WAL"),  # Enable Write-Ahead Logging for better concurrency
+    ("synchronous", "NORMAL"),
+    ("foreign_keys", "ON"),
+    ("cache_size", "-64000"),  # 64MB cache
+    ("temp_store", "MEMORY"),  # In-memory temp tables
+    ("mmap_size", "268435456"),  # 256MB memory-mapped I/O
+)
+
 
 class NodeStatus:
     """Event log writer types."""

flwr_nightly-1.26.0.dev20260119/py/flwr/supercore/credential_store/__init__.py

@@ -0,0 +1,33 @@
+# Copyright 2026 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Credential store for Flower."""
+
+
+from .credential_store import CredentialStore
+from .file_credential_store import FileCredentialStore
+
+
+def get_credential_store() -> CredentialStore:
+    """Get the credential store instance.
+
+    Currently, only FileCredentialStore is implemented.
+    """
+    return FileCredentialStore()
+
+
+__all__ = [
+    "CredentialStore",
+    "get_credential_store",
+]

flwr_nightly-1.26.0.dev20260119/py/flwr/supercore/credential_store/credential_store.py

@@ -0,0 +1,34 @@
+# Copyright 2026 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Abstract base classes for credential store."""
+
+
+from abc import ABC, abstractmethod
+
+
+class CredentialStore(ABC):
+    """Abstract base class for credential store."""
+
+    @abstractmethod
+    def set(self, key: str, value: bytes) -> None:
+        """Set a credential in the store."""
+
+    @abstractmethod
+    def get(self, key: str) -> bytes | None:
+        """Get a credential from the store."""
+
+    @abstractmethod
+    def delete(self, key: str) -> None:
+        """Delete a credential from the store."""

flwr_nightly-1.26.0.dev20260119/py/flwr/supercore/credential_store/file_credential_store.py

@@ -0,0 +1,76 @@
+# Copyright 2026 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""File-based credential store implementation."""
+
+
+import base64
+from pathlib import Path
+from typing import cast
+
+import yaml
+
+from ..utils import get_flwr_home
+from .credential_store import CredentialStore
+
+CREDENTIAL_FILE_PATH = get_flwr_home() / "credentials.yaml"
+
+
+class FileCredentialStore(CredentialStore):
+    """File-based credential store implementation."""
+
+    def __init__(self, file_path: Path | None = None) -> None:
+        """Initialize the file credential store.
+
+        Parameters
+        ----------
+        file_path : Path | None
+            Path to the credentials file. If None, uses default path.
+        """
+        self.file_path = file_path or CREDENTIAL_FILE_PATH
+
+    def _load_credentials(self) -> dict[str, str]:
+        """Load credentials from file."""
+        if not self.file_path.exists():
+            return {}
+        with self.file_path.open("r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+            return cast(dict[str, str], data) if data else {}
+
+    def _save_credentials(self, credentials: dict[str, str]) -> None:
+        """Save credentials to file."""
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        with self.file_path.open("w", encoding="utf-8") as f:
+            yaml.safe_dump(credentials, f)
+
+    def set(self, key: str, value: bytes) -> None:
+        """Set a credential in the store."""
+        credentials = self._load_credentials()
+        credentials[key] = base64.b64encode(value).decode("utf-8")
+        self._save_credentials(credentials)
+
+    def get(self, key: str) -> bytes | None:
+        """Get a credential from the store."""
+        credentials = self._load_credentials()
+        encoded_value = credentials.get(key)
+        if encoded_value is None:
+            return None
+        return base64.b64decode(encoded_value)
+
+    def delete(self, key: str) -> None:
+        """Delete a credential from the store."""
+        credentials = self._load_credentials()
+        if key in credentials:
+            del credentials[key]
+            self._save_credentials(credentials)

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/supercore/sqlite_mixin.py

@@ -23,6 +23,7 @@ from logging import DEBUG, ERROR
 from typing import Any
 
 from flwr.common.logger import log
+from flwr.supercore.constant import SQLITE_PRAGMAS
 
 DictOrTuple = tuple[Any, ...] | dict[str, Any]
 
@@ -92,13 +93,9 @@ class SqliteMixin(ABC):
                 )
         """
         self._conn = sqlite3.connect(self.database_path)
-        # Enable Write-Ahead Logging (WAL) for better concurrency
-        self._conn.execute("PRAGMA journal_mode = WAL;")
-        self._conn.execute("PRAGMA synchronous = NORMAL;")
-        self._conn.execute("PRAGMA foreign_keys = ON;")
-        self._conn.execute("PRAGMA cache_size = -64000;")  # 64MB cache
-        self._conn.execute("PRAGMA temp_store = MEMORY;")  # In-memory temp tables
-        self._conn.execute("PRAGMA mmap_size = 268435456;")  # 256MB memory-mapped I/O
+        # Set SQLite pragmas for optimal performance and correctness
+        for pragma, value in SQLITE_PRAGMAS:
+            self._conn.execute(f"PRAGMA {pragma} = {value};")
         self._conn.row_factory = dict_factory
 
         if log_queries:

{flwr_nightly-1.26.0.dev20260117 → flwr_nightly-1.26.0.dev20260119}/py/flwr/supercore/state/schema/corestate_tables.py

@@ -17,15 +17,20 @@
 
 from sqlalchemy import Column, Float, Integer, MetaData, String, Table
 
-corestate_metadata = MetaData()
 
-# ------------------------------------------------------------------------------
-#  Table: token_store
-# ------------------------------------------------------------------------------
-token_store = Table(
-    "token_store",
-    corestate_metadata,
-    Column("run_id", Integer, primary_key=True, nullable=True),
-    Column("token", String, unique=True, nullable=False),
-    Column("active_until", Float),
-)
+def create_corestate_metadata() -> MetaData:
+    """Create and return MetaData with CoreState table definitions."""
+    metadata = MetaData()
+
+    # --------------------------------------------------------------------------
+    #  Table: token_store
+    # --------------------------------------------------------------------------
+    Table(
+        "token_store",
+        metadata,
+        Column("run_id", Integer, primary_key=True, nullable=True),
+        Column("token", String, unique=True, nullable=False),
+        Column("active_until", Float),
+    )
+
+    return metadata

flwr_nightly-1.26.0.dev20260119/py/flwr/supercore/state/schema/linkstate_tables.py

@@ -0,0 +1,152 @@
+# Copyright 2026 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""SQLAlchemy Core Table definitions for LinkState."""
+
+
+from sqlalchemy import (
+    TIMESTAMP,
+    Column,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    LargeBinary,
+    MetaData,
+    String,
+    Table,
+    UniqueConstraint,
+)
+
+
+def create_linkstate_metadata() -> MetaData:
+    """Create and return MetaData with LinkState table definitions."""
+    metadata = MetaData()
+
+    # --------------------------------------------------------------------------
+    #  Table: node
+    # --------------------------------------------------------------------------
+    Table(
+        "node",
+        metadata,
+        Column("node_id", Integer, unique=True),
+        Column("owner_aid", String),
+        Column("owner_name", String),
+        Column("status", String),
+        Column("registered_at", String),
+        Column("last_activated_at", String, nullable=True),
+        Column("last_deactivated_at", String, nullable=True),
+        Column("unregistered_at", String, nullable=True),
+        Column("online_until", TIMESTAMP, nullable=True),
+        Column("heartbeat_interval", Float),
+        Column("public_key", LargeBinary, unique=True),
+        # Indexes
+        # Used in delete_node and get_node_info (security/filtering)
+        Index("idx_node_owner_aid", "owner_aid"),
+        # Used in get_nodes and activation checks (frequent filtering)
+        Index("idx_node_status", "status"),
+        # Used in heartbeat checks to efficiently find expired nodes
+        Index("idx_online_until", "online_until"),
+    )
+
+    # --------------------------------------------------------------------------
+    #  Table: run
+    # --------------------------------------------------------------------------
+    Table(
+        "run",
+        metadata,
+        Column("run_id", Integer, unique=True),
+        Column("fab_id", String),
+        Column("fab_version", String),
+        Column("fab_hash", String),
+        Column("override_config", String),
+        Column("pending_at", String),
+        Column("starting_at", String),
+        Column("running_at", String),
+        Column("finished_at", String),
+        Column("sub_status", String),
+        Column("details", String),
+        Column("federation", String),
+        Column("federation_options", LargeBinary),
+        Column("flwr_aid", String),
+        Column("bytes_sent", Integer, server_default="0"),
+        Column("bytes_recv", Integer, server_default="0"),
+        Column("clientapp_runtime", Float, server_default="0.0"),
+    )
+
+    # --------------------------------------------------------------------------
+    #  Table: logs
+    # --------------------------------------------------------------------------
+    Table(
+        "logs",
+        metadata,
+        Column("timestamp", Float),
+        Column("run_id", Integer, ForeignKey("run.run_id")),
+        Column("node_id", Integer),
+        Column("log", String),
+        # Composite PK
+        UniqueConstraint("timestamp", "run_id", "node_id"),
+    )
+
+    # --------------------------------------------------------------------------
+    #  Table: context
+    # --------------------------------------------------------------------------
+    Table(
+        "context",
+        metadata,
+        Column("run_id", Integer, ForeignKey("run.run_id"), unique=True),
+        Column("context", LargeBinary),
+    )
+
+    # --------------------------------------------------------------------------
+    #  Table: message_ins
+    # --------------------------------------------------------------------------
+    Table(
+        "message_ins",
+        metadata,
+        Column("message_id", String, unique=True),
+        Column("group_id", String),
+        Column("run_id", Integer, ForeignKey("run.run_id")),
+        Column("src_node_id", Integer),
+        Column("dst_node_id", Integer),
+        Column("reply_to_message_id", String),
+        Column("created_at", Float),
+        Column("delivered_at", String),
+        Column("ttl", Float),
+        Column("message_type", String),
+        Column("content", LargeBinary, nullable=True),
+        Column("error", LargeBinary, nullable=True),
+    )
+
+    # --------------------------------------------------------------------------
+    #  Table: message_res
+    # --------------------------------------------------------------------------
+    Table(
+        "message_res",
+        metadata,
+        Column("message_id", String, unique=True),
+        Column("group_id", String),
+        Column("run_id", Integer, ForeignKey("run.run_id")),
+        Column("src_node_id", Integer),
+        Column("dst_node_id", Integer),
+        Column("reply_to_message_id", String),
+        Column("created_at", Float),
+        Column("delivered_at", String),
+        Column("ttl", Float),
+        Column("message_type", String),
+        Column("content", LargeBinary, nullable=True),
+        Column("error", LargeBinary, nullable=True),
+    )
+
+    return metadata