@loadmill/droid-cua 2.21.0 → 2.23.0

package/build/src/integrations/loadmill/run-reporter.js

@@ -0,0 +1,113 @@
+const VALID_STATUSES = new Set(["pass", "fail", "error", "skipped", "stopped"]);
+function trimToNull(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function nonNegativeNumberOrNull(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : null;
+}
+function nonNegativeIntegerOrNull(value) {
+    const normalized = nonNegativeNumberOrNull(value);
+    return normalized == null ? null : Math.floor(normalized);
+}
+function normalizeSource(value) {
+    return value === "ci" ? "ci" : "desktop";
+}
+function normalizePlatform(value) {
+    const platform = trimToNull(value);
+    return platform === "browser" ? "web" : platform;
+}
+function normalizeTestName(value) {
+    return value ? value.replace(/\.dcua$/i, "") : null;
+}
+function normalizeRunType(value, testCases) {
+    if (value === "project" || value === "test") {
+        return value;
+    }
+    return testCases > 1 ? "project" : "test";
+}
+export function normalizeDroidRunStatus({ status = null, outcome = null, success = null, error = null } = {}) {
+    if (VALID_STATUSES.has(status)) {
+        return status;
+    }
+    if (outcome === "pass" || success === true) {
+        return "pass";
+    }
+    if (error === "Stopped by user") {
+        return "stopped";
+    }
+    if (outcome === "skipped") {
+        return "skipped";
+    }
+    if (outcome === "failure" || (typeof error === "string" && error.startsWith("Assertion failed:"))) {
+        return "fail";
+    }
+    return "error";
+}
+export function buildDroidRunReportPayload(input = {}) {
+    const completedAt = trimToNull(input.completedAt) || new Date().toISOString();
+    const testCases = nonNegativeIntegerOrNull(input.testCases);
+    const payload = {
+        runType: normalizeRunType(input.runType, testCases),
+        testCases,
+        durationMs: nonNegativeIntegerOrNull(input.durationMs),
+        platform: normalizePlatform(input.platform),
+        deviceSource: trimToNull(input.deviceSource),
+        deviceName: trimToNull(input.deviceName),
+        osVersion: trimToNull(input.osVersion),
+        instructionsTotal: nonNegativeIntegerOrNull(input.instructionsTotal),
+        instructionsCompleted: nonNegativeIntegerOrNull(input.instructionsCompleted),
+        actionsTotal: nonNegativeIntegerOrNull(input.actionsTotal),
+        assertionsPassed: nonNegativeIntegerOrNull(input.assertionsPassed),
+        assertionsFailed: nonNegativeIntegerOrNull(input.assertionsFailed),
+        retries: nonNegativeIntegerOrNull(input.retries),
+        error: trimToNull(input.error),
+    };
+    for (const key of Object.keys(payload)) {
+        if (payload[key] == null) {
+            delete payload[key];
+        }
+    }
+    return {
+        runId: trimToNull(input.runId),
+        source: normalizeSource(input.source),
+        projectName: trimToNull(input.projectName),
+        testName: normalizeTestName(trimToNull(input.testName)),
+        status: normalizeDroidRunStatus(input),
+        completedAt,
+        payload,
+    };
+}
+/**
+ * @param {{
+ *   loadmillClient?: { getApiToken?: () => string | null, reportDroidRun?: (payload: object) => Promise<unknown> } | null,
+ *   onWarning?: ((message: string) => void) | null,
+ *   [key: string]: unknown,
+ * }} input
+ */
+export async function reportDroidRunCompletion({ loadmillClient, onWarning = null, ...input } = {}) {
+    if (!loadmillClient?.getApiToken?.()) {
+        return { reported: false, reason: "missing_token" };
+    }
+    if (typeof loadmillClient.reportDroidRun !== "function") {
+        return { reported: false, reason: "unsupported_client" };
+    }
+    const payload = buildDroidRunReportPayload(input);
+    if (!payload.runId) {
+        return { reported: false, reason: "missing_run_id" };
+    }
+    try {
+        await loadmillClient.reportDroidRun(payload);
+        return { reported: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (typeof onWarning === "function") {
+            onWarning(`Failed to report Droid run to Loadmill: ${message}`);
+        }
+        return { reported: false, reason: "request_failed", error: message };
+    }
+}

package/build/src/integrations/loadmill/session-user.js

@@ -0,0 +1,39 @@
+function trimToNull(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function extractUserDisplayNameFromRecord(record) {
+    for (const key of ["displayName", "fullName", "name", "email"]) {
+        const value = trimToNull(record[key]);
+        if (value) {
+            return value;
+        }
+    }
+    const nested = record.user;
+    if (nested && typeof nested === "object") {
+        return extractUserDisplayNameFromRecord(nested);
+    }
+    return null;
+}
+export function extractLoadmillSessionUser(payload) {
+    if (!payload || typeof payload !== "object") {
+        return null;
+    }
+    const record = payload;
+    const id = trimToNull(record.id) || trimToNull(record.userId);
+    const email = trimToNull(record.email);
+    const displayName = extractUserDisplayNameFromRecord(record);
+    const teamId = trimToNull(record.teamId);
+    if (!id) {
+        return null;
+    }
+    return {
+        id,
+        email,
+        displayName,
+        teamId,
+    };
+}

package/build/src/integrations/segment/droid-cua-segment.js

@@ -0,0 +1,64 @@
+import { DroidCuaSegmentEvent, buildDroidCuaTestRunCompletedProperties, } from "../../core/droid-cua-segment-events.js";
+const DEFAULT_DROID_CUA_SEGMENT_WRITE_KEY = "ZuHGZkEXjhEkvzVPMnVDJfWiNsD1nGhG";
+const SEGMENT_TRACK_URL = "https://api.segment.io/v1/track";
+function trimToNull(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+function getSegmentWriteKey() {
+    if (process.env.DROID_CUA_SEGMENT_DISABLED === "1") {
+        return null;
+    }
+    if (process.env.DROID_CUA_SEGMENT_DISABLED === "true") {
+        return null;
+    }
+    return trimToNull(process.env.SEGMENT_WRITE_KEY) || DEFAULT_DROID_CUA_SEGMENT_WRITE_KEY;
+}
+function buildBasicAuthHeader(writeKey) {
+    return `Basic ${Buffer.from(`${writeKey}:`).toString("base64")}`;
+}
+function warnSegmentError(scope, error) {
+    console.warn(`[segment] ${scope}`, error);
+}
+export async function reportDroidCuaCiTestRunCompleted(input = {}) {
+    const writeKey = getSegmentWriteKey();
+    if (!writeKey) {
+        return { reported: false, reason: "disabled" };
+    }
+    const userId = trimToNull(input.userId);
+    const anonymousId = trimToNull(input.anonymousId) || (input.runId ? `droid-cua-ci:${input.runId}` : null);
+    if (!userId && !anonymousId) {
+        return { reported: false, reason: "missing_identity" };
+    }
+    const body = {
+        ...(userId ? { userId } : { anonymousId }),
+        event: DroidCuaSegmentEvent.TEST_RUN_COMPLETED,
+        properties: buildDroidCuaTestRunCompletedProperties(input),
+    };
+    try {
+        const response = await fetch(SEGMENT_TRACK_URL, {
+            method: "POST",
+            headers: {
+                Authorization: buildBasicAuthHeader(writeKey),
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const detail = await response.text();
+            return { reported: false, reason: "request_failed", error: `Segment API error (${response.status}): ${detail}` };
+        }
+        return { reported: true };
+    }
+    catch (error) {
+        warnSegmentError("CI test run completed reporting failed", error);
+        return {
+            reported: false,
+            reason: "request_failed",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/build/src/modes/design-mode-ink.js

@@ -206,7 +206,7 @@ export class DesignModeInk {
                     toolCapabilities: this.engine.toolCapabilities,
                 });
                 // Run turn with action tracking and interruption checking
-                const { responseId: newResponseId } = await this.engine.runFullTurn(response, (action) => {
+                const { responseId: newResponseId, summary: turnSummary } = await this.engine.runFullTurn(response, (action) => {
                     // Check if user interrupted - stop immediately
                     if (this.inputQueue.length > 0) {
                         return true; // Signal to stop execution
@@ -223,6 +223,15 @@ export class DesignModeInk {
                     }
                     return false; // Continue execution
                 }, this.context, null, { currentScreenshot });
+                if (turnSummary.failed) {
+                    if (this.context.setAgentWorking) {
+                        this.context.setAgentWorking(false);
+                    }
+                    addOutput({ type: 'error', text: turnSummary.error || 'Design mode stopped.' });
+                    this.conversationActive = false;
+                    this.cleanup();
+                    return;
+                }
                 this.session.updateResponseId(newResponseId);
                 this.consecutiveErrorCount = 0;
                 // Clear agent working status

package/build/src/modes/design-mode.js

@@ -170,7 +170,7 @@ export class DesignMode {
                     toolCapabilities: this.engine.toolCapabilities,
                 });
                 // Run turn with action tracking and interruption checking
-                const { responseId: newResponseId } = await this.engine.runFullTurn(response, (action) => {
+                const { responseId: newResponseId, summary: turnSummary } = await this.engine.runFullTurn(response, (action) => {
                     // Check if user pressed ESC - stop immediately
                     if (this.escPressed) {
                         return true; // Signal to stop execution
@@ -188,6 +188,12 @@ export class DesignMode {
                     }
                     return false; // Continue execution
                 }, null, null, { currentScreenshot });
+                if (turnSummary.failed) {
+                    this.cleanupEscDetection(keypressHandler);
+                    console.log(`\n${turnSummary.error || "Design mode stopped."}`);
+                    this.conversationActive = false;
+                    return;
+                }
                 this.session.updateResponseId(newResponseId);
                 this.consecutiveErrorCount = 0;
                 // Cleanup ESC detection

package/build/src/modes/execution-mode.js

@@ -4,15 +4,15 @@ import { connectToBrowser, getBrowserInfo, getCurrentPlatform as getBrowserCurre
 import { normalizeBrowserInfoForSession } from "../browser/normalize.js";
 import { sendCUARequest } from "../device/openai.js";
 import { buildExecutionRecoveryPrompt } from "../core/prompts.js";
-import { isAssertion } from "../device/assertions.js";
+import { extractAssertionPrompt, isAssertion } from "../device/assertions.js";
+import { handleAssertionToolCall } from "../core/tool-handlers/assert.js";
 import { logger } from "../utils/logger.js";
 import { emitDesktopDebug } from "../utils/desktop-debug.js";
 import { printCliOutput } from "../utils/console-output.js";
-// Mirrors the codes emitted by the Loadmill LLM gateway (see services/app/private/llm
-// in the server repo): a transient burst limit plus day/week/fixed-budget request and
-// token quotas. Free plans run on the fixed-budget quota.
+// Mirrors the quota codes emitted by the Loadmill LLM gateway (see
+// services/app/private/llm in the server repo). Free plans run on the
+// fixed-budget quota.
 const LLM_USAGE_LIMIT_ERROR_CODES = new Set([
-    "llm_rate_limit_exceeded",
     "llm_day_quota_exceeded",
     "llm_week_quota_exceeded",
     "llm_fixed_budget_quota_exceeded",
@@ -21,6 +21,8 @@ const LLM_USAGE_LIMIT_ERROR_CODES = new Set([
     "llm_fixed_budget_token_quota_exceeded",
 ]);
 const LOADMILL_UPGRADE_URL = "https://www.loadmill.com/book-a-demo";
+const LLM_REQUEST_RATE_LIMIT_ERROR_CODE = "llm_rate_limit_exceeded";
+const DEFAULT_ASSERTION_CONTEXT = "No additional prior context is needed; validate directly from the current screen.";
 function isLlmUsageLimitError(err) {
     if (!err || typeof err !== "object") {
         return false;
@@ -30,9 +32,15 @@ function isLlmUsageLimitError(err) {
     }
     return err.status === 429 && err.type === "rate_limit_error";
 }
+function isLlmRequestRateLimitError(err) {
+    return err && typeof err === "object" && err.code === LLM_REQUEST_RATE_LIMIT_ERROR_CODE;
+}
 function getLlmUsageLimitMessage() {
     return `Execution stopped: you've reached the AI usage limit for this account. Contact the Loadmill team to upgrade: ${LOADMILL_UPGRADE_URL}`;
 }
+function getLlmRequestRateLimitMessage() {
+    return "Execution stopped: too many AI requests are running for this account right now. Please retry shortly or reduce parallel test runs.";
+}
 /**
  * Execution Mode - Run test scripts line-by-line
  * Each instruction is executed in isolation (messages cleared after each turn)
@@ -105,10 +113,11 @@ export class ExecutionMode {
         lines.push(`  Retries:      ${this.stats.retryCount}`);
         return lines;
     }
-    buildStepContext(instructionIndex) {
+    buildStepContext(instructionIndex, instruction = null) {
         return {
             instructionIndex,
             stepId: `step-${String(instructionIndex + 1).padStart(4, "0")}`,
+            ...(typeof instruction === "string" ? { instruction } : {}),
         };
     }
     emit(addOutput, type, text, context = {}, stepContext = null, extra = {}) {
@@ -123,6 +132,45 @@ export class ExecutionMode {
             payload: extra.payload
         });
     }
+    resetInstructionConversationState() {
+        this.session.updateResponseId(null);
+        if (typeof this.session.clearTranscript === "function") {
+            this.session.clearTranscript();
+            return;
+        }
+        if (Array.isArray(this.session.transcript)) {
+            this.session.transcript = [];
+        }
+    }
+    async executeVerificationInstruction(instruction, context, stepContext = null) {
+        const toolResult = await handleAssertionToolCall({
+            engine: this.engine,
+            callId: stepContext?.stepId ? `${stepContext.stepId}-assert` : "instruction-assert",
+            argumentsText: JSON.stringify({
+                condition: extractAssertionPrompt(instruction),
+                context: DEFAULT_ASSERTION_CONTEXT,
+            }),
+            context,
+            stepContext,
+        });
+        const assertionStatus = toolResult.summaryUpdates?.assertionStatus;
+        if (assertionStatus === "passed") {
+            this.stats.assertionsPassed++;
+        }
+        else if (assertionStatus === "failed" || assertionStatus === "failed_skipped") {
+            this.stats.assertionsFailed++;
+        }
+        if (toolResult.kind === "retry_instruction") {
+            this.stats.retryCount++;
+            this.session.clearMessages();
+            return await this.executeInstruction(instruction, context, 0, stepContext);
+        }
+        if (toolResult.kind === "fail") {
+            return { success: false, error: toolResult.error || "Assertion failed." };
+        }
+        this.session.clearMessages();
+        return { success: true };
+    }
     /**
      * Execute all instructions in the test script
      * @param {Object} context - Additional context (Ink context with addOutput)
@@ -137,7 +185,8 @@ export class ExecutionMode {
         // Start timing
         this.stats.startTime = Date.now();
         for (let i = 0; i < this.instructions.length; i++) {
-            const stepContext = this.buildStepContext(i);
+            const instruction = this.instructions[i];
+            const stepContext = this.buildStepContext(i, instruction);
             // Check if execution should be stopped
             if (this.shouldStop) {
                 this.emit(addOutput, 'info', 'Test execution stopped by user.', runContext, stepContext, {
@@ -158,7 +207,6 @@ export class ExecutionMode {
                     return { success: false, error: 'Stopped by user' };
                 }
             }
-            const instruction = this.instructions[i];
             this.emit(addOutput, 'user', instruction, runContext, stepContext, {
                 eventType: 'instruction_started',
                 payload: {
@@ -236,10 +284,17 @@ export class ExecutionMode {
         const MAX_RETRIES = 10;
         const instructionContext = {
             ...context,
+            currentInstruction: instruction,
             futureInstructions: this.instructions.slice((stepContext?.instructionIndex ?? -1) + 1),
         };
+        if (retryCount === 0) {
+            this.resetInstructionConversationState();
+        }
         this.session.addToTranscript(`[User] ${instruction}`);
         this.session.addMessage("user", instruction);
+        if (isAssertion(instruction)) {
+            return await this.executeVerificationInstruction(instruction, instructionContext, stepContext);
+        }
         try {
             const screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
             const currentScreenshot = await this.engine.recordScreenshot?.(screenshotBase64, {
@@ -309,6 +364,26 @@ export class ExecutionMode {
                 stack: err.stack
             });
             const addOutput = context.addOutput || printCliOutput;
+            if (isLlmRequestRateLimitError(err)) {
+                const stopMessage = getLlmRequestRateLimitMessage();
+                logger.debug('Stopping execution because an LLM request rate limit was reached', {
+                    instruction,
+                    message: err.message,
+                    status: err.status,
+                    code: err.code,
+                    type: err.type,
+                });
+                this.emit(addOutput, 'error', stopMessage, context, stepContext, {
+                    eventType: 'error',
+                    payload: {
+                        message: stopMessage,
+                        status: err.status,
+                        code: err.code,
+                        type: err.type,
+                    }
+                });
+                return { success: false, error: stopMessage, usageLimitReached: true };
+            }
             if (isLlmUsageLimitError(err)) {
                 const stopMessage = getLlmUsageLimitMessage();
                 logger.debug('Stopping execution because an LLM usage limit was reached', {
@@ -449,6 +524,7 @@ export class ExecutionMode {
             });
             // Replace the system message with the enhanced one
             this.session.installRecoverySystemPrompt(recoverySystemPrompt);
+            this.session.updateResponseId(null);
             // Wait a bit before retrying
             await new Promise(resolve => setTimeout(resolve, 1000));
             // Retry the same instruction with incremented counter

package/build/src/prompts/design.js

@@ -139,7 +139,9 @@ Test design exploration is complete. Use the validated completion summary below
 Do not call tools.
 Do not continue exploring.
 Do not add explanation.
-Output only the final result in the required design-mode format.
+Output only the exact final result format below: one "Suggested test name:" line, then one fenced code block.
+Do not use TEST NAME, GOAL, STEPS, VERIFICATIONS, FINAL STATE, markdown headings, numbered lists, or bullets.
+The fenced code block must contain only executable test instructions, one per line, ending with exit.
 
 Completion summary:
 Suggested test name: ${suggestedTestName || "(choose a short kebab-case name)"}
@@ -151,3 +153,21 @@ Verification points:
 ${formatStringList(summary.verificationPoints)}
 ${notesForScript ? `Notes for script:\n${notesForScript}\n` : ""}`;
 }
+export function buildDesignScriptFormatRetryPrompt(previousOutput = "") {
+    const previousOutputText = typeof previousOutput === "string" ? previousOutput.trim() : "";
+    return `AUTHORING FORMAT CORRECTION:
+Your previous answer did not use the required design-mode format.
+
+Output only:
+Suggested test name: short-kebab-case-name
+
+\`\`\`
+one executable instruction per line
+exit
+\`\`\`
+
+Do not include TEST NAME, GOAL, STEPS, VERIFICATIONS, FINAL STATE, markdown headings, numbered lists, bullets, or explanation.${previousOutputText ? `
+
+Previous output to reformat:
+${previousOutputText}` : ""}`;
+}

package/build/src/utils/console-output.js

@@ -1,4 +1,5 @@
 import { classifyCaptureSource } from "../core/capture-sources.js";
+import { stepCompletionData } from "../core/report/run-log-model.js";
 function isHiddenExecutionOutput(item) {
     const captureSource = item?.payload?.captureSource;
     return classifyCaptureSource(captureSource).mediaKind === "hidden-debug";
@@ -24,6 +25,10 @@ export function formatCliOutput(item) {
         if (!text || text.trim().length === 0) {
             return null;
         }
+        const stepCompletion = stepCompletionData(text);
+        if (stepCompletion) {
+            return `assistant: Step complete — ${stepCompletion.instruction}`;
+        }
         return text
             .split("\n")
             .map((line) => `assistant: ${line}`)

package/build/src/utils/cua-debug-tracer.js

@@ -92,6 +92,54 @@ function summarizeRequestInput(input) {
         };
     });
 }
+function extractImageBase64Length(imageUrl) {
+    return typeof imageUrl === "string" ? imageUrl.replace("data:image/png;base64,", "").length : 0;
+}
+function summarizeRequestScreenshots(input, deviceInfo) {
+    const screenshots = [];
+    for (const item of input) {
+        if (item?.role && Array.isArray(item.content)) {
+            for (const entry of item.content) {
+                if (entry?.type !== "input_image" || typeof entry.image_url !== "string")
+                    continue;
+                screenshots.push({
+                    source: `message:${item.role}`,
+                    base64Length: extractImageBase64Length(entry.image_url),
+                });
+            }
+            continue;
+        }
+        if (item?.type === "computer_call_output" && typeof item.output?.image_url === "string") {
+            screenshots.push({
+                source: "computer_call_output",
+                callId: item.call_id,
+                base64Length: extractImageBase64Length(item.output.image_url),
+            });
+            continue;
+        }
+        if (item?.type === "function_call_output" && Array.isArray(item.output)) {
+            for (const entry of item.output) {
+                if (entry?.type !== "input_image" || typeof entry.image_url !== "string")
+                    continue;
+                screenshots.push({
+                    source: "function_call_output",
+                    callId: item.call_id,
+                    base64Length: extractImageBase64Length(entry.image_url),
+                });
+            }
+        }
+    }
+    if (screenshots.length === 0) {
+        return null;
+    }
+    return {
+        count: screenshots.length,
+        sources: screenshots.map((entry) => entry.source),
+        base64Lengths: screenshots.map((entry) => entry.base64Length),
+        width: deviceInfo?.scaled_width ?? null,
+        height: deviceInfo?.scaled_height ?? null,
+    };
+}
 function redactRequestForFileLog(requestParams) {
     return {
         ...requestParams,
@@ -223,6 +271,7 @@ export class CuaDebugTracer {
         const localRequestId = crypto.randomUUID();
         const requestLog = redactRequestForFileLog(requestParams);
         const messages = summarizeRequestInput(input);
+        const screenshot = summarizeRequestScreenshots(input, deviceInfo);
         const acknowledgedSafetyChecksSent = input
             .filter((item) => item?.type === "computer_call_output")
             .flatMap((item) => {
@@ -260,13 +309,7 @@ export class CuaDebugTracer {
             inputItemTypes,
             inputCallIds,
             messages,
-            screenshot: screenshotBase64
-                ? {
-                    width: deviceInfo?.scaled_width ?? null,
-                    height: deviceInfo?.scaled_height ?? null,
-                    base64Length: screenshotBase64.length
-                }
-                : null,
+            screenshot,
             safetyChecks: {
                 previousPending: previousPendingSafetyChecks,
                 previousPendingCount: previousPendingSafetyChecks.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadmill/droid-cua",
-  "version": "2.21.0",
+  "version": "2.23.0",
   "description": "AI-powered Android testing agent using OpenAI's computer-use model and ADB",
   "main": "build/index.js",
   "type": "module",
@@ -20,6 +20,7 @@
     "bench:run": "tsx index.js --platform android --instructions benchmarks/benchmark.dcua --context benchmarks/context.md --debug",
     "bench:report": "node scripts/benchmark-report.js",
     "bench:report:web": "node scripts/benchmark-report-web.js",
+    "obs:droid": "node scripts/obs-droid-demo.mjs",
     "execution:profile": "node scripts/execution-profile.js",
     "test": "node --test unit-tests/*.test.js",
     "test:aws-device-farm:android": "node integration-tests/aws-device-farm-android.test.js",

package/build/src/core/cua-backends.js

@@ -1,11 +0,0 @@
-export const CUA_BACKENDS = ["openai", "fara"];
-export const DEFAULT_CUA_BACKEND = "openai";
-export const DEFAULT_FARA_BASE_URL = "http://localhost:5000/v1";
-export const DEFAULT_FARA_MODEL = "Fara-7B";
-const VALID_CUA_BACKENDS = new Set(CUA_BACKENDS);
-export function isValidCuaBackend(value) {
-    return VALID_CUA_BACKENDS.has(value);
-}
-export function resolveCuaBackend(value) {
-    return isValidCuaBackend(value) ? value : DEFAULT_CUA_BACKEND;
-}