@loadmill/droid-cua 2.21.0 → 2.23.0

package/build/index.js

@@ -15,7 +15,7 @@ import { selectDevice } from "./src/cli/device-selector.js";
 import { resolveExecutionAppContext } from "./src/core/app-context.js";
 import { resolveExecutionTestData } from "./src/core/test-data.js";
 import { getDefaultSecretsPath, resolveExecutionSecrets } from "./src/core/secrets.js";
-import { createRunContext, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "./src/core/runtime-config.js";
+import { assertRuntimeCredentialsForProvider, createRunContext, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "./src/core/runtime-config.js";
 import { resolveHeadlessExecutionConfig } from "./src/cli/headless-execution-config.js";
 import { resolveHeadlessTarget } from "./src/cli/headless-target.js";
 import { createHeadlessDebugArtifacts } from "./src/cli/headless-debug.js";
@@ -71,6 +71,33 @@ function createCliRuntimeContext(configOverrides = {}) {
         loadmillClient,
     };
 }
+async function assertCliRuntimeCredentials({ llmProviderMode }) {
+    const credentials = resolveRuntimeCredentialsFromEnv(process.env);
+    assertRuntimeCredentialsForProvider({
+        llmProviderMode,
+        credentials,
+    });
+    if (llmProviderMode !== "loadmill") {
+        return;
+    }
+    const loadmillClient = createLoadmillApiClient({
+        token: credentials.loadmillApiToken,
+        baseUrl: credentials.loadmillBaseUrl,
+    });
+    let tokenValidation = null;
+    try {
+        tokenValidation = await loadmillClient.validateApiToken();
+    }
+    catch {
+        throw new Error("Could not validate LOADMILL_API_TOKEN.");
+    }
+    if (tokenValidation?.reason === "invalid") {
+        throw new Error("LOADMILL_API_TOKEN is invalid.");
+    }
+    if (!tokenValidation?.valid) {
+        throw new Error("Could not validate LOADMILL_API_TOKEN.");
+    }
+}
 function createLambdaTestCliBuildName() {
     return `loadmill-droid-cua-cli-${new Date().toISOString().replace(/[:.]/g, "-")}`;
 }
@@ -184,6 +211,9 @@ async function main() {
     let preloadedSecrets = null;
     if (isHeadlessInstructionsRun) {
         preloadedHeadlessConfig = await resolveHeadlessExecutionConfig(args);
+        await assertCliRuntimeCredentials({
+            llmProviderMode: preloadedHeadlessConfig.llmProviderMode,
+        });
         preloadedHeadlessTarget = await resolveHeadlessInstructionsTarget(instructionsFile);
         preloadedSecrets = await resolveExecutionSecrets({
             secretsPath: getDefaultSecretsPath(process.cwd()),

package/build/src/browser/playwright/actions.js

@@ -3,7 +3,8 @@ import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
 import { buildActionEventMeta } from "../../device/action-event-meta.js";
 import { actionForErrorLog, buildActionErrorOutput, buildDebugTextField, buildSensitiveDebugFields, buildTypeActionPayload, buildTypeActionText, isSensitiveAction, } from "../../device/sensitive-action.js";
-import { getActiveBrowserPage } from "./session-state.js";
+import { normalizeAutomationUrl } from "./url.js";
+import { getActiveBrowserSession, getActiveBrowserPage } from "./session-state.js";
 const KEY_ALIASES = {
     CTRL: "Control",
     CONTROL: "Control",
@@ -58,8 +59,47 @@ function buildMeta(context, action, payload = {}) {
         payload,
     });
 }
+function handleNavigationTimeout(error, description) {
+    if (!(error instanceof Error) || error.name !== "TimeoutError") {
+        throw error;
+    }
+    console.warn(`Page load did not finish within the timeout for ${description}. Continuing with the current page state.`);
+}
+async function gotoWithTimeoutTolerance(page, url) {
+    try {
+        await page.goto(url, { waitUntil: "load" });
+    }
+    catch (error) {
+        handleNavigationTimeout(error, url);
+    }
+}
+async function goBackWithTimeoutTolerance(page) {
+    try {
+        await page.goBack({ waitUntil: "load" });
+    }
+    catch (error) {
+        handleNavigationTimeout(error, "browser history back");
+    }
+}
+async function goForwardWithTimeoutTolerance(page) {
+    try {
+        await page.goForward({ waitUntil: "load" });
+    }
+    catch (error) {
+        handleNavigationTimeout(error, "browser history forward");
+    }
+}
+function updateSessionUrlFromPage(session, page) {
+    const currentUrl = typeof page.url === "function" ? page.url() : null;
+    if (!currentUrl) {
+        return;
+    }
+    session.pageUrls?.set?.(page, currentUrl);
+    session.url = currentUrl;
+}
 export async function handleModelAction(browserSessionId, action, scale = 1, context = null) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const session = getActiveBrowserSession(browserSessionId);
     const page = getActiveBrowserPage(browserSessionId);
     try {
         emitDesktopDebug("browser.action.execute", "device", {
@@ -166,6 +206,30 @@ export async function handleModelAction(browserSessionId, action, scale = 1, con
                 await page.waitForTimeout(timeoutMs);
                 break;
             }
+            case "goto": {
+                const normalizedUrl = normalizeAutomationUrl(action.url);
+                addOutput({
+                    type: "action",
+                    text: `Navigating to ${normalizedUrl}`,
+                    ...buildMeta(context, action, { url: normalizedUrl }),
+                });
+                await gotoWithTimeoutTolerance(page, normalizedUrl);
+                session.pageUrls?.set?.(page, normalizedUrl);
+                session.url = normalizedUrl;
+                break;
+            }
+            case "back": {
+                addOutput({ type: "action", text: "Going back", ...buildMeta(context, action) });
+                await goBackWithTimeoutTolerance(page);
+                updateSessionUrlFromPage(session, page);
+                break;
+            }
+            case "forward": {
+                addOutput({ type: "action", text: "Going forward", ...buildMeta(context, action) });
+                await goForwardWithTimeoutTolerance(page);
+                updateSessionUrlFromPage(session, page);
+                break;
+            }
             default:
                 addOutput({ type: "info", text: `Unknown action: ${JSON.stringify(action)}` });
         }

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/commands/help.js

@@ -32,7 +32,7 @@ export async function handleHelp(args, session, context) {
     addOutput({ type: 'info', text: '  --session-mode <mode>  Browser session mode for web runs: persistent or fresh' });
     addOutput({ type: 'info', text: '  --config <file>        Headless execution JSON config for prompt parity' });
     addOutput({ type: 'info', text: '  --llm-provider <mode>  Headless AI provider: loadmill or openai' });
-    addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4, loadmill-smart, or gpt-5.4-mini' });
+    addOutput({ type: 'info', text: '  --cua-model <model>    Headless CUA model override: gpt-5.4, loadmill-smart, loadmill-beacon, or gpt-5.4-mini' });
     addOutput({ type: 'info', text: '  --aim-assist <mode>    Headless Aim Assist mode: off, smart, or always' });
     addOutput({ type: 'info', text: '  --context <file>       Optional app context file injected into execution runs' });
     addOutput({ type: 'info', text: '  --no-context           Disable app context for headless execution' });

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

@@ -2,15 +2,22 @@ export const DEFAULT_OPENAI_CUA_MODEL = "gpt-5.4";
 export const DEFAULT_LOADMILL_CUA_MODEL = "loadmill-smart";
 export const DEFAULT_CUA_MODEL = DEFAULT_LOADMILL_CUA_MODEL;
 export const OPENAI_CUA_MODELS = ["gpt-5.4", "gpt-5.4-mini"];
-export const LOADMILL_CUA_MODELS = [DEFAULT_LOADMILL_CUA_MODEL];
-export const CUA_MODELS = ["gpt-5.4", "loadmill-smart", "gpt-5.4-mini"];
+export const LOADMILL_CUA_MODELS = [DEFAULT_LOADMILL_CUA_MODEL, "loadmill-beacon"];
+export const CUA_MODELS = ["gpt-5.4", "loadmill-smart", "loadmill-beacon", "gpt-5.4-mini"];
 export const CUA_MODEL_OPTIONS = Object.freeze([
     Object.freeze({
         id: "loadmill-smart",
         providerMode: "loadmill",
         providerLabel: "Loadmill",
-        name: "Loadmill Smart",
-        label: "Loadmill Smart (recommended)",
+        name: "Loadmill - Smart",
+        label: "Loadmill - Smart (recommended)",
+    }),
+    Object.freeze({
+        id: "loadmill-beacon",
+        providerMode: "loadmill",
+        providerLabel: "Loadmill",
+        name: "Loadmill - Beacon",
+        label: "Loadmill - Beacon",
     }),
     Object.freeze({
         id: "gpt-5.4",

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 } : {}),
+    };
+}