@loadmill/droid-cua 2.21.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, isCloudTarget, 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,
         };
@@ -102,14 +121,38 @@ function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionP
     }
     return engineOptions;
 }
-async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, 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 } : {}),
@@ -147,6 +190,9 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             screenshotDir,
             isBrowserTarget,
             isCloudTarget,
+            onCuaResponse: (response) => {
+                runUsageTotals = addOpenAiResponseToDroidCuaRunUsage(runUsageTotals, response);
+            },
             secrets
         });
         const engine = new ExecutionEngine(session, engineOptions);
@@ -174,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}`);
         }
@@ -199,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) {
@@ -221,6 +305,37 @@ 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;
     }
 }
@@ -233,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);
@@ -262,8 +387,16 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
                 isBrowserTarget,
                 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;
             }
@@ -285,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/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/integrations/loadmill/client.js

@@ -1,6 +1,7 @@
 /**
  * Loadmill API client for interacting with test flows
  */
+import { extractLoadmillSessionUser } from "./session-user.js";
 const DEFAULT_BASE_URL = "https://app.loadmill.com/api";
 function normalizeApiBaseUrl(rawBaseUrl) {
     const candidate = (rawBaseUrl || DEFAULT_BASE_URL).trim();
@@ -19,6 +20,10 @@ function normalizeApiBaseUrl(rawBaseUrl) {
         return DEFAULT_BASE_URL;
     }
 }
+function normalizeSiteBaseUrl(rawBaseUrl) {
+    const apiBaseUrl = normalizeApiBaseUrl(rawBaseUrl);
+    return apiBaseUrl.replace(/\/api$/, "");
+}
 /**
  * @param {{
  *   token?: string | null,
@@ -33,6 +38,9 @@ export function createLoadmillApiClient({ token = null, baseUrl = null, onUnauth
     function getBaseUrl() {
         return normalizeApiBaseUrl(baseUrl);
     }
+    function getSiteBaseUrl() {
+        return normalizeSiteBaseUrl(baseUrl);
+    }
     async function apiRequest(endpoint, options = {}) {
         const resolvedToken = getApiToken();
         if (!resolvedToken) {
@@ -124,9 +132,38 @@ export function createLoadmillApiClient({ token = null, baseUrl = null, onUnauth
             }),
         });
     }
+    async function reportDroidRun(payload) {
+        return await apiRequest(`/droid-cua/runs`, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+    }
+    async function getCurrentUser() {
+        const resolvedToken = getApiToken();
+        if (!resolvedToken) {
+            return null;
+        }
+        const response = await fetch(`${getSiteBaseUrl()}/auth/logged-in-user`, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${resolvedToken}`,
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        try {
+            return extractLoadmillSessionUser(await response.json());
+        }
+        catch {
+            return null;
+        }
+    }
     return {
         getApiToken,
         getBaseUrl,
+        getSiteBaseUrl,
         searchFlows,
         runTestSuite,
         runTestFlow,
@@ -134,6 +171,8 @@ export function createLoadmillApiClient({ token = null, baseUrl = null, onUnauth
         getFlowRunStatus,
         getTestSuiteFlowRun,
         explainFailure,
+        reportDroidRun,
+        getCurrentUser,
     };
 }
 export function getApiToken() {
@@ -185,6 +224,13 @@ export async function getFlowRunStatus(flowRunId) {
         onUnauthorized: globalThis.__DROID_CUA_HANDLE_LOADMILL_UNAUTHORIZED__,
     }).getFlowRunStatus(flowRunId);
 }
+export async function reportDroidRun(payload) {
+    return await createLoadmillApiClient({
+        token: process.env.LOADMILL_API_TOKEN,
+        baseUrl: process.env.LOADMILL_BASE_URL,
+        onUnauthorized: globalThis.__DROID_CUA_HANDLE_LOADMILL_UNAUTHORIZED__,
+    }).reportDroidRun(payload);
+}
 export async function getTestSuiteFlowRun(flowRunId) {
     return await createLoadmillApiClient({
         token: process.env.LOADMILL_API_TOKEN,

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadmill/droid-cua",
-  "version": "2.21.0",
+  "version": "2.22.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",