@loadmill/droid-cua 2.7.0 → 2.9.0

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

@@ -0,0 +1,96 @@
+import OpenAI from "openai";
+import { readContextOptimizationEnv, normalizeContextOptimizationEnabled, normalizeContextOptimizationThreshold, } from "./context-optimization.js";
+import { resolveCuaModel } from "./cua-models.js";
+import { normalizeStepDelayMs } from "../utils/step-delay.js";
+export function createEmptyPromptCustomizations() {
+    return {
+        basePromptInstructions: "",
+        designModeInstructions: "",
+        executionModeInstructions: "",
+    };
+}
+export function resolvePromptCustomizations(rawValue = null) {
+    const resolved = createEmptyPromptCustomizations();
+    if (!rawValue || typeof rawValue !== "object" || Array.isArray(rawValue)) {
+        return resolved;
+    }
+    for (const key of Object.keys(resolved)) {
+        if (typeof rawValue[key] === "string") {
+            resolved[key] = rawValue[key];
+        }
+    }
+    return resolved;
+}
+function trimNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+export function resolveRuntimeCredentials({ openAiApiKey = null, loadmillApiToken = null, loadmillBaseUrl = null, } = {}) {
+    return {
+        openAiApiKey: trimNullableString(openAiApiKey),
+        loadmillApiToken: trimNullableString(loadmillApiToken),
+        loadmillBaseUrl: trimNullableString(loadmillBaseUrl),
+    };
+}
+export function resolveRuntimeConfig({ cuaModel = null, strictMode = false, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+    return {
+        cuaModel: resolveCuaModel(cuaModel),
+        strictMode: strictMode === true,
+        stepDelayMs: normalizeStepDelayMs(Number(stepDelayMs)),
+        contextOptimizationEnabled: normalizeContextOptimizationEnabled(contextOptimizationEnabled),
+        contextOptimizationThreshold: normalizeContextOptimizationThreshold(contextOptimizationThreshold),
+        promptCustomizations: resolvePromptCustomizations(promptCustomizations),
+        appContext: appContext && typeof appContext === "object"
+            ? {
+                enabled: appContext.enabled !== false,
+                path: trimNullableString(appContext.path ?? appContext.contextPath),
+                status: typeof appContext.status === "string" ? appContext.status : null,
+                text: typeof appContext.text === "string" ? appContext.text : "",
+                message: trimNullableString(appContext.message),
+            }
+            : {
+                enabled: true,
+                path: null,
+                status: null,
+                text: "",
+                message: null,
+            },
+    };
+}
+export function resolveRuntimeConfigFromEnv(env = process.env, overrides = {}) {
+    const contextOptimization = readContextOptimizationEnv(env);
+    return resolveRuntimeConfig({
+        cuaModel: env.OPENAI_CUA_MODEL,
+        stepDelayMs: env.DROID_CUA_STEP_DELAY_MS,
+        contextOptimizationEnabled: contextOptimization.enabled,
+        contextOptimizationThreshold: contextOptimization.threshold,
+        ...overrides,
+    });
+}
+export function resolveRuntimeCredentialsFromEnv(env = process.env, overrides = {}) {
+    return resolveRuntimeCredentials({
+        openAiApiKey: env.OPENAI_API_KEY,
+        loadmillApiToken: env.LOADMILL_API_TOKEN,
+        loadmillBaseUrl: env.LOADMILL_BASE_URL,
+        ...overrides,
+    });
+}
+export function createOpenAiClient(apiKey) {
+    return new OpenAI({
+        apiKey: trimNullableString(apiKey) || undefined,
+    });
+}
+export function createRunContext({ config, credentials }) {
+    const resolvedConfig = resolveRuntimeConfig(config);
+    const resolvedCredentials = resolveRuntimeCredentials(credentials);
+    return {
+        config: resolvedConfig,
+        credentials: resolvedCredentials,
+        clients: {
+            openai: createOpenAiClient(resolvedCredentials.openAiApiKey),
+        },
+    };
+}

package/build/src/core/session.js

@@ -1,11 +1,18 @@
 /**
  * Session manages the state for a single CLI session
- * Includes device info, message history, transcript, and response chaining
+ * Includes target info, message history, transcript, and response chaining
  */
 export class Session {
-    constructor(deviceId, deviceInfo) {
-        this.deviceId = deviceId;
-        this.deviceInfo = deviceInfo;
+    constructor(targetSessionId, targetInfo) {
+        this.deviceId = targetSessionId;
+        this.deviceInfo = targetInfo;
+        this.deviceName = targetInfo?.device_name || null;
+        this.browserSessionId = targetInfo?.platform === "browser" ? targetSessionId : null;
+        this.browserInfo = targetInfo?.platform === "browser" ? targetInfo : null;
+        this.browserName = targetInfo?.browserName || null;
+        this.currentUrl = targetInfo?.currentUrl || null;
+        this.sessionMode = targetInfo?.sessionMode || null;
+        this.targetKind = targetInfo?.platform === "browser" ? "browser" : "mobile";
         this.messages = [];
         this.previousResponseId = null;
         this.transcript = [];
@@ -54,4 +61,11 @@ export class Session {
     updateResponseId(responseId) {
         this.previousResponseId = responseId;
     }
+    /**
+     * Replace the active system prompt for the next turn and start a fresh response chain.
+     */
+    installRecoverySystemPrompt(prompt) {
+        this.messages = [{ role: "system", content: prompt }];
+        this.updateResponseId(null);
+    }
 }

package/build/src/device/action-event-meta.js

@@ -0,0 +1,18 @@
+export function buildActionEventMeta({ context, action, platform, payload = {}, extraPayload = {} }) {
+    return {
+        eventType: "tool_call",
+        actionType: action?.type,
+        runId: context?.runId,
+        stepId: context?.stepId,
+        instructionIndex: context?.instructionIndex,
+        payload: {
+            eventId: context?.eventId,
+            screenshotPath: context?.screenshotPath,
+            screenshotDataUrl: context?.screenshotDataUrl,
+            captureSource: context?.captureSource,
+            platform,
+            ...extraPayload,
+            ...payload,
+        },
+    };
+}

package/build/src/device/android/actions.js

@@ -1,6 +1,7 @@
 import { logger } from "../../utils/logger.js";
 import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
+import { buildActionEventMeta } from "../action-event-meta.js";
 import { resolveScrollGesture } from "../scroll-gesture.js";
 import { execAdb } from "./tools.js";
 function adbShell(deviceId, command) {
@@ -33,19 +34,11 @@ function normalizeMobileKeypress(keys = []) {
 }
 export async function handleModelAction(deviceId, action, scale = 1.0, context = null) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
-    const meta = (payload = {}) => ({
-        eventType: 'tool_call',
-        actionType: action?.type,
-        runId: context?.runId,
-        stepId: context?.stepId,
-        instructionIndex: context?.instructionIndex,
-        payload: {
-            eventId: context?.eventId,
-            screenshotPath: context?.screenshotPath,
-            screenshotDataUrl: context?.screenshotDataUrl,
-            platform: 'android',
-            ...payload
-        }
+    const meta = (payload = {}) => buildActionEventMeta({
+        context,
+        action,
+        platform: 'android',
+        payload
     });
     try {
         const { x, y, x1, y1, x2, y2, text, keys, path } = action;

package/build/src/device/cloud/actions.js

@@ -1,6 +1,7 @@
 import { logger } from "../../utils/logger.js";
 import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
 import { getConfiguredStepDelayMs } from "../../utils/step-delay.js";
+import { buildActionEventMeta } from "../action-event-meta.js";
 import { getActiveSession, getDevicePixelRatio } from "./connection.js";
 import { resolveScrollGesture } from "../scroll-gesture.js";
 function normalizeMobileKeypress(platform, keys = []) {
@@ -47,20 +48,14 @@ export async function handleModelAction(deviceId, action, scale = 1.0, context =
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
     const session = getActiveSession();
     const platform = session?.platform;
-    const meta = (payload = {}) => ({
-        eventType: "tool_call",
-        actionType: action?.type,
-        runId: context?.runId,
-        stepId: context?.stepId,
-        instructionIndex: context?.instructionIndex,
-        payload: {
-            eventId: context?.eventId,
-            screenshotPath: context?.screenshotPath,
-            screenshotDataUrl: context?.screenshotDataUrl,
-            platform,
-            source: session?.providerId,
-            ...payload
-        }
+    const meta = (payload = {}) => buildActionEventMeta({
+        context,
+        action,
+        platform,
+        extraPayload: {
+            source: session?.providerId
+        },
+        payload
     });
     if (!session || !platform) {
         throw new Error("No active cloud session");

package/build/src/device/cloud/connection.js

@@ -103,6 +103,14 @@ export function getActiveSession() {
 export function getDevicePixelRatio() {
     return activeSession?.devicePixelRatio || 1;
 }
+// Test-only — do not call from production code. Used by unit tests to install
+// a fake session without going through the real cloud-provider connect flow.
+export function setActiveSessionForTests(session) {
+    activeSession = session;
+}
+export function clearActiveSessionForTests() {
+    activeSession = null;
+}
 export async function disconnect() {
     if (!activeSession) {
         return;

package/build/src/device/ios/actions.js

@@ -4,6 +4,7 @@
  * Executes CUA model actions on iOS Simulator via Appium.
  */
 import * as appium from "./appium-client.js";
+import { buildActionEventMeta } from "../action-event-meta.js";
 import { getActiveSession, getDevicePixelRatio } from "./connection.js";
 import { logger } from "../../utils/logger.js";
 import { emitDesktopDebug, truncateForDebug } from "../../utils/desktop-debug.js";
@@ -44,19 +45,11 @@ function normalizeMobileKeypress(keys = []) {
 export async function handleModelAction(simulatorId, action, scale = 1.0, context = null) {
     const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
     const session = getActiveSession();
-    const meta = (payload = {}) => ({
-        eventType: "tool_call",
-        actionType: action?.type,
-        runId: context?.runId,
-        stepId: context?.stepId,
-        instructionIndex: context?.instructionIndex,
-        payload: {
-            eventId: context?.eventId,
-            screenshotPath: context?.screenshotPath,
-            screenshotDataUrl: context?.screenshotDataUrl,
-            platform: "ios",
-            ...payload
-        }
+    const meta = (payload = {}) => buildActionEventMeta({
+        context,
+        action,
+        platform: "ios",
+        payload
     });
     if (!session) {
         throw new Error("No active iOS session");

package/build/src/device/ios/connection.js

@@ -299,6 +299,14 @@ export function getActiveSession() {
 export function getDevicePixelRatio() {
     return activeSession?.devicePixelRatio || 3;
 }
+// Test-only — do not call from production code. Used by unit tests to install
+// a fake session without going through the real Appium/simulator boot flow.
+export function setActiveSessionForTests(session) {
+    activeSession = session;
+}
+export function clearActiveSessionForTests() {
+    activeSession = null;
+}
 /**
  * Disconnect and cleanup
  */

package/build/src/device/loadmill.js

@@ -3,8 +3,8 @@
  */
 import { executeLoadmillCommand } from "../integrations/loadmill/index.js";
 import { printCliOutput } from "../utils/console-output.js";
-function getLoadmillSiteBaseUrl() {
-    const rawBaseUrl = process.env.LOADMILL_BASE_URL || "https://app.loadmill.com/api";
+function getLoadmillSiteBaseUrl(loadmillClient = null) {
+    const rawBaseUrl = loadmillClient?.getBaseUrl?.() || "https://app.loadmill.com/api";
     return rawBaseUrl.replace(/\/api\/?$/, "");
 }
 /**
@@ -45,6 +45,8 @@ export function extractLoadmillCommand(userInput) {
  */
 export async function executeLoadmillInstruction(command, isHeadlessMode, context, stepContext = null) {
     const addOutput = context?.addOutput || printCliOutput;
+    const loadmillClient = context?.loadmillClient || null;
+    const openAiClient = context?.openAiClient || null;
     const meta = {
         runId: context?.runId,
         stepId: stepContext?.stepId,
@@ -54,14 +56,16 @@ export async function executeLoadmillInstruction(command, isHeadlessMode, contex
         type: 'info',
         text: `[Loadmill] Executing: ${command}`,
         eventType: 'system_message',
-        payload: { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() },
+        payload: { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) },
         ...meta
     });
     const result = await executeLoadmillCommand(command, {
+        loadmillClient,
+        openAiClient,
         onProgress: ({ message, runId }) => {
             const payload = runId
-                ? { loadmillSuiteRunId: runId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() }
-                : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() };
+                ? { loadmillSuiteRunId: runId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) }
+                : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) };
             addOutput({ type: 'info', text: `[Loadmill] ${message}`, eventType: 'system_message', payload, ...meta });
         }
     });
@@ -84,14 +88,15 @@ export async function executeLoadmillInstruction(command, isHeadlessMode, contex
  */
 export async function handleLoadmillFailure(command, error, isHeadlessMode, context, stepContext = null, suiteRunId = null) {
     const addOutput = context?.addOutput || printCliOutput;
+    const loadmillClient = context?.loadmillClient || null;
     const meta = {
         runId: context?.runId,
         stepId: stepContext?.stepId,
         instructionIndex: stepContext?.instructionIndex
     };
     const payload = suiteRunId
-        ? { loadmillSuiteRunId: suiteRunId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() }
-        : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() };
+        ? { loadmillSuiteRunId: suiteRunId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) }
+        : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) };
     addOutput({ type: 'error', text: '[Loadmill] FAILED', eventType: 'error', payload, ...meta });
     addOutput({ type: 'error', text: `Command: ${command}`, eventType: 'error', payload, ...meta });
     addOutput({ type: 'error', text: `Error: ${error}`, eventType: 'error', payload, ...meta });
@@ -148,14 +153,15 @@ export async function handleLoadmillFailure(command, error, isHeadlessMode, cont
  */
 export function handleLoadmillSuccess(command, result, context, stepContext = null) {
     const addOutput = context?.addOutput || printCliOutput;
+    const loadmillClient = context?.loadmillClient || null;
     const meta = {
         runId: context?.runId,
         stepId: stepContext?.stepId,
         instructionIndex: stepContext?.instructionIndex
     };
     const payload = result.runId
-        ? { loadmillSuiteRunId: result.runId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() }
-        : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl() };
+        ? { loadmillSuiteRunId: result.runId, loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) }
+        : { loadmillCommand: command, loadmillBaseUrl: getLoadmillSiteBaseUrl(loadmillClient) };
     if (result.action === "search") {
         addOutput({ type: 'success', text: `[Loadmill] Found ${result.result.flows.length} flow(s)`, eventType: 'system_message', payload, ...meta });
         result.result.flows.forEach((flow, i) => {

package/build/src/device/openai.js

@@ -1,15 +1,9 @@
-import OpenAI from "openai";
-import { readContextOptimizationEnv } from "../core/context-optimization.js";
 import { buildTestRevisionSystemPrompt } from "../prompts/editor.js";
-import { buildAppContextCompactionInput } from "../prompts/execution.js";
+import { createOpenAiClient, resolveRuntimeConfig } from "../core/runtime-config.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";
-let openai = null;
 const cuaDebugTracer = new CuaDebugTracer(logger);
-const VALID_CUA_MODELS = new Set(["gpt-5.4", "gpt-5.4-mini", "computer-use-preview"]);
-function getSelectedCuaModel() {
-    return VALID_CUA_MODELS.has(process.env.OPENAI_CUA_MODEL) ? process.env.OPENAI_CUA_MODEL : "gpt-5.4";
-}
 function normalizeMessageContent(content) {
     if (Array.isArray(content)) {
         return content.map((item) => {
@@ -90,37 +84,14 @@ export function buildCuaInput({ messages, screenshotBase64, previousResponseId,
     }
     return input;
 }
-function buildContextManagement(cuaModel) {
-    if (cuaModel === "computer-use-preview") {
-        return undefined;
-    }
-    const { enabled, threshold } = readContextOptimizationEnv();
-    if (!enabled) {
+function buildContextManagement(contextOptimizationEnabled, contextOptimizationThreshold) {
+    if (!contextOptimizationEnabled) {
         return undefined;
     }
-    return [{ type: "compaction", compact_threshold: threshold }];
+    return [{ type: "compaction", compact_threshold: contextOptimizationThreshold }];
 }
-export function buildCuaRequestParams({ cuaModel, previousResponseId, deviceInfo, input }) {
-    const contextManagement = buildContextManagement(cuaModel);
-    if (cuaModel === "computer-use-preview") {
-        return {
-            model: cuaModel,
-            previous_response_id: previousResponseId || undefined,
-            input,
-            store: true,
-            truncation: "auto",
-            tools: [
-                {
-                    type: "computer_use_preview",
-                    display_width: deviceInfo.scaled_width,
-                    display_height: deviceInfo.scaled_height,
-                    environment: "browser",
-                },
-                previewClickTool,
-            ],
-            reasoning: { summary: "concise" },
-        };
-    }
+export function buildCuaRequestParams({ cuaModel, previousResponseId, input, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, }) {
+    const contextManagement = buildContextManagement(contextOptimizationEnabled, contextOptimizationThreshold);
     return {
         model: cuaModel,
         reasoning: { effort: "medium" },
@@ -130,97 +101,23 @@ export function buildCuaRequestParams({ cuaModel, previousResponseId, deviceInfo
         store: true,
         truncation: "auto",
         tools: [
-            {
-                type: "computer",
-            },
+            { type: "computer" },
             previewClickTool,
         ],
     };
 }
-function shouldMapPreviewAccessError(err) {
-    const status = err?.status;
-    const code = typeof err?.code === "string" ? err.code.toLowerCase() : "";
-    const type = typeof err?.type === "string" ? err.type.toLowerCase() : "";
-    const message = typeof err?.message === "string" ? err.message.toLowerCase() : "";
-    if (status === 403 || status === 404)
-        return true;
-    if (code.includes("model_not_found") || code.includes("permission"))
-        return true;
-    if (type.includes("permission"))
-        return true;
-    return (message.includes("computer-use-preview") &&
-        (message.includes("access") || message.includes("permission") || message.includes("not found") || message.includes("unsupported")));
-}
-export function shouldMapMiniCompatibilityError(err) {
-    const status = Number(err?.status);
-    const code = typeof err?.code === "string" ? err.code.toLowerCase() : "";
-    const type = typeof err?.type === "string" ? err.type.toLowerCase() : "";
-    const message = typeof err?.message === "string" ? err.message.toLowerCase() : "";
-    const mentionsMiniModel = message.includes("gpt-5.4-mini");
-    const mentionsComputerTool = message.includes("computer") || message.includes("tool");
-    const mentionsUnsupported = (message.includes("unsupported") ||
-        message.includes("not supported") ||
-        message.includes("does not support"));
-    if (code.includes("model_not_found")) {
-        return true;
-    }
-    if (status === 404) {
-        return mentionsMiniModel && (message.includes("not found") || mentionsUnsupported);
-    }
-    if (code.includes("unsupported")) {
-        return mentionsMiniModel || mentionsComputerTool;
-    }
-    if (!type.includes("invalid")) {
-        return false;
-    }
-    return mentionsUnsupported && (mentionsMiniModel || mentionsComputerTool);
-}
-function mapCuaError(err, cuaModel) {
-    if (cuaModel === "computer-use-preview" && shouldMapPreviewAccessError(err)) {
-        const mapped = new Error("OpenAI API key does not have access to computer-use-preview. Switch to gpt-5.4 in Settings > CUA Model.");
-        mapped.cause = err;
-        return mapped;
-    }
-    if (cuaModel === "gpt-5.4-mini" && shouldMapMiniCompatibilityError(err)) {
-        const mapped = new Error("OpenAI rejected gpt-5.4-mini for computer-use execution. Switch to gpt-5.4 or computer-use-preview in Settings > CUA Model.");
-        mapped.cause = err;
-        return mapped;
-    }
-    return err;
-}
-export function isNonRetryableCuaError(err) {
-    const status = Number(err?.status);
-    const code = typeof err?.code === "string" ? err.code.toLowerCase() : "";
-    const type = typeof err?.type === "string" ? err.type.toLowerCase() : "";
-    const message = typeof err?.message === "string" ? err.message.toLowerCase() : "";
-    if ([401, 403, 404].includes(status)) {
-        return true;
-    }
-    return (code.includes("model_not_found") ||
-        code.includes("permission") ||
-        type.includes("permission") ||
-        message.includes("does not have access to computer-use-preview") ||
-        message.includes("switch to gpt-5.4 in settings > cua model") ||
-        message.includes("openai rejected gpt-5.4-mini for computer-use execution") ||
-        message.includes("switch to gpt-5.4 or computer-use-preview in settings > cua model"));
-}
-function getOpenAI() {
-    if (!openai) {
-        openai = new OpenAI({
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    return openai;
-}
 /**
  * Revise a test script based on user feedback using simple chat completion
- * @param {string} originalScript - The original test script
- * @param {string} revisionRequest - User's requested changes
+ * @param {{
+ *   client: import("openai").default,
+ *   originalScript: string,
+ *   revisionRequest: string,
+ * }} options
  * @returns {Promise<string>} - The revised test script
  */
-export async function reviseTestScript(originalScript, revisionRequest) {
-    const response = await getOpenAI().chat.completions.create({
-        model: "gpt-4o",
+export async function reviseTestScript({ client, originalScript, revisionRequest }) {
+    const response = await client.chat.completions.create({
+        model: "gpt-5.4",
         messages: [{
                 role: "system",
                 content: buildTestRevisionSystemPrompt(originalScript, revisionRequest)
@@ -228,29 +125,28 @@ export async function reviseTestScript(originalScript, revisionRequest) {
     });
     return response.choices[0].message.content.trim();
 }
-export async function compactAppContext({ contextDocument, taskDescription, tokenBudget }) {
-    const response = await getOpenAI().responses.create({
-        model: "gpt-5.4",
-        temperature: 0,
-        input: buildAppContextCompactionInput({
-            contextDocument,
-            taskDescription,
-            tokenBudget,
-        })
-    });
-    return {
-        briefing: typeof response.output_text === "string" ? response.output_text.trim() : "",
-        outputTokens: typeof response.usage?.output_tokens === "number" ? response.usage.output_tokens : null,
-    };
-}
-export async function sendCUARequest({ messages, screenshotBase64, previousResponseId, callId, deviceInfo, debugContext, }) {
-    const cuaModel = getSelectedCuaModel();
+/**
+ * @param {{
+ *   client: import("openai").default,
+ *   cuaModel: string,
+ *   contextOptimizationEnabled?: boolean,
+ *   contextOptimizationThreshold?: number,
+ *   messages: Array<unknown>,
+ *   screenshotBase64?: string,
+ *   previousResponseId?: string | null,
+ *   callId?: string | null,
+ *   deviceInfo?: unknown,
+ *   debugContext?: unknown,
+ * }} options
+ */
+export async function sendCUARequest({ client, cuaModel, contextOptimizationEnabled = true, contextOptimizationThreshold = DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD, messages, screenshotBase64, previousResponseId, callId, deviceInfo, debugContext, }) {
     const input = buildCuaInput({ messages, screenshotBase64, previousResponseId, callId });
     const requestParams = buildCuaRequestParams({
         cuaModel,
         previousResponseId,
-        deviceInfo,
         input,
+        contextOptimizationEnabled,
+        contextOptimizationThreshold,
     });
     const trace = cuaDebugTracer.startTurn({
         requestParams,
@@ -262,12 +158,44 @@ export async function sendCUARequest({ messages, screenshotBase64, previousRespo
     });
     logger.debug("CUA Request:", trace.requestLog);
     try {
-        const response = await getOpenAI().responses.create(requestParams);
+        const response = await client.responses.create(requestParams);
         cuaDebugTracer.onResponse(trace, response);
         return response;
     }
     catch (err) {
         cuaDebugTracer.onError(trace, err);
-        throw mapCuaError(err, cuaModel);
+        throw err;
     }
 }
+/**
+ * @param {{
+ *   client?: import("openai").default | null,
+ *   config?: Record<string, unknown>,
+ * }} options
+ */
+export function createOpenAiExecutor({ client, config }) {
+    const runtimeConfig = resolveRuntimeConfig(config);
+    const openAiClient = client || createOpenAiClient(null);
+    return {
+        client: openAiClient,
+        config: runtimeConfig,
+        async sendCUARequest(args) {
+            // Bind model and request-shaping config to the active run so execution
+            // stays deterministic even if settings change after the run starts.
+            return await sendCUARequest({
+                client: openAiClient,
+                cuaModel: runtimeConfig.cuaModel,
+                contextOptimizationEnabled: runtimeConfig.contextOptimizationEnabled,
+                contextOptimizationThreshold: runtimeConfig.contextOptimizationThreshold,
+                ...args,
+            });
+        },
+        async reviseTestScript(originalScript, revisionRequest) {
+            return await reviseTestScript({
+                client: openAiClient,
+                originalScript,
+                revisionRequest,
+            });
+        },
+    };
+}