@smileid/usesmileid 12.0.0 → 12.0.2

package/src/metadata/__tests__/use_smile_id_metadata_factory.test.ts

@@ -0,0 +1,615 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+
+// `vi.mock` is hoisted above the imports, so anything its factory closes over
+// must be created with `vi.hoisted` or it is still in the TDZ when the factory
+// runs.
+const {
+  loadExpoDevice,
+  loadExpoNetwork,
+  loadExpoBattery,
+  loadExpoCellular,
+  loadAsyncStorage,
+  resolveGeolocation,
+  privileges,
+  signals,
+  generateHardwareAttestation,
+  dimensionsGet,
+} = vi.hoisted(() => ({
+  loadExpoDevice: vi.fn(),
+  loadExpoNetwork: vi.fn(),
+  loadExpoBattery: vi.fn(),
+  loadExpoCellular: vi.fn(),
+  loadAsyncStorage: vi.fn(),
+  resolveGeolocation: vi.fn(),
+  privileges: vi.fn(),
+  signals: vi.fn(),
+  generateHardwareAttestation: vi.fn(),
+  dimensionsGet: vi.fn(),
+}));
+
+vi.mock("../optional_native_modules", () => ({
+  loadExpoDevice,
+  loadExpoNetwork,
+  loadExpoBattery,
+  loadExpoCellular,
+  loadAsyncStorage,
+}));
+
+vi.mock("../geolocation", () => ({ resolveGeolocation }));
+
+// The shared react-native stub has no `Dimensions` — the factory's screen /
+// orientation resolvers are the only consumers, so they are supplied here
+// rather than widening the stub for every other suite.
+vi.mock("react-native", async () => {
+  const actual =
+    await vi.importActual<typeof import("react-native")>("react-native");
+  return { ...actual, Dimensions: { get: dimensionsGet } };
+});
+
+vi.mock("@smileid/usesmileid_bridge", async () => {
+  const actual = await vi.importActual<
+    typeof import("@smileid/usesmileid_bridge")
+  >("@smileid/usesmileid_bridge");
+  return {
+    ...actual,
+    PrivilegesProvider: { privileges },
+    DeviceIntegrityProvider: { signals },
+    Attestation: { generateHardwareAttestation },
+  };
+});
+
+import { Platform } from "react-native";
+import {
+  UseSmileIDMetadataFactory,
+  generateSessionId,
+} from "../use_smile_id_metadata_factory";
+import type { UseSmileIDMetadata } from "../use_smile_id_metadata";
+
+/**
+ * Boundary tests for the metadata factory's optional-peer wiring: the
+ * `expo-device` constructor branch, the fire-and-forget warmup fan-out
+ * (network / battery / launch count / geolocation / privileges /
+ * device integrity), and the resolver fallbacks. Every optional module
+ * is mocked at the `optional_native_modules` seam, which is where the
+ * production code isolates the peer dependency.
+ */
+
+type MutablePlatform = { OS: string };
+const platform = Platform as unknown as MutablePlatform;
+const originalPlatformOs = platform.OS;
+
+/** Lets the constructor's unawaited warmup promises settle. */
+async function flush(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function entries(metadata: UseSmileIDMetadata): Map<string, string> {
+  return new Map(
+    metadata.toEntries().map((entry) => [entry.name, entry.value]),
+  );
+}
+
+function names(metadata: UseSmileIDMetadata): readonly string[] {
+  return metadata.toEntries().map((entry) => entry.name);
+}
+
+/** A minimal expo-network stand-in — the warmup fan-out is gated on it. */
+function networkModule(type: string | null = "WIFI") {
+  return { getNetworkStateAsync: vi.fn(async () => ({ type })) };
+}
+
+beforeEach(() => {
+  loadExpoDevice.mockReset().mockReturnValue(null);
+  loadExpoNetwork.mockReset().mockReturnValue(null);
+  loadExpoBattery.mockReset().mockReturnValue(null);
+  loadExpoCellular.mockReset().mockReturnValue(null);
+  loadAsyncStorage.mockReset().mockReturnValue(null);
+  resolveGeolocation.mockReset().mockResolvedValue(null);
+  privileges.mockReset().mockResolvedValue("");
+  signals.mockReset().mockResolvedValue({});
+  generateHardwareAttestation.mockReset().mockResolvedValue({
+    securityLevel: -2,
+    supportsAppAttest: false,
+  });
+  dimensionsGet
+    .mockReset()
+    .mockImplementation((dimension: string) =>
+      dimension === "screen"
+        ? { width: 390, height: 844, scale: 3 }
+        : { width: 390, height: 844 },
+    );
+  platform.OS = originalPlatformOs;
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  platform.OS = originalPlatformOs;
+});
+
+describe("UseSmileIDMetadataFactory — expo-device constructor branch", () => {
+  it("joins brand and model, converts memory to MB, and reads the iOS build fields", async () => {
+    platform.OS = "ios";
+    loadExpoDevice.mockReturnValue({
+      brand: "  Apple  ",
+      modelName: " iPhone 15 ",
+      supportedCpuArchitectures: [" arm64e "],
+      totalMemory: 6 * 1024 * 1024 * 1024,
+      modelId: " iPhone16,2 ",
+      designName: "ignored-on-ios",
+      osBuildFingerprint: " apple/iphone:17 ",
+      productName: " iphone15 ",
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const values = entries(factory.make());
+
+    expect(values.get("device_model")).toBe("Apple iPhone 15");
+    expect(values.get("system_architecture")).toBe("arm64e");
+    expect(values.get("memory_info")).toBe("6144");
+    expect(values.get("build_brand")).toBe("Apple");
+    expect(values.get("build_device")).toBe("iPhone16,2");
+    expect(values.get("build_fingerprint")).toBe("apple/iphone:17");
+    expect(values.get("build_product")).toBe("iphone15");
+  });
+
+  it("reads Build.DEVICE (designName) for the build_device field on Android", async () => {
+    platform.OS = "android";
+    loadExpoDevice.mockReturnValue({
+      brand: "google",
+      modelName: "Pixel 8",
+      designName: "husky",
+      modelId: "ignored-on-android",
+      supportedCpuArchitectures: ["arm64-v8a"],
+      totalMemory: 1024 * 1024,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const values = entries(factory.make());
+
+    expect(values.get("build_device")).toBe("husky");
+    expect(values.get("memory_info")).toBe("1");
+  });
+
+  it("tolerates a device module with every field null", async () => {
+    loadExpoDevice.mockReturnValue({
+      brand: null,
+      modelName: null,
+      supportedCpuArchitectures: null,
+      totalMemory: null,
+      designName: null,
+      modelId: null,
+      osBuildFingerprint: null,
+      productName: null,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const metadata = factory.make();
+
+    // device_model is always-present; the rest drop out when empty / zero.
+    expect(entries(metadata).get("device_model")).toBe("");
+    expect(names(metadata)).not.toContain("build_brand");
+    expect(names(metadata)).not.toContain("memory_info");
+    expect(names(metadata)).not.toContain("system_architecture");
+  });
+
+  it("treats a non-positive totalMemory as unknown", async () => {
+    loadExpoDevice.mockReturnValue({
+      brand: "google",
+      modelName: "Pixel",
+      totalMemory: 0,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    expect(names(factory.make())).not.toContain("memory_info");
+  });
+
+  it("falls back to empty device fields when expo-device is absent", async () => {
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const metadata = factory.make();
+
+    expect(entries(metadata).get("device_model")).toBe("");
+    expect(names(metadata)).not.toContain("build_product");
+  });
+
+  it("reads the carrier name from expo-cellular", async () => {
+    loadExpoCellular.mockReturnValue({ carrier: "  MTN  " });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    expect(entries(factory.make()).get("carrier_info")).toBe("MTN");
+  });
+});
+
+describe("UseSmileIDMetadataFactory — async warmup", () => {
+  it("resolves network connection and client IP from expo-network", async () => {
+    loadExpoNetwork.mockReturnValue({
+      getNetworkStateAsync: vi.fn(async () => ({ type: "WIFI" })),
+      getIpAddressAsync: vi.fn(async () => "10.0.0.7"),
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+    const values = entries(factory.make());
+
+    expect(values.get("network_connection")).toBe("WIFI");
+    expect(values.get("client_ip")).toBe("10.0.0.7");
+  });
+
+  it("keeps the empty defaults when the network calls reject", async () => {
+    loadExpoNetwork.mockReturnValue({
+      getNetworkStateAsync: vi.fn(async () => {
+        throw new Error("no radio");
+      }),
+      getIpAddressAsync: vi.fn(async () => {
+        throw new Error("no ip");
+      }),
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+
+    expect(names(factory.make())).not.toContain("network_connection");
+    expect(names(factory.make())).not.toContain("client_ip");
+  });
+
+  it("skips the IP probe when the module does not expose one", async () => {
+    const network = networkModule(null);
+    loadExpoNetwork.mockReturnValue(network);
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+
+    expect(network.getNetworkStateAsync).toHaveBeenCalled();
+    expect(names(factory.make())).not.toContain("client_ip");
+  });
+
+  it("maps expo-battery states to the cross-SDK plug status", async () => {
+    const cases: ReadonlyArray<readonly [number, string]> = [
+      [1, "0"],
+      [2, "1"],
+      [3, "1"],
+      [0, "-1"],
+    ];
+    for (const [nativeState, expected] of cases) {
+      loadExpoNetwork.mockReturnValue(networkModule());
+      loadExpoBattery.mockReturnValue({
+        getBatteryStateAsync: vi.fn(async () => nativeState),
+      });
+      const factory = new UseSmileIDMetadataFactory();
+      await factory.warmup();
+      expect(entries(factory.make()).get("battery_status")).toBe(expected);
+    }
+  });
+
+  it("omits battery_status when the battery probe throws", async () => {
+    loadExpoNetwork.mockReturnValue(networkModule());
+    loadExpoBattery.mockReturnValue({
+      getBatteryStateAsync: vi.fn(async () => {
+        throw new Error("no battery service");
+      }),
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+    expect(names(factory.make())).not.toContain("battery_status");
+  });
+
+  it("increments and persists the launch counter through async-storage", async () => {
+    const setItem = vi.fn(async () => {});
+    loadExpoNetwork.mockReturnValue(networkModule());
+    loadAsyncStorage.mockReturnValue({
+      getItem: vi.fn(async () => "4"),
+      setItem,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+
+    expect(setItem).toHaveBeenCalledWith(
+      "com.usesmileid.metadata.sdk_launch_count",
+      "5",
+    );
+    expect(entries(factory.make()).get("sdk_launch_count")).toBe("5");
+  });
+
+  it("starts the launch counter at 1 when nothing is stored", async () => {
+    loadExpoNetwork.mockReturnValue(networkModule());
+    loadAsyncStorage.mockReturnValue({
+      getItem: vi.fn(async () => null),
+      setItem: vi.fn(async () => {}),
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+    expect(entries(factory.make()).get("sdk_launch_count")).toBe("1");
+  });
+
+  it("omits sdk_launch_count when the store rejects", async () => {
+    loadExpoNetwork.mockReturnValue(networkModule());
+    loadAsyncStorage.mockReturnValue({
+      getItem: vi.fn(async () => {
+        throw new Error("storage unavailable");
+      }),
+      setItem: vi.fn(async () => {}),
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+    expect(names(factory.make())).not.toContain("sdk_launch_count");
+  });
+
+  it("emits the resolved geolocation and the privileges blob", async () => {
+    loadExpoNetwork.mockReturnValue(networkModule());
+    resolveGeolocation.mockResolvedValue({
+      latitude: 1.5,
+      longitude: -2.5,
+      accuracy: "precise",
+      source: "gps",
+    });
+    privileges.mockResolvedValue('{"1":"100010"}');
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+    const values = entries(factory.make());
+
+    expect(values.get("geolocation")).toContain('"latitude":1.5');
+    expect(values.get("privileges")).toBe('{"1":"100010"}');
+  });
+
+  it("omits privileges and geolocation when neither resolves", async () => {
+    loadExpoNetwork.mockReturnValue(networkModule());
+    privileges.mockResolvedValue("");
+    resolveGeolocation.mockResolvedValue(null);
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+
+    expect(names(factory.make())).not.toContain("privileges");
+    expect(names(factory.make())).not.toContain("geolocation");
+  });
+
+  it("copies the native device-integrity signals onto the payload", async () => {
+    loadExpoNetwork.mockReturnValue(networkModule());
+    signals.mockResolvedValue({
+      buildHardware: "husky",
+      buildSource: "com.android.vending",
+      packageName: "com.partner.app",
+      fingerprint: "android-id-123",
+      vpn: true,
+      certificateDigest: ["AA:BB"],
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+    const values = entries(factory.make());
+
+    expect(values.get("build_hardware")).toBe("husky");
+    expect(values.get("build_source")).toBe("com.android.vending");
+    expect(values.get("package_name")).toBe("com.partner.app");
+    expect(values.get("fingerprint")).toBe("android-id-123");
+    expect(values.get("vpn")).toBe("true");
+    expect(values.get("certificate_digest")).toBe('["AA:BB"]');
+  });
+
+  it("short-circuits the whole fan-out when expo-network is absent", async () => {
+    loadExpoNetwork.mockReturnValue(null);
+
+    const factory = new UseSmileIDMetadataFactory();
+    await factory.warmup();
+
+    expect(privileges).not.toHaveBeenCalled();
+    expect(signals).not.toHaveBeenCalled();
+    expect(names(factory.make())).not.toContain("client_ip");
+  });
+});
+
+describe("UseSmileIDMetadataFactory — make()", () => {
+  it("carries the partner-supplied app name and host application", async () => {
+    const factory = new UseSmileIDMetadataFactory({
+      appName: "PartnerApp",
+      hostApplication: "PartnerApp v1.2.3",
+    });
+    await flush();
+    const values = entries(factory.make());
+
+    expect(values.get("app_name")).toBe("PartnerApp");
+    expect(values.get("host_application")).toBe("PartnerApp v1.2.3");
+    expect(values.get("session_id")).toBe(factory.sessionId);
+  });
+
+  it("reports the sdk_config provenance and the resolved capture dimensions", async () => {
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+
+    const defaults = entries(factory.make());
+    expect(defaults.get("sdk_config_source")).toBe("default");
+    expect(defaults.get("selfie_image_dimensions")).toBe("480x640");
+    expect(defaults.get("liveness_image_dimensions")).toBe("480x640");
+
+    const overridden = entries(
+      factory.make({
+        selfie: { width: 720, height: 1280 },
+        liveness: { width: 320, height: 240 },
+      }),
+    );
+    expect(overridden.get("sdk_config_source")).toBe("sdk_config");
+    expect(overridden.get("selfie_image_dimensions")).toBe("720x1280");
+    expect(overridden.get("liveness_image_dimensions")).toBe("320x240");
+  });
+
+  it("emits the Android Keystore attestation fields only on Android", async () => {
+    platform.OS = "android";
+    generateHardwareAttestation.mockResolvedValue({
+      securityLevel: 2,
+      certificateChain: ["leaf", "root"],
+      supportsAppAttest: false,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const values = entries(factory.make());
+
+    expect(values.get("supports_hardware_attestation")).toBe("2");
+    expect(values.get("attestation_certificate_chain")).toContain("leaf");
+    expect(values.has("supports_app_attest")).toBe(false);
+  });
+
+  it("omits the certificate chain when the Keystore minted none", async () => {
+    platform.OS = "android";
+    generateHardwareAttestation.mockResolvedValue({
+      securityLevel: 1,
+      certificateChain: [],
+      supportsAppAttest: false,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const metadata = factory.make();
+
+    expect(entries(metadata).get("supports_hardware_attestation")).toBe("1");
+    expect(names(metadata)).not.toContain("attestation_certificate_chain");
+  });
+
+  it("emits the App Attest capability only on iOS", async () => {
+    platform.OS = "ios";
+    generateHardwareAttestation.mockResolvedValue({
+      securityLevel: -2,
+      supportsAppAttest: true,
+    });
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const values = entries(factory.make());
+
+    expect(values.get("supports_app_attest")).toBe("true");
+    expect(values.has("supports_hardware_attestation")).toBe(false);
+  });
+
+  it("omits the attestation fields when the native probe throws", async () => {
+    platform.OS = "android";
+    generateHardwareAttestation.mockRejectedValue(new Error("no keystore"));
+
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+
+    expect(names(factory.make())).not.toContain(
+      "supports_hardware_attestation",
+    );
+  });
+
+  it("resolves the dynamic screen, orientation and locale fields per call", async () => {
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    const values = entries(factory.make());
+
+    expect(values.get("screen_resolution")).toBe("1170 × 2532");
+    expect(values.get("device_orientation")).toBe("Portrait");
+    expect(values.get("timezone")).toBe(
+      Intl.DateTimeFormat().resolvedOptions().timeZone,
+    );
+    expect(values.get("locale")).toBe(
+      Intl.DateTimeFormat().resolvedOptions().locale,
+    );
+    expect(values.get("wrapper_name")).toBe("react_native_expo");
+    expect(values.get("wrapper_version")).toBe(values.get("sdk_version"));
+  });
+
+  it("reports Landscape when the window is wider than it is tall", async () => {
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    dimensionsGet.mockImplementation(() => ({
+      width: 844,
+      height: 390,
+      scale: 3,
+    }));
+
+    expect(entries(factory.make()).get("device_orientation")).toBe("Landscape");
+  });
+
+  it("drops the screen fields when Dimensions reports a zero-sized surface", async () => {
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+    dimensionsGet.mockImplementation(() => ({
+      width: 0,
+      height: 0,
+      scale: 0,
+    }));
+    const metadata = factory.make();
+
+    expect(names(metadata)).not.toContain("screen_resolution");
+    expect(names(metadata)).not.toContain("device_orientation");
+  });
+
+  it("falls back to empty strings when Dimensions, Intl and Date throw", async () => {
+    const factory = new UseSmileIDMetadataFactory();
+    await flush();
+
+    dimensionsGet.mockImplementation(() => {
+      throw new Error("no display metrics");
+    });
+    vi.spyOn(Intl, "DateTimeFormat").mockImplementation(() => {
+      throw new Error("no ICU");
+    });
+    vi.spyOn(Date.prototype, "toISOString").mockImplementation(() => {
+      throw new Error("no clock");
+    });
+
+    const metadata = factory.make();
+
+    expect(names(metadata)).not.toContain("screen_resolution");
+    expect(names(metadata)).not.toContain("device_orientation");
+    expect(names(metadata)).not.toContain("timezone");
+    expect(names(metadata)).not.toContain("locale");
+    expect(names(metadata)).not.toContain("local_time_of_enrolment");
+  });
+});
+
+describe("generateSessionId", () => {
+  function withCrypto(value: unknown, body: () => void): void {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, "crypto");
+    Object.defineProperty(globalThis, "crypto", {
+      value,
+      configurable: true,
+      writable: true,
+    });
+    try {
+      body();
+    } finally {
+      if (descriptor) Object.defineProperty(globalThis, "crypto", descriptor);
+      else delete (globalThis as { crypto?: unknown }).crypto;
+    }
+  }
+
+  it("prefers crypto.randomUUID when available", () => {
+    withCrypto(
+      { randomUUID: () => "11111111-2222-4333-8444-555555555555" },
+      () => {
+        expect(generateSessionId()).toBe(
+          "11111111-2222-4333-8444-555555555555",
+        );
+      },
+    );
+  });
+
+  it("falls back to a UUID-v4-shaped id when crypto is unavailable", () => {
+    withCrypto(undefined, () => {
+      const id = generateSessionId();
+      const parts = id.split("-");
+      expect(parts).toHaveLength(5);
+      expect(parts[2]?.startsWith("4")).toBe(true);
+      expect(/^[0-9a-f-]+$/.test(id)).toBe(true);
+      expect(generateSessionId()).not.toBe(id);
+    });
+  });
+
+  it("falls back when crypto exists without randomUUID", () => {
+    withCrypto({}, () => {
+      expect(generateSessionId().split("-")).toHaveLength(5);
+    });
+  });
+});

package/src/metadata/builder_configuration.ts

@@ -32,6 +32,11 @@ export type BuilderConfiguration = {
   readonly allowGalleryUpload: boolean;
   readonly captureBothSides: boolean;
   readonly allowSkipBack: boolean;
+  /**
+   * Partner-declared GPC posture ("opt-out" / "opt-in") — the consent
+   * layout every session ran under.
+   */
+  readonly globalPrivacyControl: string;
 };
 
 /**
@@ -59,5 +64,6 @@ export function builderConfigurationToJson(
     allow_gallery_upload: configuration.allowGalleryUpload,
     capture_both_sides: configuration.captureBothSides,
     allow_skip_back: configuration.allowSkipBack,
+    global_privacy_control: configuration.globalPrivacyControl,
   };
 }

package/src/metadata/metadata_configuration_mappers.ts

@@ -1,3 +1,4 @@
+import { GlobalPrivacyControl } from "../core/models/global_privacy_control";
 import { AnalyzerFactoryKey } from "@smileid/usesmileid_bridge";
 
 import { CaptureType } from "../core/models/ml_config";
@@ -89,6 +90,8 @@ export function flowConfigurationToBuilderConfiguration(
     allowGalleryUpload: document?.allowGalleryUpload ?? false,
     captureBothSides: document?.captureBothSides ?? false,
     allowSkipBack: document?.allowSkipBack ?? false,
+    globalPrivacyControl:
+      configuration.config?.globalPrivacyControl ?? GlobalPrivacyControl.OptOut,
   };
 }
 
@@ -165,14 +168,13 @@ type SelfieLivenessTelemetry =
 
 /**
  * Flow-derived selfie liveness telemetry. All-`null` for flows without a selfie
- * capture; otherwise the active-liveness check (`head_pose` when enhanced
- * liveness is on, else `smile`), the version, and the selfie origin (always
- * `front_camera` — the selfie SDK has no gallery path).
+ * capture; otherwise the active-liveness check, the version, and the lens the
+ * selfie came from (the selfie SDK has no gallery path).
  */
 export function flowConfigurationToSelfieLivenessTelemetry(
   configuration: FlowConfiguration,
 ): SelfieLivenessTelemetry {
-  let selfie: { enableEnhancedLiveness: boolean } | undefined;
+  let selfie: SelfieLivenessSource;
   let hasSelfieCapture = false;
   for (const step of configuration.screens.steps) {
     if (step.kind === "capture") {
@@ -190,12 +192,24 @@ export function flowConfigurationToSelfieLivenessTelemetry(
     };
   }
   return {
-    activeLivenessType: selfie?.enableEnhancedLiveness ? "head_pose" : "smile",
+    activeLivenessType: activeLivenessTypeOf(selfie),
     activeLivenessVersion: "2.0.0",
-    selfieImageOrigin: "front_camera",
+    selfieImageOrigin: selfieImageOriginOf(selfie),
   };
 }
 
+type SelfieLivenessSource =
+  | { enableEnhancedLiveness: boolean; allowAgentMode?: boolean }
+  | undefined;
+
+function activeLivenessTypeOf(selfie: SelfieLivenessSource): string {
+  return selfie?.enableEnhancedLiveness ? "head_pose" : "smile";
+}
+
+function selfieImageOriginOf(selfie: SelfieLivenessSource): string {
+  return selfie?.allowAgentMode ? "back_camera" : "front_camera";
+}
+
 function faceDescriptorOf(
   key: AnalyzerFactoryKey | undefined,
 ): ModelDescriptor {
@@ -229,6 +243,6 @@ function faceDescriptorOf(
 const NOOP_DOCUMENT_DESCRIPTOR: ModelDescriptor = {
   provider: ModelProvider.Smile,
   name: "noop_document_detector",
-  version: "12.0.0",
+  version: "12.0.2", // x-release-please-version
   bundled: true,
 };