flwr 1.24.0__py3-none-any.whl → 1.25.0__py3-none-any.whl

flwr/cli/app_cmd/review.py

@@ -36,6 +36,7 @@ from flwr.supercore.primitives.asymmetric_ed25519 import (
     load_private_key,
     sign_message,
 )
+from flwr.supercore.utils import parse_app_spec, request_download_link
 
 from ..auth_plugin.oidc_cli_plugin import OidcCliPlugin
 from ..config_utils import (
@@ -45,7 +46,7 @@ from ..config_utils import (
 )
 from ..constant import FEDERATION_CONFIG_HELP_MESSAGE
 from ..install import install_from_fab
-from ..utils import load_cli_auth_plugin, parse_app_spec, request_download_link
+from ..utils import load_cli_auth_plugin
 
 TRY_AGAIN_MESSAGE = "Please try again or press CTRL+C to abort.\n"
 
@@ -104,12 +105,21 @@ def review(
     token = auth_plugin.access_token
 
     # Validate app version and ID format
-    app_id, app_version = parse_app_spec(app_spec)
+    try:
+        app_id, app_version = parse_app_spec(app_spec)
+    except ValueError as e:
+        typer.secho(f"❌ {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from e
 
     # Download FAB
     typer.secho("Downloading FAB... ", fg=typer.colors.BLUE)
     url = f"{PLATFORM_API_URL}/hub/fetch-fab"
-    presigned_url = request_download_link(app_id, app_version, url, "fab_url")
+    try:
+        presigned_url, _ = request_download_link(app_id, app_version, url, "fab_url")
+    except ValueError as e:
+        typer.secho(f"❌ {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from e
+
     fab_bytes = _download_fab(presigned_url)
 
     # Unpack FAB

flwr/cli/federation/show.py

@@ -41,6 +41,7 @@ from flwr.proto.control_pb2 import (  # pylint: disable=E0611
 from flwr.proto.control_pb2_grpc import ControlStub
 from flwr.proto.node_pb2 import NodeInfo  # pylint: disable=E0611
 from flwr.supercore.constant import NOOP_FEDERATION
+from flwr.supercore.utils import humanize_duration
 
 from ..run_utils import RunRow, format_runs
 from ..utils import flwr_cli_grpc_exc_handler, init_channel, load_cli_auth_plugin
@@ -262,7 +263,7 @@ def _to_runs_table(run_list: list[RunRow]) -> Table:
             f"[bold]{row.run_id}[/bold]",
             f"@{row.fab_id}=={row.fab_version}",
             f"[{status_style}]{row.status_text}[/{status_style}]",
-            row.elapsed,
+            f"{humanize_duration(row.elapsed)}",
         )
         table.add_row(*formatted_row)
 
@@ -298,7 +299,7 @@ def _to_json(
     for node in nodes:
         nodes_list.append(
             {
-                "node_id": node.node_id,
+                "node_id": f"{node.node_id}",
                 "owner": node.owner_name,
                 "status": node.status,
             }
@@ -307,7 +308,7 @@ def _to_json(
     for run in runs:
         runs_list.append(
             {
-                "run_id": run.run_id,
+                "run_id": f"{run.run_id}",
                 "app": f"@{run.fab_id}=={run.fab_version}",
                 "status": run.status_text,
                 "elapsed": run.elapsed,

flwr/cli/ls.py

@@ -40,6 +40,7 @@ from flwr.proto.control_pb2 import (  # pylint: disable=E0611
     ListRunsResponse,
 )
 from flwr.proto.control_pb2_grpc import ControlStub
+from flwr.supercore.utils import humanize_bytes, humanize_duration
 
 from .run_utils import RunRow, format_runs
 from .utils import flwr_cli_grpc_exc_handler, init_channel, load_cli_auth_plugin
@@ -231,7 +232,7 @@ def _to_table(run_list: list[RunRow]) -> Table:
             row.federation,
             f"@{row.fab_id}=={row.fab_version}",
             f"[{status_style}]{row.status_text}[/{status_style}]",
-            row.elapsed,
+            humanize_duration(row.elapsed),
             status_changed_at,
         )
         table.add_row(*formatted_row)
@@ -265,11 +266,39 @@ def _to_detail_table(run: RunRow) -> Table:
     table.add_row("App", f"@{run.fab_id}=={run.fab_version}")
     table.add_row("FAB Hash", f"{run.fab_hash[:8]}...{run.fab_hash[-8:]}")
     table.add_row("Status", f"[{status_style}]{run.status_text}[/{status_style}]")
-    table.add_row("Elapsed", f"[blue]{run.elapsed}[/blue]")
+    table.add_row("Elapsed", f"[blue]{humanize_duration(run.elapsed)}[/blue]")
     table.add_row("Pending At", run.pending_at)
     table.add_row("Starting At", run.starting_at)
     table.add_row("Running At", run.running_at)
     table.add_row("Finished At", run.finished_at)
+    table.add_row(
+        "Network traffic (inbound)",
+        f"[blue]{humanize_bytes(run.network_traffic_inbound)}[/blue]",
+    )
+    table.add_row(
+        "Network traffic (outbound)",
+        f"[blue]{humanize_bytes(run.network_traffic_outbound)}[/blue]",
+    )
+    table.add_row(
+        "Network Traffic (total)",
+        "[blue]"
+        f"{humanize_bytes(run.network_traffic_inbound + run.network_traffic_outbound)}"
+        "[/blue]",
+    )
+    table.add_row(
+        "Compute Time (ServerApp)",
+        f"[blue]{humanize_duration(run.compute_time_serverapp)}[/blue]",
+    )
+    table.add_row(
+        "Compute Time (ClientApp)",
+        f"[blue]{humanize_duration(run.compute_time_clientapp)}[/blue]",
+    )
+    table.add_row(
+        "Compute Time (total)",
+        "[blue]"
+        f"{humanize_duration(run.compute_time_serverapp + run.compute_time_clientapp)}"
+        "[/blue]",
+    )
 
     return table
 
@@ -291,7 +320,7 @@ def _to_json(run_list: list[RunRow]) -> str:
     for row in run_list:
         runs_list.append(
             {
-                "run-id": row.run_id,
+                "run-id": f"{row.run_id}",
                 "federation": row.federation,
                 "fab-id": row.fab_id,
                 "fab-name": row.fab_id.split("/")[-1],
@@ -303,6 +332,18 @@ def _to_json(run_list: list[RunRow]) -> str:
                 "starting-at": row.starting_at,
                 "running-at": row.running_at,
                 "finished-at": row.finished_at,
+                "network-traffic": {
+                    "inbound-bytes": row.network_traffic_inbound,
+                    "outbound-bytes": row.network_traffic_outbound,
+                    "total-bytes": row.network_traffic_inbound
+                    + row.network_traffic_outbound,
+                },
+                "compute-time": {
+                    "serverapp-seconds": row.compute_time_serverapp,
+                    "clientapp-seconds": row.compute_time_clientapp,
+                    "total-seconds": row.compute_time_serverapp
+                    + row.compute_time_clientapp,
+                },
             }
         )
 

flwr/cli/new/new.py

@@ -16,93 +16,84 @@
 
 
 import io
-import re
 import zipfile
-from enum import Enum
 from pathlib import Path
-from string import Template
-from typing import Annotated
+from typing import Annotated, cast
 
 import requests
 import typer
 
 from flwr.supercore.constant import PLATFORM_API_URL
+from flwr.supercore.utils import parse_app_spec, request_download_link
 
-from ..utils import (
-    is_valid_project_name,
-    parse_app_spec,
-    prompt_options,
-    prompt_text,
-    request_download_link,
-    sanitize_project_name,
-)
+from ..utils import prompt_options, prompt_text
 
 
-class MlFramework(str, Enum):
-    """Available frameworks."""
-
-    PYTORCH = "PyTorch"
-    TENSORFLOW = "TensorFlow"
-    SKLEARN = "sklearn"
-    HUGGINGFACE = "HuggingFace"
-    JAX = "JAX"
-    MLX = "MLX"
-    NUMPY = "NumPy"
-    XGBOOST = "XGBoost"
-    FLOWERTUNE = "FlowerTune"
-    BASELINE = "Flower Baseline"
-    PYTORCH_LEGACY_API = "PyTorch (Legacy API, deprecated)"
-
-
-class LlmChallengeName(str, Enum):
-    """Available LLM challenges."""
-
-    GENERALNLP = "GeneralNLP"
-    FINANCE = "Finance"
-    MEDICAL = "Medical"
-    CODE = "Code"
-
-
-class TemplateNotFound(Exception):
-    """Raised when template does not exist."""
-
-
-def load_template(name: str) -> str:
-    """Load template from template directory and return as text."""
-    tpl_dir = (Path(__file__).parent / "templates").absolute()
-    tpl_file_path = tpl_dir / name
-
-    if not tpl_file_path.is_file():
-        raise TemplateNotFound(f"Template '{name}' not found")
-
-    with open(tpl_file_path, encoding="utf-8") as tpl_file:
-        return tpl_file.read()
-
-
-def render_template(template: str, data: dict[str, str]) -> str:
-    """Render template."""
-    tpl_file = load_template(template)
-    tpl = Template(tpl_file)
-    if ".gitignore" not in template:
-        return tpl.substitute(data)
-    return tpl.template
-
+# pylint: disable=too-many-locals,too-many-branches,too-many-statements
+def new(
+    app_spec: Annotated[
+        str | None,
+        typer.Argument(
+            help="Flower app specifier. Use the format "
+            "'@account_name/app_name' or '@account_name/app_name==x.y.z'. "
+            "Version is optional (defaults to latest)."
+        ),
+    ] = None,
+    framework: Annotated[
+        str | None,
+        typer.Option(case_sensitive=False, help="Deprecated. The ML framework to use"),
+    ] = None,
+    username: Annotated[
+        str | None,
+        typer.Option(
+            case_sensitive=False, help="Deprecated. The Flower username of the author"
+        ),
+    ] = None,
+) -> None:
+    """Create new Flower App."""
+    if framework is not None or username is not None:
+        typer.secho(
+            "❌ The --framework and --username options are deprecated and will be "
+            "removed in future versions of Flower. Please provide an app specifier "
+            "after `flwr new` instead, e.g., '@account_name/app_name' or "
+            "'@account_name/app_name==x.y.z'.",
+            fg=typer.colors.RED,
+            bold=True,
+            err=True,
+        )
+        raise typer.Exit(code=1)
 
-def create_file(file_path: Path, content: str) -> None:
-    """Create file including all nessecary directories and write content into file."""
-    file_path.parent.mkdir(exist_ok=True)
-    file_path.write_text(content, encoding="utf-8")
+    if app_spec is None:
+        # Fetch recommended apps
+        print(
+            typer.style(
+                "\n🌸 Fetching recommended apps...",
+                fg=typer.colors.GREEN,
+                bold=True,
+            )
+        )
+        apps = fetch_recommended_apps()
 
+        if not apps:
+            typer.secho(
+                "No recommended apps found. Please provide an app specifier manually.",
+                fg=typer.colors.YELLOW,
+            )
+            app_spec = prompt_text("Please provide the app specifier")
+        else:
+            # Extract app_ids and show selection menu
+            app_ids = [app["app_id"] for app in apps]
+            app_spec = prompt_options(
+                "Select a Flower App to create by entering "
+                "the number from the list below:",
+                app_ids,
+            )
 
-def render_and_create(file_path: Path, template: str, context: dict[str, str]) -> None:
-    """Render template and write to file."""
-    content = render_template(template, context)
-    create_file(file_path, content)
+    # Download remote app
+    download_remote_app_via_api(app_spec)
 
 
-def print_success_prompt(
-    package_name: str, llm_challenge_str: str | None = None
-) -> None:
+def print_success_prompt(package_name: str) -> None:
     """Print styled setup instructions for running a new Flower App after creation."""
     prompt = typer.style(
         "🎊 Flower App creation successful.\n\n"
@@ -111,10 +102,8 @@ def print_success_prompt(
         bold=True,
     )
 
-    _add = "	huggingface-cli login\n" if llm_challenge_str else ""
-
     prompt += typer.style(
-        f"	cd {package_name} && pip install -e .\n" + _add + "\n",
+        f"	cd {package_name} && pip install -e .\n\n",
         fg=typer.colors.BRIGHT_CYAN,
         bold=True,
     )
@@ -141,6 +130,25 @@ def print_success_prompt(
     print(prompt)
 
 
+def fetch_recommended_apps() -> list[dict[str, str]]:
+    """Fetch recommended apps from Platform API."""
+    url = f"{PLATFORM_API_URL}/hub/apps?tag=recommended"
+    try:
+        response = requests.get(url, headers={"accept": "application/json"}, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        apps = data.get("apps", [])
+        return cast(list[dict[str, str]], apps)
+
+    except requests.RequestException as e:
+        typer.secho(
+            f"❌ Failed to fetch recommended apps: {e}",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(code=1) from e
+
+
 # Security: prevent zip-slip
 def _safe_extract_zip(zf: zipfile.ZipFile, dest_dir: Path) -> None:
     """Extract ZIP file into destination directory."""
@@ -205,7 +213,12 @@ def _download_zip_to_memory(presigned_url: str) -> io.BytesIO:
 def download_remote_app_via_api(app_spec: str) -> None:
     """Download App from Platform API."""
     # Validate app version and ID format
-    app_id, app_version = parse_app_spec(app_spec)
+    try:
+        app_id, app_version = parse_app_spec(app_spec)
+    except ValueError as e:
+        typer.secho(f"❌ {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from e
+
     app_name = app_id.split("/")[1]
 
     project_dir = Path.cwd() / app_name
@@ -219,236 +232,32 @@ def download_remote_app_via_api(app_spec: str) -> None:
         ):
             return
 
-    print(
-        typer.style(
-            f"\n🔗 Requesting download link for {app_id}...",
-            fg=typer.colors.GREEN,
-            bold=True,
-        )
+    typer.secho(
+        f"\n🔗 Requesting download link for {app_id}...",
+        fg=typer.colors.GREEN,
+        bold=True,
     )
     # Fetch ZIP downloading URL
     url = f"{PLATFORM_API_URL}/hub/fetch-zip"
-    presigned_url = request_download_link(app_id, app_version, url, "zip_url")
+    try:
+        presigned_url, _ = request_download_link(app_id, app_version, url, "zip_url")
+    except ValueError as e:
+        typer.secho(f"❌ {e}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from e
 
-    print(
-        typer.style(
-            "⬇️  Downloading ZIP into memory...",
-            fg=typer.colors.GREEN,
-            bold=True,
-        )
+    typer.secho(
+        "🔽 Downloading ZIP into memory...",
+        fg=typer.colors.GREEN,
+        bold=True,
     )
     zip_buf = _download_zip_to_memory(presigned_url)
 
-    print(
-        typer.style(
-            f"📦 Unpacking into {project_dir}...",
-            fg=typer.colors.GREEN,
-            bold=True,
-        )
+    typer.secho(
+        f"📦 Unpacking into {project_dir}...",
+        fg=typer.colors.GREEN,
+        bold=True,
     )
     with zipfile.ZipFile(zip_buf) as zf:
         _safe_extract_zip(zf, Path.cwd())
 
     print_success_prompt(app_name)
-
-
-# pylint: disable=too-many-locals,too-many-branches,too-many-statements
-def new(
-    app_name: Annotated[
-        str | None,
-        typer.Argument(
-            help="Flower app name. For remote apps, use the format "
-            "'@account_name/app_name' or '@account_name/app_name==x.y.z'. "
-            "Version is optional (defaults to latest)."
-        ),
-    ] = None,
-    framework: Annotated[
-        MlFramework | None,
-        typer.Option(case_sensitive=False, help="The ML framework to use"),
-    ] = None,
-    username: Annotated[
-        str | None,
-        typer.Option(case_sensitive=False, help="The Flower username of the author"),
-    ] = None,
-) -> None:
-    """Create new Flower App."""
-    if app_name is None:
-        app_name = prompt_text("Please provide the app name")
-
-    # Download remote app
-    if app_name and app_name.startswith("@"):
-        download_remote_app_via_api(app_name)
-        return
-
-    if not is_valid_project_name(app_name):
-        app_name = prompt_text(
-            "Please provide a name that only contains "
-            "characters in {'-', a-zA-Z', '0-9'}",
-            predicate=is_valid_project_name,
-            default=sanitize_project_name(app_name),
-        )
-
-    # Set project directory path
-    package_name = re.sub(r"[-_.]+", "-", app_name).lower()
-    import_name = package_name.replace("-", "_")
-    project_dir = Path.cwd() / package_name
-
-    if project_dir.exists():
-        if not typer.confirm(
-            typer.style(
-                f"\n💬 {app_name} already exists, do you want to override it?",
-                fg=typer.colors.MAGENTA,
-                bold=True,
-            )
-        ):
-            return
-
-    if username is None:
-        username = prompt_text("Please provide your Flower username")
-
-    if framework is not None:
-        framework_str = str(framework.value)
-    else:
-        framework_str = prompt_options(
-            "Please select ML framework by typing in the number",
-            [mlf.value for mlf in MlFramework],
-        )
-
-    llm_challenge_str = None
-    if framework_str == MlFramework.FLOWERTUNE:
-        llm_challenge_value = prompt_options(
-            "Please select LLM challenge by typing in the number",
-            sorted([challenge.value for challenge in LlmChallengeName]),
-        )
-        llm_challenge_str = llm_challenge_value.lower()
-
-    if framework_str == MlFramework.BASELINE:
-        framework_str = "baseline"
-
-    if framework_str == MlFramework.PYTORCH_LEGACY_API:
-        framework_str = "pytorch_legacy_api"
-
-    print(
-        typer.style(
-            f"\n🔨 Creating Flower App {app_name}...",
-            fg=typer.colors.GREEN,
-            bold=True,
-        )
-    )
-
-    context = {
-        "framework_str": framework_str,
-        "import_name": import_name.replace("-", "_"),
-        "package_name": package_name,
-        "project_name": app_name,
-        "username": username,
-    }
-
-    template_name = framework_str.lower()
-
-    # List of files to render
-    if llm_challenge_str:
-        files = {
-            ".gitignore": {"template": "app/.gitignore.tpl"},
-            "pyproject.toml": {"template": f"app/pyproject.{template_name}.toml.tpl"},
-            "README.md": {"template": f"app/README.{template_name}.md.tpl"},
-            f"{import_name}/__init__.py": {"template": "app/code/__init__.py.tpl"},
-            f"{import_name}/server_app.py": {
-                "template": "app/code/flwr_tune/server_app.py.tpl"
-            },
-            f"{import_name}/client_app.py": {
-                "template": "app/code/flwr_tune/client_app.py.tpl"
-            },
-            f"{import_name}/models.py": {
-                "template": "app/code/flwr_tune/models.py.tpl"
-            },
-            f"{import_name}/dataset.py": {
-                "template": "app/code/flwr_tune/dataset.py.tpl"
-            },
-            f"{import_name}/strategy.py": {
-                "template": "app/code/flwr_tune/strategy.py.tpl"
-            },
-        }
-
-        # Challenge specific context
-        fraction_train = "0.2" if llm_challenge_str == "code" else "0.1"
-        if llm_challenge_str == "generalnlp":
-            challenge_name = "General NLP"
-            num_clients = "20"
-            dataset_name = "flwrlabs/alpaca-gpt4"
-        elif llm_challenge_str == "finance":
-            challenge_name = "Finance"
-            num_clients = "50"
-            dataset_name = "flwrlabs/fingpt-sentiment-train"
-        elif llm_challenge_str == "medical":
-            challenge_name = "Medical"
-            num_clients = "20"
-            dataset_name = "flwrlabs/medical-meadow-medical-flashcards"
-        else:
-            challenge_name = "Code"
-            num_clients = "10"
-            dataset_name = "flwrlabs/code-alpaca-20k"
-
-        context["llm_challenge_str"] = llm_challenge_str
-        context["fraction_train"] = fraction_train
-        context["challenge_name"] = challenge_name
-        context["num_clients"] = num_clients
-        context["dataset_name"] = dataset_name
-    else:
-        files = {
-            ".gitignore": {"template": "app/.gitignore.tpl"},
-            "README.md": {"template": "app/README.md.tpl"},
-            "pyproject.toml": {"template": f"app/pyproject.{template_name}.toml.tpl"},
-            f"{import_name}/__init__.py": {"template": "app/code/__init__.py.tpl"},
-            f"{import_name}/server_app.py": {
-                "template": f"app/code/server.{template_name}.py.tpl"
-            },
-            f"{import_name}/client_app.py": {
-                "template": f"app/code/client.{template_name}.py.tpl"
-            },
-        }
-
-        # Depending on the framework, generate task.py file
-        frameworks_with_tasks = [
-            MlFramework.PYTORCH.value,
-            MlFramework.JAX.value,
-            MlFramework.HUGGINGFACE.value,
-            MlFramework.MLX.value,
-            MlFramework.TENSORFLOW.value,
-            MlFramework.SKLEARN.value,
-            MlFramework.NUMPY.value,
-            MlFramework.XGBOOST.value,
-            "pytorch_legacy_api",
-        ]
-        if framework_str in frameworks_with_tasks:
-            files[f"{import_name}/task.py"] = {
-                "template": f"app/code/task.{template_name}.py.tpl"
-            }
-
-        if framework_str == "pytorch_legacy_api":
-            # Use custom __init__ that better captures name of framework
-            files[f"{import_name}/__init__.py"] = {
-                "template": f"app/code/__init__.{framework_str}.py.tpl"
-            }
-
-        if framework_str == "baseline":
-            # Include additional files for baseline template
-            for file_name in ["model", "dataset", "strategy", "utils", "__init__"]:
-                files[f"{import_name}/{file_name}.py"] = {
-                    "template": f"app/code/{file_name}.{template_name}.py.tpl"
-                }
-
-            # Replace README.md
-            files["README.md"]["template"] = f"app/README.{template_name}.md.tpl"
-
-            # Add LICENSE
-            files["LICENSE"] = {"template": "app/LICENSE.tpl"}
-
-    for file_path, value in files.items():
-        render_and_create(
-            file_path=project_dir / file_path,
-            template=value["template"],
-            context=context,
-        )
-
-    print_success_prompt(package_name, llm_challenge_str)

flwr/cli/run/run.py

@@ -46,14 +46,10 @@ from flwr.common.typing import Fab
 from flwr.proto.control_pb2 import StartRunRequest  # pylint: disable=E0611
 from flwr.proto.control_pb2_grpc import ControlStub
 from flwr.supercore.constant import NOOP_FEDERATION
+from flwr.supercore.utils import parse_app_spec
 
 from ..log import start_stream
-from ..utils import (
-    flwr_cli_grpc_exc_handler,
-    init_channel,
-    load_cli_auth_plugin,
-    parse_app_spec,
-)
+from ..utils import flwr_cli_grpc_exc_handler, init_channel, load_cli_auth_plugin
 
 CONN_REFRESH_PERIOD = 60  # Connection refresh period for log streaming (seconds)
 
@@ -111,8 +107,15 @@ def run(
         app_spec = None
         if (app_str := str(app)).startswith("@"):
             # Validate app version and ID format
-            _ = parse_app_spec(app_str)
+            try:
+                _ = parse_app_spec(app_str)
+            except ValueError as e:
+                typer.secho(f"❌ {e}", fg=typer.colors.RED, err=True)
+                raise typer.Exit(code=1) from e
+
             app_spec = app_str
+            # Set `app` to current directory for credential storage
+            app = Path(".")
         is_remote_app = app_spec is not None
 
         typer.secho("Loading project configuration... ", fg=typer.colors.BLUE)
@@ -212,22 +215,14 @@ def _run_with_control_api(
                 f"🎊 Successfully started run {res.run_id}", fg=typer.colors.GREEN
             )
         else:
-            if is_remote_app:
-                typer.secho(
-                    "❌ Failed to start run. Please check that the provided "
-                    "app identifier (@account_name/app_name) is correct.",
-                    fg=typer.colors.RED,
-                    err=True,
-                )
-            else:
-                typer.secho("❌ Failed to start run", fg=typer.colors.RED, err=True)
+            typer.secho("❌ Failed to start run", fg=typer.colors.RED, err=True)
             raise typer.Exit(code=1)
 
         if output_format == CliOutputFormat.JSON:
             # Only include FAB metadata if we actually built a local FAB
             payload: dict[str, Any] = {
                 "success": res.HasField("run_id"),
-                "run-id": res.run_id if res.HasField("run_id") else None,
+                "run-id": f"{res.run_id}" if res.HasField("run_id") else None,
             }
             if not is_remote_app:
                 payload.update(