@loadmill/droid-cua 2.19.0 → 2.22.0

package/build/src/cli/headless-runner.js

@@ -4,7 +4,10 @@ import { getCurrentPlatform as getBrowserCurrentPlatform, getScreenshotAsBase64
 import { handleModelAction as handleBrowserModelAction } from "../browser/actions.js";
 import { ExecutionEngine } from "../core/execution-engine.js";
 import { buildExecutionModePrompt } from "../core/prompts.js";
+import { addOpenAiResponseToDroidCuaRunUsage, createDroidCuaRunUsageTotals, estimateDroidCuaRunCostUsd, setDroidCuaRunUsageModel, } from "../core/droid-cua-run-usage.js";
 import { ExecutionMode } from "../modes/execution-mode.js";
+import { reportDroidRunCompletion } from "../integrations/loadmill/run-reporter.js";
+import { reportDroidCuaCiTestRunCompleted } from "../integrations/segment/droid-cua-segment.js";
 import { printCliOutput } from "../utils/console-output.js";
 import { emitDesktopDebug } from "../utils/desktop-debug.js";
 import { loadHeadlessInstructions } from "./headless-instructions.js";
@@ -27,6 +30,18 @@ function getRecordScreenshotDirForTest(baseScreenshotDir, testName, isBatchRun)
     }
     return path.join(baseScreenshotDir, sanitizePathSegment(testName));
 }
+function toDroidCuaSegmentRunStatus(success, error = null) {
+    if (success) {
+        return "pass";
+    }
+    if (error === "Stopped by user") {
+        return "skipped";
+    }
+    if (typeof error === "string" && error.startsWith("Assertion failed:")) {
+        return "failure";
+    }
+    return "error";
+}
 function emitCliAppContextDebug(runId, appContext, appContextText) {
     if (appContext.status === "loaded" || appContext.status === "empty") {
         emitDesktopDebug("app_context.loaded", "execution", { runId }, {
@@ -56,7 +71,17 @@ function emitCliAppContextDebug(runId, appContext, appContextText) {
         });
     }
 }
-function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionPrompt, screenshotRecorder, recordScreenshots, screenshotDir, isBrowserTarget, isLambdaTestTarget, secrets = null }) {
+function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionPrompt, screenshotRecorder, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, onCuaResponse = null, secrets = null }) {
+    const sendCUARequest = async (requestArgs) => {
+        const response = await runtimeContext.openAi.sendCUARequest({
+            ...requestArgs,
+            aimAssistMode: headlessConfig.aimAssistMode,
+        });
+        if (typeof onCuaResponse === "function") {
+            onCuaResponse(response);
+        }
+        return response;
+    };
     const executionEngineOptions = {
         toolCapabilities: {
             assert: true,
@@ -72,10 +97,7 @@ function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionP
             recordScreenshots: true,
             screenshotRecorder,
             stepDelayMs: runtimeContext.config.stepDelayMs,
-            sendCUARequest: (requestArgs) => runtimeContext.openAi.sendCUARequest({
-                ...requestArgs,
-                aimAssistMode: headlessConfig.aimAssistMode,
-            }),
+            sendCUARequest,
             reviseTestScript: runtimeContext.openAi.reviseTestScript,
             ...executionEngineOptions,
         }
@@ -83,10 +105,7 @@ function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionP
             recordScreenshots,
             screenshotDir,
             stepDelayMs: runtimeContext.config.stepDelayMs,
-            sendCUARequest: (requestArgs) => runtimeContext.openAi.sendCUARequest({
-                ...requestArgs,
-                aimAssistMode: headlessConfig.aimAssistMode,
-            }),
+            sendCUARequest,
             reviseTestScript: runtimeContext.openAi.reviseTestScript,
             ...executionEngineOptions,
         };
@@ -95,21 +114,45 @@ function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionP
         engineOptions.handleModelAction = (browserSessionId, action, scale, actionContext) => handleBrowserModelAction(browserSessionId, action, scale, actionContext);
         engineOptions.getCurrentPlatform = getBrowserCurrentPlatform;
     }
-    else if (isLambdaTestTarget) {
+    else if (isCloudTarget) {
         engineOptions.connectToDevice = async () => {
-            throw new Error("LambdaTest cloud session disconnected; automatic CLI reconnect is not supported yet.");
+            throw new Error("Cloud session disconnected; automatic CLI reconnect is not supported yet.");
         };
     }
     return engineOptions;
 }
-async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isLambdaTestTarget, secrets = null, report = null, isBatchRun = false }) {
+async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, secrets = null, report = null, isBatchRun = false, reportToLoadmill = true }) {
     let executionMode = null;
+    let loadmillSessionUser = null;
+    let runUsageTotals = setDroidCuaRunUsageModel(createDroidCuaRunUsageTotals(), runtimeContext.config.cuaModel);
+    const buildSegmentUsageProperties = () => ({
+        model: runUsageTotals.model,
+        llmProviderMode: runtimeContext.config.llmProviderMode,
+        estimatedCostUsd: estimateDroidCuaRunCostUsd(runUsageTotals),
+        tokensUsed: runUsageTotals.totalTokens,
+    });
+    const reportSegmentRunCompleted = async (input) => {
+        await reportDroidCuaCiTestRunCompleted({
+            ...input,
+            runId,
+            platform: deviceInfo.platform,
+            userId: loadmillSessionUser?.id ?? null,
+            teamId: loadmillSessionUser?.teamId ?? null,
+            ...buildSegmentUsageProperties(),
+        });
+    };
     const reportEnabled = Boolean(report?.enabled);
     const collectedEvents = [];
     const addOutput = reportEnabled
         ? createCapturingAddOutput(printCliOutput, collectedEvents)
         : printCliOutput;
     try {
+        try {
+            loadmillSessionUser = await runtimeContext.loadmillClient?.getCurrentUser?.();
+        }
+        catch {
+            loadmillSessionUser = null;
+        }
         await headlessDebug.startExecutionSession(runId, {
             testName,
             ...(testDataContext ? { testDataUsed: true } : {}),
@@ -146,7 +189,10 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             recordScreenshots,
             screenshotDir,
             isBrowserTarget,
-            isLambdaTestTarget,
+            isCloudTarget,
+            onCuaResponse: (response) => {
+                runUsageTotals = addOpenAiResponseToDroidCuaRunUsage(runUsageTotals, response);
+            },
             secrets
         });
         const engine = new ExecutionEngine(session, engineOptions);
@@ -156,6 +202,7 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             addOutput,
             openAiClient: runtimeContext.openAiClient,
             loadmillClient: runtimeContext.loadmillClient,
+            runtimeConfig: runtimeContext.config,
             runtimeCredentials: runtimeContext.credentials,
             // Inline screenshots as data URLs so the HTML report is self-contained.
             ...(reportEnabled ? { includeScreenshotDataUrl: true } : {}),
@@ -173,6 +220,37 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             assertionsFailed: stats.assertionsFailed ?? 0,
             retries: stats.retryCount ?? 0
         });
+        await reportSegmentRunCompleted({
+            status: toDroidCuaSegmentRunStatus(Boolean(result.success), result.error ?? null),
+            durationMs,
+            numOfSteps: instructions.length,
+        });
+        if (reportToLoadmill) {
+            await reportDroidRunCompletion({
+                loadmillClient: runtimeContext.loadmillClient,
+                source: "ci",
+                runId,
+                projectName: path.basename(path.dirname(testPath)) || null,
+                testName,
+                runType: "test",
+                testCases: 1,
+                success: Boolean(result.success),
+                error: result.error ?? null,
+                completedAt: new Date().toISOString(),
+                durationMs,
+                platform: deviceInfo.platform,
+                deviceSource: deviceInfo.source,
+                deviceName: deviceInfo.device_name,
+                osVersion: deviceInfo.os_version,
+                instructionsTotal: instructions.length,
+                instructionsCompleted: stats.instructionsCompleted ?? 0,
+                actionsTotal: stats.actionCount ?? 0,
+                assertionsPassed: stats.assertionsPassed ?? 0,
+                assertionsFailed: stats.assertionsFailed ?? 0,
+                retries: stats.retryCount ?? 0,
+                onWarning: (message) => console.warn(`Warning: ${message}`),
+            });
+        }
         if (!result.success) {
             console.error(`\nTest failed: ${result.error}`);
         }
@@ -198,7 +276,14 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
         }
         return {
             success: Boolean(result.success),
-            error: result.error ?? null
+            error: result.error ?? null,
+            durationMs,
+            instructionsTotal: instructions.length,
+            instructionsCompleted: stats.instructionsCompleted ?? 0,
+            actionsTotal: stats.actionCount ?? 0,
+            assertionsPassed: stats.assertionsPassed ?? 0,
+            assertionsFailed: stats.assertionsFailed ?? 0,
+            retries: stats.retryCount ?? 0
         };
     }
     catch (error) {
@@ -220,10 +305,41 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
                 }
                 : { reason: "start_failed" })
         });
+        await reportSegmentRunCompleted({
+            status: "error",
+            durationMs,
+            numOfSteps: instructions.length,
+        });
+        if (reportToLoadmill) {
+            await reportDroidRunCompletion({
+                loadmillClient: runtimeContext.loadmillClient,
+                source: "ci",
+                runId,
+                projectName: path.basename(path.dirname(testPath)) || null,
+                testName,
+                runType: "test",
+                testCases: 1,
+                success: false,
+                error: message,
+                completedAt: new Date().toISOString(),
+                durationMs,
+                platform: deviceInfo.platform,
+                deviceSource: deviceInfo.source,
+                deviceName: deviceInfo.device_name,
+                osVersion: deviceInfo.os_version,
+                instructionsTotal: instructions.length,
+                instructionsCompleted: stats.instructionsCompleted ?? 0,
+                actionsTotal: stats.actionCount ?? 0,
+                assertionsPassed: stats.assertionsPassed ?? 0,
+                assertionsFailed: stats.assertionsFailed ?? 0,
+                retries: stats.retryCount ?? 0,
+                onWarning: (warningMessage) => console.warn(`Warning: ${warningMessage}`),
+            });
+        }
         throw error;
     }
 }
-export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isLambdaTestTarget, report = null, runHeadlessTestImpl = runHeadlessTest }) {
+export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, report = null, runHeadlessTestImpl = runHeadlessTest }) {
     const isBatchRun = instructionsTarget?.type === "directory" || instructionsTarget?.type === "scenario";
     if (instructionsTarget?.type === "scenario") {
         console.log(`\nRunning ${runs.length} scenario case${runs.length === 1 ? "" : "s"}\n`);
@@ -232,6 +348,16 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
         console.log(`\nRunning ${runs.length} tests from: ${instructionsTarget.path}\n`);
     }
     let failures = 0;
+    const batchStartedAt = Date.now();
+    const aggregateStats = {
+        durationMs: 0,
+        instructionsTotal: 0,
+        instructionsCompleted: 0,
+        actionsTotal: 0,
+        assertionsPassed: 0,
+        assertionsFailed: 0,
+        retries: 0
+    };
     for (const [index, run] of runs.entries()) {
         const runId = createHeadlessRunId(index);
         const testScreenshotDir = getRecordScreenshotDirForTest(screenshotDir, run.testName, isBatchRun);
@@ -259,10 +385,18 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
                 recordScreenshots,
                 screenshotDir: testScreenshotDir,
                 isBrowserTarget,
-                isLambdaTestTarget,
+                isCloudTarget,
                 report,
-                isBatchRun
+                isBatchRun,
+                reportToLoadmill: !isBatchRun
             });
+            aggregateStats.durationMs += result.durationMs ?? 0;
+            aggregateStats.instructionsTotal += result.instructionsTotal ?? 0;
+            aggregateStats.instructionsCompleted += result.instructionsCompleted ?? 0;
+            aggregateStats.actionsTotal += result.actionsTotal ?? 0;
+            aggregateStats.assertionsPassed += result.assertionsPassed ?? 0;
+            aggregateStats.assertionsFailed += result.assertionsFailed ?? 0;
+            aggregateStats.retries += result.retries ?? 0;
             if (!result.success) {
                 failures += 1;
             }
@@ -284,6 +418,35 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
         const passed = runs.length - failures;
         console.log(`\nFolder run complete: ${passed}/${runs.length} passed`);
     }
+    if (isBatchRun) {
+        const isScenario = instructionsTarget?.type === "scenario";
+        const testName = isScenario ? "Scenario run" : path.basename(instructionsTarget.path);
+        await reportDroidRunCompletion({
+            loadmillClient: runtimeContext.loadmillClient,
+            source: "ci",
+            runId: createHeadlessRunId(),
+            projectName: isScenario ? path.basename(process.cwd()) : path.basename(instructionsTarget.path),
+            testName,
+            runType: "project",
+            testCases: runs.length,
+            outcome: failures > 0 ? "failure" : "pass",
+            success: failures === 0,
+            error: failures > 0 ? `${failures} of ${runs.length} test case${runs.length === 1 ? "" : "s"} failed` : null,
+            completedAt: new Date().toISOString(),
+            durationMs: Math.max(aggregateStats.durationMs, Date.now() - batchStartedAt),
+            platform: deviceInfo.platform,
+            deviceSource: deviceInfo.source,
+            deviceName: deviceInfo.device_name,
+            osVersion: deviceInfo.os_version,
+            instructionsTotal: aggregateStats.instructionsTotal,
+            instructionsCompleted: aggregateStats.instructionsCompleted,
+            actionsTotal: aggregateStats.actionsTotal,
+            assertionsPassed: aggregateStats.assertionsPassed,
+            assertionsFailed: aggregateStats.assertionsFailed,
+            retries: aggregateStats.retries,
+            onWarning: (message) => console.warn(`Warning: ${message}`),
+        });
+    }
     return {
         exitCode: failures === 0 ? 0 : 1,
         failures

package/build/src/cli/headless-target.js

@@ -37,18 +37,25 @@ function normalizeBrowser(value) {
     }
     throw new Error("--browser must be one of: chrome, edge.");
 }
+const CLOUD_SOURCE_DISPLAY_NAMES = {
+    lambdatest: "LambdaTest",
+    "aws-device-farm": "AWS Device Farm",
+};
+function isCloudDeviceSource(deviceSource) {
+    return Object.hasOwn(CLOUD_SOURCE_DISPLAY_NAMES, deviceSource);
+}
 function normalizeDeviceSource(value) {
     if (value == null || value === "") {
         return "local";
     }
     if (typeof value !== "string") {
-        throw new Error("--device-source must be one of: local, lambdatest.");
+        throw new Error("--device-source must be one of: local, lambdatest, aws-device-farm.");
     }
     const normalized = value.trim().toLowerCase();
-    if (normalized === "local" || normalized === "lambdatest") {
+    if (normalized === "local" || isCloudDeviceSource(normalized)) {
         return normalized;
     }
-    throw new Error("--device-source must be one of: local, lambdatest.");
+    throw new Error("--device-source must be one of: local, lambdatest, aws-device-farm.");
 }
 function normalizeMobilePlatform(value, label) {
     if (!hasNonEmptyString(value)) {
@@ -72,31 +79,38 @@ function readNonEmptyCliValue(value) {
     }
     return null;
 }
-function assertNoLambdaTestFlags(args) {
-    const lambdaTestFlags = [
+function assertNoCloudFlags(args) {
+    const cloudFlags = [
         ["device-name", "--device-name"],
         ["os-version", "--os-version"],
         ["app", "--app"],
     ];
-    for (const [key, label] of lambdaTestFlags) {
+    for (const [key, label] of cloudFlags) {
         if (args[key] != null) {
-            throw new Error(`${label} can only be used with --device-source lambdatest.`);
+            throw new Error(`${label} can only be used with a cloud --device-source.`);
         }
     }
 }
-function normalizeLambdaTestAppPath(value) {
+function normalizeCloudAppPath(value, platform, deviceSource) {
     if (!hasNonEmptyString(value)) {
         return null;
     }
+    const displayName = CLOUD_SOURCE_DISPLAY_NAMES[deviceSource];
     const appPath = value.trim();
     const lower = appPath.toLowerCase();
-    if (lower.endsWith(".apk") || lower.endsWith(".ipa")) {
-        return appPath;
-    }
     if (lower.endsWith(".app")) {
-        throw new Error("LambdaTest real-device sessions require an .apk for Android or an .ipa for iOS. .app bundles are not supported.");
+        throw new Error(`${displayName} real-device sessions require an .apk for Android or an .ipa for iOS. .app bundles are not supported.`);
+    }
+    if (!lower.endsWith(".apk") && !lower.endsWith(".ipa")) {
+        throw new Error(`--app must point to an .apk or .ipa file for ${displayName} runs.`);
+    }
+    if (platform === "android" && !lower.endsWith(".apk")) {
+        throw new Error(`${displayName} Android sessions require an .apk build.`);
+    }
+    if (platform === "ios" && !lower.endsWith(".ipa")) {
+        throw new Error(`${displayName} iOS sessions require an .ipa build.`);
     }
-    throw new Error("--app must point to an .apk or .ipa file for LambdaTest runs.");
+    return appPath;
 }
 export function resolveHeadlessTarget(args = {}) {
     const target = normalizeTarget(args.target);
@@ -104,6 +118,9 @@ export function resolveHeadlessTarget(args = {}) {
     const avdName = hasNonEmptyString(args.avd) ? args.avd.trim() : null;
     const platform = normalizeMobilePlatform(args.platform, "--platform");
     const deviceSource = normalizeDeviceSource(args["device-source"]);
+    if (args["list-devices"] != null && deviceSource !== "aws-device-farm") {
+        throw new Error("--list-devices can only be used with --device-source aws-device-farm.");
+    }
     if (target === "web") {
         if (avdName || platform) {
             throw new Error("--avd and --platform cannot be used with --target web.");
@@ -111,7 +128,7 @@ export function resolveHeadlessTarget(args = {}) {
         if (deviceSource !== "local") {
             throw new Error("--device-source can only be used with --target mobile.");
         }
-        assertNoLambdaTestFlags(args);
+        assertNoCloudFlags(args);
         return {
             target,
             sessionMode,
@@ -122,6 +139,7 @@ export function resolveHeadlessTarget(args = {}) {
             deviceName: null,
             osVersion: null,
             appPath: null,
+            listDevices: false,
         };
     }
     if (args["session-mode"] != null) {
@@ -130,27 +148,42 @@ export function resolveHeadlessTarget(args = {}) {
     if (args.browser != null) {
         throw new Error("--browser can only be used with --target web.");
     }
+    // --list-devices only needs credentials — no device/app flags required.
+    if (args["list-devices"] != null) {
+        return {
+            target,
+            sessionMode: null,
+            browserFamily: null,
+            deviceSource,
+            avdName: null,
+            platform: null,
+            deviceName: null,
+            osVersion: null,
+            appPath: null,
+            listDevices: true,
+        };
+    }
     if (deviceSource === "local") {
-        assertNoLambdaTestFlags(args);
+        assertNoCloudFlags(args);
     }
-    if (deviceSource === "lambdatest") {
+    if (isCloudDeviceSource(deviceSource)) {
         const deviceName = hasNonEmptyString(args["device-name"]) ? args["device-name"].trim() : null;
         const osVersion = readNonEmptyCliValue(args["os-version"]);
-        const appPath = normalizeLambdaTestAppPath(args.app);
+        const appPath = normalizeCloudAppPath(args.app, platform, deviceSource);
         if (avdName) {
-            throw new Error("--avd cannot be used with --device-source lambdatest.");
+            throw new Error(`--avd cannot be used with --device-source ${deviceSource}.`);
         }
         if (!platform) {
-            throw new Error("--platform is required with --device-source lambdatest.");
+            throw new Error(`--platform is required with --device-source ${deviceSource}.`);
         }
         if (!deviceName) {
-            throw new Error("--device-name is required with --device-source lambdatest.");
+            throw new Error(`--device-name is required with --device-source ${deviceSource}.`);
         }
         if (!osVersion) {
-            throw new Error("--os-version is required with --device-source lambdatest.");
+            throw new Error(`--os-version is required with --device-source ${deviceSource}.`);
         }
         if (!appPath) {
-            throw new Error("--app is required with --device-source lambdatest.");
+            throw new Error(`--app is required with --device-source ${deviceSource}.`);
         }
         return {
             target,
@@ -162,6 +195,7 @@ export function resolveHeadlessTarget(args = {}) {
             deviceName,
             osVersion,
             appPath,
+            listDevices: false,
         };
     }
     return {
@@ -174,5 +208,6 @@ export function resolveHeadlessTarget(args = {}) {
         deviceName: null,
         osVersion: null,
         appPath: null,
+        listDevices: false,
     };
 }

package/build/src/commands/loadmill.js

@@ -2,7 +2,7 @@
  * Loadmill command handler
  */
 import { createLoadmillApiClient, executeLoadmillCommand, getApiToken } from "../integrations/loadmill/index.js";
-import { createResolvedLlmClient, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "../core/runtime-config.js";
+import { createResolvedLlmClient, resolveEffectiveHelperModel, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "../core/runtime-config.js";
 /**
  * Handle /loadmill command
  * @param {string} args - Command arguments (natural language command)
@@ -60,10 +60,17 @@ export async function handleLoadmill(args, session, context) {
             credentials: runtimeCredentials,
             clientName: "cli",
         });
+        const helperModel = runtimeConfig.llmProviderMode === "openai"
+            ? resolveEffectiveHelperModel({
+                llmProviderMode: runtimeConfig.llmProviderMode,
+                cuaModel: runtimeConfig.cuaModel,
+            })
+            : null;
         // Execute the command
         const result = await executeLoadmillCommand(command, {
             loadmillClient,
             openAiClient,
+            helperModel,
             onProgress: ({ message }) => {
                 addOutput({ type: 'info', text: `[Loadmill] ${message}` });
             }

package/build/src/core/droid-cua-run-usage.js

@@ -0,0 +1,106 @@
+const TOKENS_PER_MILLION = 1_000_000;
+const OPENAI_GPT_5_4_PRICING = Object.freeze({
+    inputPerMillionUsd: 2.5,
+});
+const OPENAI_GPT_5_4_MINI_PRICING = Object.freeze({
+    inputPerMillionUsd: 0.75,
+});
+const MODEL_PRICING = Object.freeze({
+    "gpt-5.4": Object.freeze({
+        ...OPENAI_GPT_5_4_PRICING,
+    }),
+    "gpt-5.4-mini": Object.freeze({
+        ...OPENAI_GPT_5_4_MINI_PRICING,
+    }),
+    // Loadmill Smart currently routes to GPT-5.4 behind the Loadmill LLM gateway.
+    // Keep this explicit so pricing can be updated here if the backing model changes.
+    "loadmill-smart": Object.freeze({
+        ...OPENAI_GPT_5_4_PRICING,
+    }),
+});
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function trimToNull(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+export function normalizeDroidCuaCostModel(model) {
+    if (typeof model !== "string") {
+        return null;
+    }
+    if (model === "gpt-5.4-mini" || model.startsWith("gpt-5.4-mini-")) {
+        return "gpt-5.4-mini";
+    }
+    if (model === "gpt-5.4" || model.startsWith("gpt-5.4-")) {
+        return "gpt-5.4";
+    }
+    if (model === "loadmill-smart" || model === "smart") {
+        return "loadmill-smart";
+    }
+    return null;
+}
+export function createDroidCuaRunUsageTotals({ model = null } = {}) {
+    const normalizedModel = trimToNull(model);
+    return {
+        model: normalizedModel,
+        costModel: normalizeDroidCuaCostModel(normalizedModel),
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0,
+    };
+}
+export function setDroidCuaRunUsageModel(totals, model) {
+    const normalizedModel = trimToNull(model);
+    if (!normalizedModel) {
+        return totals;
+    }
+    return {
+        ...totals,
+        model: totals.model ?? normalizedModel,
+        costModel: totals.costModel ?? normalizeDroidCuaCostModel(normalizedModel),
+    };
+}
+export function addOpenAiResponseToDroidCuaRunUsage(totals, response) {
+    const record = response && typeof response === "object" ? response : {};
+    const usage = record.usage && typeof record.usage === "object" ? record.usage : null;
+    if (!usage) {
+        return totals;
+    }
+    const inputDetails = usage.input_tokens_details && typeof usage.input_tokens_details === "object"
+        ? usage.input_tokens_details
+        : {};
+    const outputDetails = usage.output_tokens_details && typeof usage.output_tokens_details === "object"
+        ? usage.output_tokens_details
+        : {};
+    const observedModel = trimToNull(record.model);
+    const inputTokens = finiteNumber(usage.input_tokens);
+    const outputTokens = finiteNumber(usage.output_tokens);
+    const totalTokens = finiteNumber(usage.total_tokens) || inputTokens + outputTokens;
+    return {
+        model: totals.model ?? observedModel,
+        costModel: totals.costModel ?? normalizeDroidCuaCostModel(observedModel),
+        inputTokens: totals.inputTokens + inputTokens,
+        cachedInputTokens: totals.cachedInputTokens + finiteNumber(inputDetails.cached_tokens),
+        outputTokens: totals.outputTokens + outputTokens,
+        reasoningOutputTokens: totals.reasoningOutputTokens + finiteNumber(outputDetails.reasoning_tokens),
+        totalTokens: totals.totalTokens + totalTokens,
+    };
+}
+export function estimateDroidCuaRunCostUsd(totals) {
+    const costModel = totals.costModel ?? normalizeDroidCuaCostModel(totals.model);
+    if (!costModel) {
+        return null;
+    }
+    const pricing = MODEL_PRICING[costModel];
+    if (!pricing) {
+        return null;
+    }
+    const cost = (totals.inputTokens / TOKENS_PER_MILLION) * pricing.inputPerMillionUsd;
+    return Number(cost.toFixed(8));
+}

package/build/src/core/droid-cua-segment-events.js

@@ -0,0 +1,32 @@
+export const DroidCuaSegmentEvent = Object.freeze({
+    TEST_RUN_COMPLETED: "Droid CUA test run completed",
+});
+const VALID_TEST_RUN_STATUSES = new Set(["pass", "failure", "error", "skipped"]);
+function finiteNumberOrNull(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+export function normalizeDroidCuaTestRunStatus(value) {
+    return VALID_TEST_RUN_STATUSES.has(value) ? value : "error";
+}
+export function normalizeDroidCuaTestRunDevice(platform) {
+    if (platform === "ios")
+        return "ios";
+    if (platform === "android")
+        return "android";
+    return "web";
+}
+export function buildDroidCuaTestRunCompletedProperties(input = {}) {
+    const estimatedCostUsd = finiteNumberOrNull(input.estimatedCostUsd);
+    const tokensUsed = finiteNumberOrNull(input.tokensUsed);
+    return {
+        status: normalizeDroidCuaTestRunStatus(input.status),
+        durationMs: Math.max(0, Math.floor(finiteNumberOrNull(input.durationMs) ?? 0)),
+        numOfSteps: Math.max(0, Math.floor(finiteNumberOrNull(input.numOfSteps) ?? 0)),
+        device: normalizeDroidCuaTestRunDevice(input.platform),
+        ...(input.teamId ? { teamId: input.teamId } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        ...(input.llmProviderMode ? { llmProviderMode: input.llmProviderMode } : {}),
+        ...(estimatedCostUsd != null ? { estimatedCostUsd } : {}),
+        ...(tokensUsed != null ? { tokensUsed } : {}),
+    };
+}

package/build/src/core/report/run-log-model.js

@@ -34,6 +34,10 @@ export function mediaKindOf(line) {
 export function isHiddenExecutionLogEvent(line) {
     if (line.eventType === "run_paused")
         return true;
+    // Connecting markers drive renderer state (isConnecting) but carry no
+    // user-facing content beyond the cloud progress lines already shown.
+    if (line.eventType === "run_connecting" || line.eventType === "run_connected")
+        return true;
     return mediaKindOf(line) === "hidden-debug";
 }
 export function isGalleryMediaEvent(line) {