@opengeni/core 0.28.0 → 1.0.0

package/src/sandbox/routing.ts

@@ -12,20 +12,28 @@
 // over the events bus) lives here, not in the leaf (which stays db-free).
 
 import { sandboxLifecycleTransitionWaitMs, type Settings } from "@opengeni/config";
+import { appendSessionCommandOutput } from "@opengeni/db/session-command-output";
+import {
+  createProviderCommandRetainer,
+  supervisedCommandProtocolReady,
+} from "@opengeni/db/retained-provider-commands";
 import {
   advanceWorkspaceGenerationForDirectRequest,
+  retainedProviderCommandPersistence,
   advanceWorkspaceGenerationForRetainedProcess,
-  getEnrollment,
+  getLiveEnrollmentConnection,
   getRetainedProcess,
   getSandbox,
   markWarmLeaseInstanceLost,
   readActiveSandbox,
   retainWorkspaceMutationProcess,
+  SandboxRetainedProcessPromotionFencedError,
   retainedProcessSettlementIdentity,
   settleRetainedProcess,
   verifyDirectWorkspaceMutationSettlement,
   verifyRetainedProcessMutationSettlement,
   type Database,
+  type SandboxRetainedProcess,
   type SandboxWorkspaceMutationAdmission,
 } from "@opengeni/db";
 import { appendAndPublishEvents, type EventBus } from "@opengeni/events";
@@ -45,7 +53,9 @@ import {
   type RoutingRetainedProcess,
   type RoutingRetainedProcessTerminalProof,
   type RoutingSandboxOperationObserver,
+  type RoutingSandboxCaptureWaitObserver,
   type SelfhostedRelayConfig,
+  type SelfhostedConnectionBinding,
   type SelfhostedOpStreamDeps,
 } from "@opengeni/runtime/sandbox";
 
@@ -56,11 +66,59 @@ type PersistableMutationAdmission = {
   > | null;
 };
 
+const retainWorkspaceProviderCommand = createProviderCommandRetainer(
+  retainWorkspaceMutationProcess,
+  (error) => (error instanceof SandboxRetainedProcessPromotionFencedError ? error.process : null),
+);
+
+type DirectRetainedProcessRoute = {
+  providerSessionId: number;
+  providerBackend: string;
+  providerInstanceId: string;
+  leaseEpoch: number;
+  routeKind: "home" | "active";
+  routeTargetId: string | null;
+  routeEpoch: number;
+};
+
+/** API-direct requests always use active-route authority. The default active
+ * pointer is represented by a null target id; it is not a home-route write. */
+export function directRetainedProcessMatchesBackend(
+  durable: DirectRetainedProcessRoute,
+  process: RoutingRetainedProcess,
+  backend: ResolvedActiveBackend,
+): boolean {
+  return (
+    durable.providerSessionId === process.providerSessionId &&
+    durable.providerBackend === backend.kind &&
+    durable.providerInstanceId === backend.providerInstanceId &&
+    durable.leaseEpoch === backend.leaseEpoch &&
+    durable.routeKind === "active" &&
+    durable.routeTargetId === backend.sandboxId &&
+    durable.routeEpoch === backend.activeEpoch
+  );
+}
+
+export function retainedProcessBackgroundSettlement(
+  process: Pick<SandboxRetainedProcess, "state" | "exitCode" | "settlementReason">,
+  fallback: RoutingRetainedProcessTerminalProof,
+): { outcome: "exited" | "lost"; exitCode: number | null; reason: string } {
+  if (process.state === "active") {
+    throw new Error("Retained-process settlement returned an active durable process");
+  }
+  return {
+    outcome: process.state,
+    exitCode: process.exitCode,
+    reason: process.settlementReason ?? fallback.reason,
+  };
+}
+
 export type ChannelARoutingServices = {
   db: Database;
   settings: Settings;
   bus?: EventBus;
   onSandboxOperation?: RoutingSandboxOperationObserver;
+  onSandboxCaptureWait?: RoutingSandboxCaptureWaitObserver;
   waitSignal?: AbortSignal;
 };
 
@@ -118,24 +176,31 @@ function controlRpcFactory(bus: EventBus | undefined): () => ControlRpc {
     });
 }
 
-async function resolveSelfhostedOpStream(
+async function resolveSelfhostedConnection(
   services: ChannelARoutingServices,
-  workspaceId: string,
+  access: string | { accountId: string; workspaceId: string; subjectId: string },
   sandbox: RoutableSandbox,
-): Promise<SelfhostedOpStreamDeps | undefined> {
-  if (
-    services.settings.agentOpStreamEnabled !== true ||
-    !services.bus?.getOpStreamConnection ||
-    !sandbox.enrollmentId
-  ) {
-    return undefined;
-  }
-  const enrollment = await getEnrollment(services.db, workspaceId, sandbox.enrollmentId);
-  if (enrollment?.opStream !== true) return undefined;
+): Promise<SelfhostedConnectionBinding | null> {
+  if (!sandbox.enrollmentId) return null;
+  const enrollment = await getLiveEnrollmentConnection(services.db, access, sandbox.enrollmentId);
+  if (!enrollment?.connectionInstanceId) return null;
+  const opStream: SelfhostedOpStreamDeps | undefined =
+    services.settings.agentOpStreamEnabled === true &&
+    services.bus?.getOpStreamConnection &&
+    enrollment.opStream === true
+      ? {
+          transport: new NatsOpStreamTransport(
+            async () => services.bus?.getOpStreamConnection?.() ?? null,
+          ),
+        }
+      : undefined;
   return {
-    transport: new NatsOpStreamTransport(
-      async () => services.bus?.getOpStreamConnection?.() ?? null,
-    ),
+    connectionInstanceId: enrollment.connectionInstanceId,
+    workspaceRoot: enrollment.workspaceRoot,
+    ...(opStream ? { opStream } : {}),
+    operationResourcePolicy: enrollment.operationPolicy,
+    operationResourcePolicySupported: enrollment.agentCapabilities.operationResourcePolicy === true,
+    operationCpuQuotaSupported: enrollment.agentCapabilities.operationCpuQuota === true,
   };
 }
 
@@ -157,6 +222,7 @@ export function wrapChannelABoxWithRouting(
     accountId: string;
     workspaceId: string;
     sessionId: string;
+    resourceSubjectId: string;
     homeLease?: {
       sandboxGroupId: string;
       leaseEpoch: number;
@@ -209,6 +275,7 @@ export function wrapChannelABoxWithRouting(
           sessionId: ids.sessionId,
           requestId: ids.directRequest.requestId,
           holderId: ids.directRequest.holderId,
+          initiatorSubjectId: ids.resourceSubjectId,
           sandboxGroupId: homeLease.sandboxGroupId,
           expectedEpoch: backend.leaseEpoch,
           expectedInstanceId: backend.providerInstanceId,
@@ -232,7 +299,7 @@ export function wrapChannelABoxWithRouting(
         op: string;
         backend: ResolvedActiveBackend;
         admission: unknown;
-        outcome: "resolved" | "rejected";
+        outcome: "resolved" | "rejected" | "outcome_unknown";
         result?: unknown;
         retainedProcess?: RoutingRetainedProcess;
       }): Promise<void> => {
@@ -256,21 +323,29 @@ export function wrapChannelABoxWithRouting(
         ) {
           throw new Error("API-direct workspace mutation settlement lacked its bound admission");
         }
-        if (outcome === "resolved" && retainedProcess) {
-          await retainWorkspaceMutationProcess(db, {
+        if ((outcome === "resolved" || outcome === "outcome_unknown") && retainedProcess) {
+          await retainWorkspaceProviderCommand(db, {
             accountId: ids.accountId,
             workspaceId: ids.workspaceId,
             sessionId: ids.sessionId,
             processId: retainedProcess.id,
             providerSessionId: retainedProcess.providerSessionId,
+            ...(retainedProcess.providerCommand
+              ? { providerCommand: retainedProcess.providerCommand }
+              : {}),
             admissionId: exactAdmission.id,
             admittedWorkspaceGeneration: exactAdmission.workspaceGeneration,
             operation: op,
             providerBinding: boundAdmission.providerBinding ?? null,
+            backgroundCommand: {
+              commandId: retainedProcess.id,
+              command: op,
+            },
             owner: {
               kind: "direct",
               requestId: ids.directRequest.requestId,
               holderId: ids.directRequest.holderId,
+              initiatorSubjectId: ids.resourceSubjectId,
               sandboxGroupId: homeLease.sandboxGroupId,
               expectedEpoch: backend.leaseEpoch,
               expectedInstanceId: backend.providerInstanceId,
@@ -280,12 +355,17 @@ export function wrapChannelABoxWithRouting(
           });
           return;
         }
+        if (outcome === "outcome_unknown")
+          throw new Error(
+            "Outcome-unknown command settlement requires its exact retained invocation",
+          );
         await verifyDirectWorkspaceMutationSettlement(db, {
           accountId: ids.accountId,
           workspaceId: ids.workspaceId,
           sessionId: ids.sessionId,
           requestId: ids.directRequest.requestId,
           holderId: ids.directRequest.holderId,
+          initiatorSubjectId: ids.resourceSubjectId,
           sandboxGroupId: homeLease.sandboxGroupId,
           expectedEpoch: backend.leaseEpoch,
           expectedInstanceId: backend.providerInstanceId,
@@ -373,21 +453,12 @@ export function wrapChannelABoxWithRouting(
           sessionId: ids.sessionId,
           processId: process.id,
         });
-        if (
-          !durable ||
-          durable.providerSessionId !== process.providerSessionId ||
-          durable.providerBackend !== backend.kind ||
-          durable.providerInstanceId !== backend.providerInstanceId ||
-          durable.leaseEpoch !== backend.leaseEpoch ||
-          durable.routeKind !== (backend.sandboxId === null ? "home" : "active") ||
-          durable.routeTargetId !== backend.sandboxId ||
-          durable.routeEpoch !== backend.activeEpoch
-        ) {
+        if (!durable || !directRetainedProcessMatchesBackend(durable, process, backend)) {
           throw new Error(
             "API retained-process settlement lost its exact durable backend identity",
           );
         }
-        await settleRetainedProcess(db, {
+        const settlement = await settleRetainedProcess(db, {
           accountId: ids.accountId,
           workspaceId: ids.workspaceId,
           sessionId: ids.sessionId,
@@ -398,6 +469,11 @@ export function wrapChannelABoxWithRouting(
           reason: proof.reason,
           idleGraceMs: settings.sandboxIdleGraceMs,
         });
+        if (settlement.backgroundCommandEvents.length > 0 && bus) {
+          await bus
+            .publish(ids.workspaceId, ids.sessionId, settlement.backgroundCommandEvents)
+            .catch(() => undefined);
+        }
       }
     : undefined;
   const resolver = makeActiveBackendResolver({
@@ -405,10 +481,19 @@ export function wrapChannelABoxWithRouting(
     defaultBackend: established.session as RoutableBackendSession,
     defaultKind: established.backendId,
     getSandbox: async (sandboxId): Promise<RoutableSandbox | null> => {
-      const sandbox = await getSandbox(db, ids.workspaceId, sandboxId);
+      const sandbox = await getSandbox(
+        db,
+        {
+          accountId: ids.accountId,
+          workspaceId: ids.workspaceId,
+          subjectId: ids.resourceSubjectId,
+        },
+        sandboxId,
+      );
       return sandbox
         ? {
             id: sandbox.id,
+            workspaceId: sandbox.workspaceId,
             kind: sandbox.kind,
             name: sandbox.name,
             enrollmentId: sandbox.enrollmentId,
@@ -416,8 +501,16 @@ export function wrapChannelABoxWithRouting(
         : null;
     },
     controlRpcFactory: controlRpcFactory(bus),
-    resolveSelfhostedOpStream: (sandbox) =>
-      resolveSelfhostedOpStream(services, ids.workspaceId, sandbox),
+    resolveSelfhostedConnection: (sandbox) =>
+      resolveSelfhostedConnection(
+        services,
+        {
+          accountId: ids.accountId,
+          workspaceId: ids.workspaceId,
+          subjectId: ids.resourceSubjectId,
+        },
+        sandbox,
+      ),
     relay: relayConfigFromSettings(settings),
     selfhostedTimeoutMs: settings.sandboxSelfhostedControlTimeoutMs,
     selfhostedExecTimeoutMs: settings.sandboxSelfhostedExecTimeoutMs,
@@ -444,6 +537,38 @@ export function wrapChannelABoxWithRouting(
   });
 
   const proxy = new RoutingSandboxSession({
+    providerSupervisionReady: async () =>
+      settings.modalCommandSupervisionEnabled && (await supervisedCommandProtocolReady(db)),
+    providerCommandHandle: (value) =>
+      value && typeof value === "object"
+        ? (value as PersistableMutationAdmission).admission?.workspaceGeneration
+        : undefined,
+    providerCommandPersistence: (process) =>
+      retainedProviderCommandPersistence(
+        db,
+        {
+          accountId: ids.accountId,
+          workspaceId: ids.workspaceId,
+          sessionId: ids.sessionId,
+          processId: process.id,
+        },
+        bus ? (events) => bus.publish(ids.workspaceId, ids.sessionId, events) : undefined,
+      ),
+    captureProcessOutput: async ({ process, chunkId, chunk, stream, streamFidelity }) => {
+      const events = await appendSessionCommandOutput(db, {
+        accountId: ids.accountId,
+        workspaceId: ids.workspaceId,
+        sessionId: ids.sessionId,
+        commandId: process.id,
+        chunkId,
+        chunk,
+        stream,
+        streamFidelity,
+      });
+      if (events.length && bus)
+        await bus.publish(ids.workspaceId, ids.sessionId, events).catch(() => undefined);
+    },
+    bindActiveRouteOnFirstResolve: true,
     defaultResolved: {
       session: established.session as RoutableBackendSession,
       sandboxId: null,
@@ -464,6 +589,7 @@ export function wrapChannelABoxWithRouting(
     },
     resolveActiveBackend: resolver,
     ...(services.onSandboxOperation ? { onOperation: services.onSandboxOperation } : {}),
+    ...(services.onSandboxCaptureWait ? { onCaptureWait: services.onSandboxCaptureWait } : {}),
     ...(beforeMutation ? { beforeMutation } : {}),
     ...(afterMutation ? { afterMutation } : {}),
     ...(beforeProcessMutation ? { beforeProcessMutation } : {}),
@@ -479,6 +605,7 @@ export function wrapChannelABoxWithRouting(
               sandboxGroupId: homeLease.sandboxGroupId,
               expectedEpoch: homeLease.leaseEpoch,
               expectedInstanceId: homeLease.instanceId,
+              expectedBackend: homeLease.backend,
               diagnostic: "provider_not_found_during_routed_operation",
             });
             if (marked.status === "marked" && bus) {

package/src/sandbox/runtime-settings.ts

@@ -0,0 +1,281 @@
+import { sandboxImageAllowlist, type Settings } from "@opengeni/config";
+import {
+  resolveWorkspaceDefaultSandboxImage,
+  type RigVersion,
+  type Session,
+  type SandboxBackend,
+  type SandboxOs,
+} from "@opengeni/contracts";
+import { getRigVersion, getWorkspace, type Database } from "@opengeni/db";
+import { resolveModalCheckpointProviderBinding } from "@opengeni/runtime/sandbox";
+import {
+  rigProviderImageContentHash,
+  rigProviderImageMatchesDefinition,
+  rigProviderImageProviderBindingKeyHash,
+} from "../rigs/provider-images";
+
+export type ManagedSessionGroupBackend = Exclude<SandboxBackend, "none" | "selfhosted">;
+
+/**
+ * Resolve the provider backend behind a session's synthetic managed group.
+ *
+ * A machine-home session keeps `selfhosted` as its durable policy while a
+ * non-null active pointer selects the enrolled machine. Clearing that pointer
+ * is an explicit switch to the deployment's managed group, so API readiness,
+ * viewer attachment, Channel-A, and worker turns must all select the same
+ * provider. Deployments configured with `none` or `selfhosted` have no managed
+ * fallback to expose.
+ */
+export function managedSessionGroupBackend(
+  deploymentBackend: SandboxBackend,
+  sessionBackend: SandboxBackend,
+): ManagedSessionGroupBackend | null {
+  if (sessionBackend === "none") return null;
+  const backend = sessionBackend === "selfhosted" ? deploymentBackend : sessionBackend;
+  return backend === "none" || backend === "selfhosted" ? null : backend;
+}
+
+const SESSION_GROUP_MACHINE_NAMES: Record<ManagedSessionGroupBackend, string> = {
+  local: "this computer",
+  docker: "Docker",
+  modal: "Modal",
+  daytona: "Daytona",
+  runloop: "Runloop",
+  e2b: "E2B",
+  blaxel: "Blaxel",
+  cloudflare: "Cloudflare",
+  vercel: "Vercel",
+  opensandbox: "OpenSandbox",
+};
+
+/** Display name and kind for the session's own managed box. The kind is the
+ * real provider. Callers must not collapse local, Docker, or other providers
+ * into Modal. */
+export function sessionGroupMachinePresentation(backend: ManagedSessionGroupBackend): {
+  name: string;
+  kind: ManagedSessionGroupBackend;
+} {
+  return { name: SESSION_GROUP_MACHINE_NAMES[backend], kind: backend };
+}
+
+/** A machine-home row carries the machine's host OS; its managed group uses the
+ * platform's canonical managed-sandbox OS instead. Ordinary sessions preserve
+ * their explicitly selected OS. */
+export function managedSessionGroupOs(
+  sessionBackend: SandboxBackend,
+  sessionOs: SandboxOs,
+): SandboxOs {
+  return sessionBackend === "selfhosted" ? "linux" : sessionOs;
+}
+
+/**
+ * Apply a workspace's selected sandbox image. The deployment keeps authority:
+ * only an image that is on its allowlist right now is used, so removing an
+ * entry returns every workspace that chose it to the deployment image. The
+ * lease treats the image as shared state, so a change rotates a live box
+ * through the normal capture-and-restore path instead of reusing it.
+ */
+export function settingsWithWorkspaceSandboxImage(
+  settings: Settings,
+  workspaceSettings: unknown,
+  backend: SandboxBackend,
+): Settings {
+  const image = resolveWorkspaceDefaultSandboxImage(workspaceSettings);
+  if (!image || !sandboxImageAllowlist(settings).includes(image)) return settings;
+  if (backend === "docker") return { ...settings, dockerImage: image };
+  if (backend === "modal") {
+    return { ...settings, modalImageRef: image, modalImageId: undefined };
+  }
+  return settings;
+}
+
+export function settingsWithRigImage(settings: Settings, rigImage: string | null): Settings {
+  // Explicit Rig image overrides are intentionally inert. Preserve this helper
+  // as a compatibility seam for callers and historical rows while ensuring the
+  // deployment-owned platform image remains authoritative.
+  void rigImage;
+  return settings;
+}
+
+export function rigProviderImageSourceImage(
+  settings: Settings,
+  backend: SandboxBackend,
+): string | null {
+  if (backend === "modal") return settings.modalImageId ?? settings.modalImageRef ?? null;
+  if (backend === "docker") return settings.dockerImage ?? null;
+  return null;
+}
+
+export type RigProviderImageSelectionReason =
+  | "selected"
+  | "missing"
+  | "provider_unsupported"
+  | "not_ready"
+  | "not_cold_boot_validated"
+  | "content_mismatch"
+  | "provider_binding_unavailable"
+  | "provider_binding_mismatch";
+
+export function resolveRigProviderImageSelection(
+  settings: Settings,
+  version: RigVersion | null,
+  backend: SandboxBackend,
+  currentProviderBindingKeyHash: string | null,
+): {
+  settings: Settings;
+  reason: RigProviderImageSelectionReason;
+  contentHash: string | null;
+  imageId: string | null;
+} {
+  if (!version) return { settings, reason: "missing", contentHash: null, imageId: null };
+  if (backend !== "modal") {
+    return { settings, reason: "provider_unsupported", contentHash: null, imageId: null };
+  }
+  const image = version.providerImages[backend];
+  if (!image) return { settings, reason: "missing", contentHash: null, imageId: null };
+  if (image.status !== "ready" || !image.imageId) {
+    return {
+      settings,
+      reason: "not_ready",
+      contentHash: image.contentHash,
+      imageId: image.imageId,
+    };
+  }
+  if (image.coldBootValidation?.version !== 1) {
+    return {
+      settings,
+      reason: "not_cold_boot_validated",
+      contentHash: image.contentHash,
+      imageId: null,
+    };
+  }
+  const sourceImage = rigProviderImageSourceImage(settings, backend);
+  const expectedContentHash = rigProviderImageContentHash({
+    backend,
+    sourceImage,
+    definition: version,
+  });
+  if (
+    image.sourceImage !== sourceImage ||
+    image.contentHash !== expectedContentHash ||
+    !rigProviderImageMatchesDefinition(image, version)
+  ) {
+    return {
+      settings,
+      reason: "content_mismatch",
+      contentHash: expectedContentHash,
+      imageId: null,
+    };
+  }
+  if (!image.providerBindingKeyHash || !currentProviderBindingKeyHash) {
+    return {
+      settings,
+      reason: "provider_binding_unavailable",
+      contentHash: expectedContentHash,
+      imageId: null,
+    };
+  }
+  if (image.providerBindingKeyHash !== currentProviderBindingKeyHash) {
+    return {
+      settings,
+      reason: "provider_binding_mismatch",
+      contentHash: expectedContentHash,
+      imageId: null,
+    };
+  }
+  return {
+    settings: { ...settings, modalImageId: image.imageId },
+    reason: "selected",
+    contentHash: expectedContentHash,
+    imageId: image.imageId,
+  };
+}
+
+export async function resolveRigProviderImageForRun(
+  settings: Settings,
+  version: RigVersion | null,
+  backend: SandboxBackend,
+  resolveBinding: typeof resolveModalCheckpointProviderBinding = resolveModalCheckpointProviderBinding,
+): Promise<ReturnType<typeof resolveRigProviderImageSelection>> {
+  const image = backend === "modal" ? version?.providerImages.modal : null;
+  if (image?.status !== "ready" || !image.providerBindingKeyHash) {
+    return resolveRigProviderImageSelection(settings, version, backend, null);
+  }
+  const structural = resolveRigProviderImageSelection(
+    settings,
+    version,
+    backend,
+    image.providerBindingKeyHash,
+  );
+  if (structural.reason !== "selected") return structural;
+  let currentProviderBindingKeyHash: string | null = null;
+  try {
+    const binding = await resolveBinding(settings);
+    currentProviderBindingKeyHash = rigProviderImageProviderBindingKeyHash(binding.key);
+  } catch {
+    // A provider-native image is an optimization. The exact logical image is
+    // still the correct cold-create fallback when provider identity is absent.
+  }
+  return resolveRigProviderImageSelection(
+    settings,
+    version,
+    backend,
+    currentProviderBindingKeyHash,
+  );
+}
+
+export async function settingsWithRigProviderImage(
+  settings: Settings,
+  version: RigVersion | null,
+  backend: SandboxBackend,
+  resolveBinding: typeof resolveModalCheckpointProviderBinding = resolveModalCheckpointProviderBinding,
+): Promise<Settings> {
+  return (await resolveRigProviderImageForRun(settings, version, backend, resolveBinding)).settings;
+}
+
+export type SessionSandboxRuntime = {
+  /** Exact logical image/rig settings used to fence the durable group lease. */
+  settings: Settings;
+  image: string | null;
+  rigVersion: RigVersion | null;
+};
+
+export async function resolveSessionSandboxRuntime(
+  db: Database,
+  settings: Settings,
+  session: Pick<Session, "workspaceId" | "sandboxBackend" | "rigId" | "rigVersionId">,
+): Promise<SessionSandboxRuntime> {
+  const rigVersion =
+    session.rigId && session.rigVersionId
+      ? await getRigVersion(db, session.workspaceId, session.rigId, session.rigVersionId)
+      : null;
+  if (session.rigVersionId && !rigVersion) {
+    throw new Error(`Frozen sandbox environment version ${session.rigVersionId} is unavailable`);
+  }
+  // Setup and checks layer on the deployment image, or on the workspace's
+  // allowlisted selection of one.
+  const logicalSettings = sandboxImageAllowlist(settings).length
+    ? settingsWithWorkspaceSandboxImage(
+        settings,
+        (await getWorkspace(db, session.workspaceId))?.settings,
+        session.sandboxBackend,
+      )
+    : settings;
+  return {
+    settings: {
+      ...logicalSettings,
+      sandboxBackend: session.sandboxBackend,
+    },
+    image: rigProviderImageSourceImage(logicalSettings, session.sandboxBackend),
+    rigVersion,
+  };
+}
+
+/** Resolve provider-native cold-create optimization only for the single CAS
+ * winner. Ordinary API calls never perform provider identity I/O. */
+export async function providerSettingsForSessionSandboxRuntime(
+  runtime: SessionSandboxRuntime,
+  backend: SandboxBackend,
+): Promise<Settings> {
+  return await settingsWithRigProviderImage(runtime.settings, runtime.rigVersion, backend);
+}