@loadmill/droid-cua 2.15.1 → 2.17.0

package/build/src/core/runtime-config.js

@@ -1,7 +1,26 @@
 import OpenAI from "openai";
+import { normalizeOptionalAutomationUrl } from "../browser/playwright/url.js";
 import { readContextOptimizationEnv, normalizeContextOptimizationEnabled, normalizeContextOptimizationThreshold, } from "./context-optimization.js";
-import { resolveCuaModel } from "./cua-models.js";
+import { DEFAULT_OPENAI_CUA_MODEL, isLoadmillCuaModel, resolveCuaModel, resolveCuaModelProviderMode, } from "./cua-models.js";
+import { DEFAULT_FARA_BASE_URL, DEFAULT_FARA_MODEL, resolveCuaBackend, } from "./cua-backends.js";
 import { normalizeStepDelayMs } from "../utils/step-delay.js";
+export const LOADMILL_MODEL_ALIASES = Object.freeze({
+    DEFAULT_AGENT_MODEL: "default-agent-model",
+    FAST: "fast",
+    SMART: "smart",
+    COMPUTER_USE: "computer-use",
+});
+const LOADMILL_MODEL_ALIAS_SET = new Set(Object.values(LOADMILL_MODEL_ALIASES));
+export const LLM_PROVIDER_MODES = Object.freeze(["loadmill", "openai"]);
+export const DEFAULT_LLM_PROVIDER_MODE = "loadmill";
+export const DEFAULT_LOADMILL_BASE_URL = "https://app.loadmill.com";
+const VALID_LLM_PROVIDER_MODES = new Set(LLM_PROVIDER_MODES);
+export function isValidLlmProviderMode(value) {
+    return VALID_LLM_PROVIDER_MODES.has(value);
+}
+export function resolveLlmProviderMode(value) {
+    return isValidLlmProviderMode(value) ? value : DEFAULT_LLM_PROVIDER_MODE;
+}
 export function createEmptyPromptCustomizations() {
     return {
         basePromptInstructions: "",
@@ -28,16 +47,95 @@ function trimNullableString(value) {
     const trimmed = value.trim();
     return trimmed || null;
 }
-export function resolveRuntimeCredentials({ openAiApiKey = null, loadmillApiToken = null, loadmillBaseUrl = null, } = {}) {
+function normalizeLoadmillSiteBaseUrl(value) {
+    const trimmed = trimNullableString(value) || DEFAULT_LOADMILL_BASE_URL;
+    const normalizedCandidate = normalizeOptionalAutomationUrl(trimmed) || trimmed;
+    try {
+        const parsed = new URL(normalizedCandidate);
+        const pathname = parsed.pathname.replace(/\/+$/, "");
+        parsed.pathname = pathname
+            .replace(/\/api$/, "")
+            .replace(/\/llm\/v1$/, "")
+            .replace(/\/llm$/, "");
+        parsed.search = "";
+        parsed.hash = "";
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch {
+        return normalizedCandidate
+            .replace(/\/api\/?$/, "")
+            .replace(/\/llm\/v1\/?$/, "")
+            .replace(/\/llm\/?$/, "")
+            .replace(/\/$/, "") || null;
+    }
+}
+export function buildLoadmillLlmBaseUrl(value) {
+    const siteBaseUrl = normalizeLoadmillSiteBaseUrl(value);
+    return siteBaseUrl ? `${siteBaseUrl}/llm/v1` : null;
+}
+export function hasLoadmillLlmAccess(credentials = {}) {
+    return Boolean(trimNullableString(credentials.loadmillApiToken) &&
+        buildLoadmillLlmBaseUrl(credentials.loadmillBaseUrl));
+}
+export function hasOpenAiLlmAccess(credentials = {}) {
+    return Boolean(trimNullableString(credentials.openAiApiKey));
+}
+export function inferLlmProviderModeFromCredentials(credentials = {}) {
+    if (hasLoadmillLlmAccess(credentials)) {
+        return "loadmill";
+    }
+    if (hasOpenAiLlmAccess(credentials)) {
+        return "openai";
+    }
+    return DEFAULT_LLM_PROVIDER_MODE;
+}
+export function resolveGatewayCuaModelAlias({ cuaBackend, cuaModel } = {}) {
+    if (resolveCuaBackend(cuaBackend) === "fara") {
+        return LOADMILL_MODEL_ALIASES.COMPUTER_USE;
+    }
+    const normalizedCuaModel = resolveCuaModel(cuaModel);
+    return normalizedCuaModel === "gpt-5.4-mini"
+        ? LOADMILL_MODEL_ALIASES.FAST
+        : LOADMILL_MODEL_ALIASES.SMART;
+}
+export function resolveEffectiveCuaModel({ llmProviderMode = null, cuaBackend = null, cuaModel = null, } = {}) {
+    const providerMode = resolveLlmProviderMode(llmProviderMode);
+    if (providerMode === "loadmill") {
+        return resolveGatewayCuaModelAlias({ cuaBackend, cuaModel });
+    }
+    return resolveCuaModelProviderMode(cuaModel) === "openai"
+        ? resolveCuaModel(cuaModel)
+        : DEFAULT_OPENAI_CUA_MODEL;
+}
+export function resolveEffectiveHelperModel({ llmProviderMode = null, cuaModel = null, } = {}) {
+    if (resolveLlmProviderMode(llmProviderMode) === "loadmill") {
+        return LOADMILL_MODEL_ALIASES.DEFAULT_AGENT_MODEL;
+    }
+    return resolveCuaModelProviderMode(cuaModel) === "openai"
+        ? resolveCuaModel(cuaModel)
+        : DEFAULT_OPENAI_CUA_MODEL;
+}
+export function resolveRuntimeCredentials({ openAiApiKey = null, faraApiKey = null, faraBaseUrl = null, faraModel = null, loadmillApiToken = null, loadmillBaseUrl = null, } = {}) {
     return {
         openAiApiKey: trimNullableString(openAiApiKey),
+        faraApiKey: trimNullableString(faraApiKey),
+        faraBaseUrl: trimNullableString(faraBaseUrl) || DEFAULT_FARA_BASE_URL,
+        faraModel: trimNullableString(faraModel) || DEFAULT_FARA_MODEL,
         loadmillApiToken: trimNullableString(loadmillApiToken),
-        loadmillBaseUrl: trimNullableString(loadmillBaseUrl),
+        loadmillBaseUrl: normalizeLoadmillSiteBaseUrl(loadmillBaseUrl),
     };
 }
-export function resolveRuntimeConfig({ cuaModel = null, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+export function resolveRuntimeConfig({ llmProviderMode = null, cuaBackend = null, cuaModel = null, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+    const normalizedCuaModel = typeof cuaModel === "string" && LOADMILL_MODEL_ALIAS_SET.has(cuaModel)
+        ? cuaModel
+        : resolveCuaModel(cuaModel);
+    const normalizedProviderMode = resolveLlmProviderMode(llmProviderMode);
     return {
-        cuaModel: resolveCuaModel(cuaModel),
+        llmProviderMode: llmProviderMode == null && isLoadmillCuaModel(normalizedCuaModel)
+            ? "loadmill"
+            : normalizedProviderMode,
+        cuaBackend: resolveCuaBackend(cuaBackend),
+        cuaModel: normalizedCuaModel,
         stepDelayMs: normalizeStepDelayMs(Number(stepDelayMs)),
         contextOptimizationEnabled: normalizeContextOptimizationEnabled(contextOptimizationEnabled),
         contextOptimizationThreshold: normalizeContextOptimizationThreshold(contextOptimizationThreshold),
@@ -62,6 +160,12 @@ export function resolveRuntimeConfig({ cuaModel = null, stepDelayMs = undefined,
 export function resolveRuntimeConfigFromEnv(env = process.env, overrides = {}) {
     const contextOptimization = readContextOptimizationEnv(env);
     return resolveRuntimeConfig({
+        llmProviderMode: env.DROID_CUA_LLM_PROVIDER,
+        // Only the explicit backend flag should influence CUA model routing.
+        // Legacy screenshot-provider env vars must not silently remap Loadmill
+        // model aliases like "smart" to backend-specific aliases like
+        // "computer-use".
+        cuaBackend: env.DROID_CUA_BACKEND,
         cuaModel: env.OPENAI_CUA_MODEL,
         stepDelayMs: env.DROID_CUA_STEP_DELAY_MS,
         contextOptimizationEnabled: contextOptimization.enabled,
@@ -72,6 +176,9 @@ export function resolveRuntimeConfigFromEnv(env = process.env, overrides = {}) {
 export function resolveRuntimeCredentialsFromEnv(env = process.env, overrides = {}) {
     return resolveRuntimeCredentials({
         openAiApiKey: env.OPENAI_API_KEY,
+        faraApiKey: env.DROID_CUA_FARA_API_KEY,
+        faraBaseUrl: env.DROID_CUA_FARA_BASE_URL,
+        faraModel: env.DROID_CUA_FARA_MODEL,
         loadmillApiToken: env.LOADMILL_API_TOKEN,
         loadmillBaseUrl: env.LOADMILL_BASE_URL,
         ...overrides,
@@ -82,14 +189,151 @@ export function createOpenAiClient(apiKey) {
         apiKey: trimNullableString(apiKey) || undefined,
     });
 }
+function missingCredentialErrorMessage(llmProviderMode) {
+    return resolveLlmProviderMode(llmProviderMode) === "loadmill"
+        ? "Loadmill authentication is required to use the Loadmill model."
+        : "An OpenAI API key is required to use OpenAI models.";
+}
+function isLoadmillGatewayErrorPayload(payload) {
+    return Boolean(payload &&
+        typeof payload === "object" &&
+        typeof payload.message === "string" &&
+        typeof payload.type === "string" &&
+        typeof payload.code === "string");
+}
+function normalizeLoadmillGatewayErrorBody(body) {
+    const payload = body?.payload;
+    if (!isLoadmillGatewayErrorPayload(payload)) {
+        return null;
+    }
+    return {
+        error: {
+            message: payload.message,
+            type: payload.type,
+            code: payload.code,
+            param: payload.param ?? null,
+            provider: typeof payload.provider === "string" ? payload.provider : null,
+        },
+    };
+}
+async function normalizeLoadmillGatewayErrorResponse(response) {
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.includes("application/json")) {
+        return response;
+    }
+    const responseClone = response.clone();
+    const bodyText = await responseClone.text();
+    if (!bodyText) {
+        return response;
+    }
+    let parsedBody;
+    try {
+        parsedBody = JSON.parse(bodyText);
+    }
+    catch {
+        return response;
+    }
+    const normalizedBody = normalizeLoadmillGatewayErrorBody(parsedBody);
+    if (!normalizedBody) {
+        return response;
+    }
+    const headers = new Headers(response.headers);
+    headers.set("content-type", "application/json");
+    return new Response(JSON.stringify(normalizedBody), {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+function createLoadmillGatewayFetch(baseFetch = fetch) {
+    return async (input, init) => {
+        const response = await baseFetch(input, init);
+        if (response.ok) {
+            return response;
+        }
+        return await normalizeLoadmillGatewayErrorResponse(response);
+    };
+}
+/**
+ * @param {{
+ *   loadmillApiToken?: string | null,
+ *   loadmillBaseUrl?: string | null,
+ *   clientName?: string,
+ *   maxRetries?: number,
+ * }} [options]
+ */
+export function createLlmClient({ loadmillApiToken, loadmillBaseUrl, clientName = "desktop", maxRetries = 1, } = {}) {
+    const apiKey = trimNullableString(loadmillApiToken);
+    const baseURL = buildLoadmillLlmBaseUrl(loadmillBaseUrl);
+    if (!apiKey || !baseURL) {
+        throw new Error("Loadmill authentication is required for LLM access.");
+    }
+    return new OpenAI({
+        apiKey,
+        baseURL,
+        maxRetries,
+        fetch: createLoadmillGatewayFetch(),
+        defaultHeaders: {
+            "X-Loadmill-Client": clientName,
+        },
+    });
+}
+export function createFaraClient({ apiKey, baseUrl }) {
+    return new OpenAI({
+        apiKey: trimNullableString(apiKey) || "",
+        baseURL: trimNullableString(baseUrl) || DEFAULT_FARA_BASE_URL,
+    });
+}
+export function createResolvedLlmClient({ llmProviderMode = null, credentials = null, clientName = "desktop", maxRetries = 1, } = {}) {
+    const resolvedCredentials = resolveRuntimeCredentials(credentials);
+    const resolvedProviderMode = resolveLlmProviderMode(llmProviderMode);
+    if (resolvedProviderMode === "loadmill") {
+        if (!hasLoadmillLlmAccess(resolvedCredentials)) {
+            throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
+        }
+        return createLlmClient({
+            loadmillApiToken: resolvedCredentials.loadmillApiToken,
+            loadmillBaseUrl: resolvedCredentials.loadmillBaseUrl,
+            clientName,
+            maxRetries,
+        });
+    }
+    if (!hasOpenAiLlmAccess(resolvedCredentials)) {
+        throw new Error(missingCredentialErrorMessage(resolvedProviderMode));
+    }
+    return createOpenAiClient(resolvedCredentials.openAiApiKey);
+}
 export function createRunContext({ config, credentials }) {
     const resolvedConfig = resolveRuntimeConfig(config);
     const resolvedCredentials = resolveRuntimeCredentials(credentials);
+    const resolvedProviderMode = resolveLlmProviderMode(resolvedConfig.llmProviderMode);
+    const effectiveConfig = {
+        ...resolvedConfig,
+        llmProviderMode: resolvedProviderMode,
+        cuaModel: resolveEffectiveCuaModel({
+            llmProviderMode: resolvedProviderMode,
+            cuaBackend: resolvedConfig.cuaBackend,
+            cuaModel: resolvedConfig.cuaModel,
+        }),
+    };
+    const effectiveCredentials = {
+        ...resolvedCredentials,
+    };
     return {
-        config: resolvedConfig,
-        credentials: resolvedCredentials,
+        config: effectiveConfig,
+        credentials: effectiveCredentials,
         clients: {
-            openai: createOpenAiClient(resolvedCredentials.openAiApiKey),
+            openai: createResolvedLlmClient({
+                llmProviderMode: resolvedProviderMode,
+                credentials: resolvedCredentials,
+                clientName: "desktop",
+            }),
+            fara: resolvedConfig.cuaBackend === "fara"
+                ? createFaraClient({
+                    apiKey: resolvedCredentials.faraApiKey,
+                    baseUrl: resolvedCredentials.faraBaseUrl,
+                })
+                : null,
         },
     };
 }

package/build/src/core/scenario-planner.js

@@ -0,0 +1,85 @@
+import { resolveEffectiveHelperModel } from "./runtime-config.js";
+import { buildScenarioPlannerMessages } from "../prompts/scenario-planner.js";
+function parseScenarioPlannerContent(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid JSON.";
+        throw new Error(`Could not parse scenario planner response: ${message}`);
+    }
+}
+function normalizeCaseName(value, fallback) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    return trimmed || fallback;
+}
+function dedupeCaseNames(cases) {
+    const usedNames = new Set();
+    const baseCounts = new Map();
+    return cases.map((entry) => {
+        const baseName = entry.caseName;
+        let nextIndex = baseCounts.get(baseName) || 1;
+        let caseName = baseName;
+        while (usedNames.has(caseName)) {
+            nextIndex += 1;
+            caseName = `${baseName} (${nextIndex})`;
+        }
+        baseCounts.set(baseName, nextIndex);
+        usedNames.add(caseName);
+        return {
+            ...entry,
+            caseName,
+        };
+    });
+}
+export function validateScenarioCases(rawCases, candidateTests) {
+    if (!Array.isArray(rawCases) || rawCases.length === 0) {
+        throw new Error("Scenario planner did not return any cases.");
+    }
+    const candidateNames = new Set(candidateTests.map((test) => test.testName));
+    const normalizedCases = rawCases.map((rawCase, index) => {
+        if (!rawCase || typeof rawCase !== "object" || Array.isArray(rawCase)) {
+            throw new Error(`Scenario case ${index + 1} must be an object.`);
+        }
+        const testName = typeof rawCase.testName === "string" ? rawCase.testName.trim() : "";
+        if (!candidateNames.has(testName)) {
+            throw new Error(`Scenario case ${index + 1} references unknown test "${testName || "(missing)"}".`);
+        }
+        const caseName = normalizeCaseName(rawCase.caseName, `${testName} / Case ${index + 1}`);
+        const testDataContext = typeof rawCase.testDataContext === "string" ? rawCase.testDataContext.trim() : "";
+        return {
+            testName,
+            caseName,
+            testDataContext,
+        };
+    });
+    return dedupeCaseNames(normalizedCases);
+}
+export async function planScenarioRuns({ client, runtimeConfig, scenarioPrompt, tests, appContextText = "", testDataText = "", }) {
+    if (!client?.chat?.completions?.create) {
+        throw new Error("Scenario planning requires an LLM client.");
+    }
+    const prompt = typeof scenarioPrompt === "string" ? scenarioPrompt.trim() : "";
+    if (!prompt) {
+        throw new Error("--scenario must be a non-empty string.");
+    }
+    if (!Array.isArray(tests) || tests.length === 0) {
+        throw new Error("Scenario planning requires at least one candidate test.");
+    }
+    const response = await client.chat.completions.create({
+        model: resolveEffectiveHelperModel({
+            llmProviderMode: runtimeConfig?.llmProviderMode,
+            cuaModel: runtimeConfig?.cuaModel,
+        }),
+        messages: buildScenarioPlannerMessages({
+            scenarioPrompt: prompt,
+            tests,
+            appContextText,
+            testDataText,
+        }),
+        response_format: { type: "json_object" },
+    });
+    const content = response.choices?.[0]?.message?.content || "{}";
+    const parsed = parseScenarioPlannerContent(content);
+    return validateScenarioCases(parsed.cases, tests);
+}

package/build/src/core/test-data-import.js

@@ -0,0 +1,62 @@
+import path from "path";
+import { resolveEffectiveHelperModel } from "./runtime-config.js";
+import { buildTestDataImportMessages } from "../prompts/test-data-import.js";
+export const TEST_DATA_IMPORT_EXTENSIONS = [".csv", ".txt"];
+export function isSupportedTestDataImportPath(filePath) {
+    return TEST_DATA_IMPORT_EXTENSIONS.includes(path.extname(String(filePath ?? "")).toLowerCase());
+}
+export function assertSupportedTestDataImportPath(filePath) {
+    if (!isSupportedTestDataImportPath(filePath)) {
+        throw new Error("Test data import supports CSV and TXT files only.");
+    }
+}
+function parseTestDataImportContent(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid JSON.";
+        throw new Error(`Could not parse test data import response: ${message}`);
+    }
+}
+function normalizeGeneratedContent(value) {
+    const content = typeof value === "string" ? value.trim() : "";
+    if (!content) {
+        throw new Error("Test data import returned empty content.");
+    }
+    if (/^```/.test(content)) {
+        throw new Error("Test data import returned code-fenced content instead of markdown.");
+    }
+    return content.endsWith("\n") ? content : `${content}\n`;
+}
+export async function importTestDataMarkdown({ client, runtimeConfig, currentContent = "", importedFileName, importedFileText, instructions = "", }) {
+    if (!client?.chat?.completions?.create) {
+        throw new Error("Test data import requires an LLM client.");
+    }
+    const fileName = typeof importedFileName === "string" ? importedFileName.trim() : "";
+    if (!fileName) {
+        throw new Error("Imported file name is required.");
+    }
+    const fileText = typeof importedFileText === "string" ? importedFileText : "";
+    if (!fileText.trim()) {
+        throw new Error("Selected import file is empty.");
+    }
+    const response = await client.chat.completions.create({
+        model: resolveEffectiveHelperModel({
+            llmProviderMode: runtimeConfig?.llmProviderMode,
+            cuaModel: runtimeConfig?.cuaModel,
+        }),
+        messages: buildTestDataImportMessages({
+            currentContent,
+            importedFileName: fileName,
+            importedFileText: fileText,
+            instructions,
+        }),
+        response_format: { type: "json_object" },
+    });
+    const content = response.choices?.[0]?.message?.content || "{}";
+    const parsed = parseTestDataImportContent(content);
+    return {
+        content: normalizeGeneratedContent(parsed.content),
+    };
+}

package/build/src/core/test-data.js

@@ -0,0 +1,103 @@
+import path from "path";
+import { access, readFile } from "fs/promises";
+import { constants as fsConstants } from "fs";
+export const TEST_DATA_FILENAME = "test-data.md";
+export const DEFAULT_TEST_DATA_TEMPLATE = `# Test Data
+<!-- Concrete data the agent can use during Scenario Runs. Keep entries named and specific. -->
+<!-- Examples below are commented out so they are guidance, not usable test data. -->
+
+## Accounts
+<!--
+### Standard buyer
+Email:
+Password:
+Notes: When should the agent use this account?
+-->
+
+## Products
+<!--
+### In-stock product
+Name:
+SKU:
+Notes:
+-->
+
+## Payment Methods
+<!--
+### Valid card
+Number:
+Expiration:
+CVV:
+Notes:
+-->
+
+## Roles and Permissions
+
+## Regions and Locales
+
+## Other Data
+`;
+export function getDefaultProjectTestDataPath(projectPath) {
+    return path.join(projectPath, TEST_DATA_FILENAME);
+}
+export function normalizeTestDataTemplateText(text) {
+    return String(text ?? "").replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "").trimEnd();
+}
+export function isDefaultTestDataTemplate(text) {
+    if (!String(text ?? "").trim()) {
+        return true;
+    }
+    return normalizeTestDataTemplateText(text) === normalizeTestDataTemplateText(DEFAULT_TEST_DATA_TEMPLATE);
+}
+export async function readTestDataFile(filePath) {
+    await access(filePath, fsConstants.R_OK);
+    return await readFile(filePath, "utf-8");
+}
+export async function loadTestData({ testDataPath }) {
+    if (!testDataPath) {
+        return { text: "", testDataPath: null };
+    }
+    const text = await readTestDataFile(testDataPath);
+    return { text, testDataPath };
+}
+/**
+ * @param {{
+ *   testDataPath?: string | null,
+ *   missingFileStatus?: string | null,
+ * }} [options]
+ */
+export async function resolveExecutionTestData({ testDataPath = null, missingFileStatus = null, } = {}) {
+    if (!testDataPath) {
+        return {
+            status: "omitted",
+            text: "",
+            testDataPath: null,
+            message: null,
+        };
+    }
+    try {
+        const result = await loadTestData({ testDataPath });
+        return {
+            status: result.text.trim().length > 0 ? "loaded" : "empty",
+            text: result.text,
+            testDataPath: result.testDataPath,
+            message: null,
+        };
+    }
+    catch (error) {
+        if (missingFileStatus && error && typeof error === "object" && error.code === "ENOENT") {
+            return {
+                status: missingFileStatus,
+                text: "",
+                testDataPath,
+                message: null,
+            };
+        }
+        return {
+            status: "failed",
+            text: "",
+            testDataPath,
+            message: error instanceof Error ? error.message : "Unknown test data error",
+        };
+    }
+}

package/build/src/device/openai.js

@@ -1,10 +1,25 @@
 import { buildTestRevisionSystemPrompt } from "../prompts/editor.js";
-import { createOpenAiClient, resolveRuntimeConfig } from "../core/runtime-config.js";
+import { createOpenAiClient, LOADMILL_MODEL_ALIASES, resolveEffectiveHelperModel, resolveRuntimeConfig, } from "../core/runtime-config.js";
 import { DEFAULT_AIM_ASSIST_MODE } from "../core/aim-assist.js";
 import { DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD } from "../core/context-optimization.js";
 import { logger } from "../utils/logger.js";
 import { CuaDebugTracer } from "../utils/cua-debug-tracer.js";
 const cuaDebugTracer = new CuaDebugTracer(logger);
+function resolveOpenAiBaseUrl(client) {
+    return client?.baseURL || client?.baseUrl || client?._options?.baseURL || null;
+}
+function resolveOpenAiEndpointUrl(client, endpointPath) {
+    const baseURL = resolveOpenAiBaseUrl(client);
+    if (!baseURL) {
+        return null;
+    }
+    try {
+        return new URL(endpointPath.replace(/^\/+/, ''), `${String(baseURL).replace(/\/+$/, '')}/`).toString();
+    }
+    catch {
+        return `${String(baseURL).replace(/\/+$/, '')}/${endpointPath.replace(/^\/+/, '')}`;
+    }
+}
 function normalizeMessageContent(content) {
     if (Array.isArray(content)) {
         return content.map((item) => {
@@ -225,14 +240,15 @@ export function buildCuaRequestParams({ cuaModel, aimAssistMode = DEFAULT_AIM_AS
  * Revise a test script based on user feedback using simple chat completion
  * @param {{
  *   client: import("openai").default,
+ *   model?: string,
  *   originalScript: string,
  *   revisionRequest: string,
  * }} options
  * @returns {Promise<string>} - The revised test script
  */
-export async function reviseTestScript({ client, originalScript, revisionRequest }) {
+export async function reviseTestScript({ client, model = LOADMILL_MODEL_ALIASES.DEFAULT_AGENT_MODEL, originalScript, revisionRequest, }) {
     const response = await client.chat.completions.create({
-        model: "gpt-5.4",
+        model,
         messages: [{
                 role: "system",
                 content: buildTestRevisionSystemPrompt(originalScript, revisionRequest)
@@ -274,7 +290,14 @@ export async function sendCUARequest({ client, cuaModel, aimAssistMode = DEFAULT
         debugContext,
         previousResponseId
     });
+    trace.endpoint = {
+        baseURL: resolveOpenAiBaseUrl(client),
+        responsesURL: resolveOpenAiEndpointUrl(client, "responses"),
+        model: requestParams.model,
+        previousResponseId: requestParams.previous_response_id ?? null,
+    };
     logger.debug("CUA Request:", trace.requestLog);
+    logger.debug("CUA Request endpoint:", trace.endpoint);
     try {
         const response = await client.responses.create(requestParams);
         cuaDebugTracer.onResponse(trace, response);
@@ -311,6 +334,10 @@ export function createOpenAiExecutor({ client, config }) {
         async reviseTestScript(originalScript, revisionRequest) {
             return await reviseTestScript({
                 client: openAiClient,
+                model: resolveEffectiveHelperModel({
+                    llmProviderMode: runtimeConfig.llmProviderMode,
+                    cuaModel: runtimeConfig.cuaModel,
+                }),
                 originalScript,
                 revisionRequest,
             });

package/build/src/integrations/loadmill/executor.js

@@ -4,6 +4,7 @@
 import { createLoadmillApiClient } from "./client.js";
 import { interpretLoadmillCommand, selectBestFlow } from "./interpreter.js";
 import { extractLoadmillRuntimeParameters, renderLoadmillParameterContextNote, selectLoadmillParameterCandidates, } from "./parameters.js";
+import { LOADMILL_MODEL_ALIASES } from "../../core/runtime-config.js";
 import { logger } from "../../utils/logger.js";
 const POLL_INTERVAL_MS = 5000; // 5 seconds
 const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
@@ -62,7 +63,7 @@ async function selectRelevantParameterNames({ openAiClient, command, flowName, f
     }
     try {
         const response = await openAiClient.chat.completions.create({
-            model: "gpt-5.4",
+            model: LOADMILL_MODEL_ALIASES.DEFAULT_AGENT_MODEL,
             messages: buildParameterSelectionMessages({
                 command,
                 flowName,

package/build/src/integrations/loadmill/interpreter.js

@@ -1,6 +1,7 @@
 /**
  * AI-powered text interpretation for Loadmill commands
  */
+import { LOADMILL_MODEL_ALIASES } from "../../core/runtime-config.js";
 import { buildLoadmillCommandInterpretationMessages, buildLoadmillFlowSelectionMessages, } from "../../prompts/loadmill.js";
 /**
  * Interpret a natural language Loadmill command into structured data
@@ -9,7 +10,7 @@ import { buildLoadmillCommandInterpretationMessages, buildLoadmillFlowSelectionM
  */
 export async function interpretLoadmillCommand(userInput, { client }) {
     const response = await client.chat.completions.create({
-        model: "gpt-4o-mini",
+        model: LOADMILL_MODEL_ALIASES.FAST,
         messages: buildLoadmillCommandInterpretationMessages(userInput),
         response_format: { type: "json_object" }
     });
@@ -41,7 +42,7 @@ export async function selectBestFlow(flows, originalQuery, { client }) {
         return `${i + 1}. ID: ${f.id}, Name: "${name}"${suite ? `, Suite: "${suite}"` : ""}`;
     }).join("\n");
     const response = await client.chat.completions.create({
-        model: "gpt-4o-mini",
+        model: LOADMILL_MODEL_ALIASES.FAST,
         messages: buildLoadmillFlowSelectionMessages(originalQuery, flowList),
         response_format: { type: "json_object" }
     });