@loadmill/droid-cua 2.2.2 → 2.4.0

package/build/src/device/assertions.js

@@ -1,6 +1,8 @@
 /**
  * Assertion handling for script validation
  */
+import { printCliOutput } from "../utils/console-output.js";
+export { buildAssertionSystemPrompt } from "../prompts/execution.js";
 export function isAssertion(userInput) {
     const trimmed = userInput.trim();
     const lower = trimmed.toLowerCase();
@@ -19,27 +21,6 @@ export function extractAssertionPrompt(userInput) {
     }
     return trimmed;
 }
-export function buildAssertionSystemPrompt(baseSystemPrompt, assertionPrompt) {
-    return `${baseSystemPrompt}
-
-ASSERTION MODE:
-You are now validating an assertion. The user has provided an assertion statement that you must verify.
-
-Your task:
-1. Take screenshots and perform LIMITED actions if needed to validate the assertion.
-2. Determine if the assertion is TRUE or FALSE based on the current state.
-3. You MUST respond with a clear verdict in this exact format:
-   - If the assertion is true, include the text: "ASSERTION RESULT: PASS"
-   - If the assertion is false or cannot be confidently validated, include: "ASSERTION RESULT: FAIL"
-4. After the verdict, provide a brief explanation (1-2 sentences) of why it passed or failed.
-
-The assertion to validate is: "${assertionPrompt}"
-
-Remember:
-- If you cannot confidently validate the assertion, treat it as FAIL.
-- You must include either "ASSERTION RESULT: PASS" or "ASSERTION RESULT: FAIL" in your response.
-- Be thorough but efficient. Only take the actions necessary to validate the assertion.`;
-}
 export function checkAssertionResult(transcript) {
     const transcriptText = transcript.join("\n");
     const hasPassed = transcriptText.includes("ASSERTION RESULT: PASS");
@@ -56,7 +37,7 @@ export function extractFailureDetails(transcript) {
 }
 export function handleAssertionFailure(assertionPrompt, transcript, isHeadlessMode, context, stepContext = null) {
     const details = extractFailureDetails(transcript);
-    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const addOutput = context?.addOutput || printCliOutput;
     const meta = {
         eventType: 'assertion_result',
         runId: context?.runId,
@@ -81,7 +62,7 @@ export function handleAssertionFailure(assertionPrompt, transcript, isHeadlessMo
     // Interactive mode: caller should clear remaining instructions
 }
 export function handleAssertionSuccess(assertionPrompt, context = null, stepContext = null) {
-    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const addOutput = context?.addOutput || printCliOutput;
     addOutput({
         type: 'success',
         text: `✓ Assertion passed: ${assertionPrompt}`,

package/build/src/device/cloud/browserstack/adapter.js

@@ -195,6 +195,7 @@ function readAppStatusEntry(payload) {
     }
     return entries;
 }
+/** @type {import("../adapter").CloudProviderAdapter} */
 export const browserStackAdapter = {
     id: "browserstack",
     displayName: "BrowserStack",

package/build/src/device/cloud/lambdatest/adapter.js

@@ -0,0 +1,402 @@
+import { readFile } from "node:fs/promises";
+const HUB_URL = "https://mobile-hub.lambdatest.com/wd/hub";
+const CONCURRENCY_URL = "https://mobile-api.lambdatest.com/mobile-automation/api/v1/org/concurrency";
+const DEVICE_REGIONS = ["us", "ap", "eu"];
+const DEVICE_LIST_URL = "https://mobile-api.lambdatest.com/mobile-automation/api/v1/list";
+const APP_UPLOAD_URL = "https://manual-api.lambdatest.com/app/upload/realDevice";
+const APP_DATA_URL = "https://manual-api.lambdatest.com/app/data";
+function notImplemented(methodName) {
+    throw new Error(`LambdaTest adapter stub: ${methodName} is not implemented yet.`);
+}
+function normalizeString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function normalizeRemoteAppRef(value) {
+    const normalized = normalizeString(value);
+    return normalized?.startsWith("lt://") ? normalized : undefined;
+}
+function normalizePlanLabel(value) {
+    if (typeof value === "string") {
+        return value.trim() || undefined;
+    }
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return (normalizePlanLabel(value.plan) ??
+            normalizePlanLabel(value.name) ??
+            normalizePlanLabel(value.label) ??
+            normalizePlanLabel(value.tier) ??
+            normalizePlanLabel(value.type));
+    }
+    return undefined;
+}
+function readPlanLabel(payload) {
+    const candidates = [
+        payload.plan,
+        payload.plan_name,
+        payload.planName,
+        payload.plan_type,
+        payload.account_plan,
+        payload.accountPlan,
+        payload.tier,
+        payload.tier_name,
+        payload.subscription,
+        payload.organization_plan
+    ];
+    for (const candidate of candidates) {
+        const normalized = normalizePlanLabel(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+function readFiniteNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function readParallelLimit(payload) {
+    const candidates = [
+        payload.max_concurrency,
+        payload.maxConcurrency,
+        payload.parallel_sessions,
+        payload.parallelSessions,
+        payload.parallel_limit,
+        payload.parallelLimit,
+        payload.concurrency,
+        payload.max_sessions,
+        payload.maxSessions
+    ];
+    for (const candidate of candidates) {
+        const normalized = readFiniteNumber(candidate);
+        if (normalized !== undefined) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+function readSummary(payload, plan, parallelLimit) {
+    const message = normalizeString(payload.message) ??
+        normalizeString(payload.summary) ??
+        normalizeString(payload.status_message) ??
+        normalizeString(payload.statusMessage);
+    if (message) {
+        return message;
+    }
+    if (plan && parallelLimit !== undefined) {
+        return `${plan} account with ${parallelLimit} parallel sessions available.`;
+    }
+    if (parallelLimit !== undefined) {
+        return `LambdaTest credentials validated. ${parallelLimit} parallel sessions available.`;
+    }
+    return undefined;
+}
+function normalizePlatform(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "android") {
+        return "android";
+    }
+    if (normalized === "ios" || normalized === "iphone" || normalized === "ipad") {
+        return "ios";
+    }
+    return null;
+}
+function sortOsVersionsDescending(values) {
+    return [...values].sort((left, right) => right.localeCompare(left, undefined, { numeric: true, sensitivity: "base" }));
+}
+function unwrapDevicePayload(payload) {
+    if (Array.isArray(payload)) {
+        return payload;
+    }
+    if (typeof payload !== "object" || payload === null) {
+        return [];
+    }
+    const candidates = [payload.devices, payload.data, payload.results, payload.list];
+    for (const candidate of candidates) {
+        if (Array.isArray(candidate)) {
+            return candidate;
+        }
+    }
+    return [];
+}
+async function requestConcurrency(creds) {
+    const response = await fetch(CONCURRENCY_URL, {
+        method: "GET",
+        headers: {
+            Authorization: lambdaTestAdapter.getAuthHeader(creds)
+        }
+    });
+    if (response.status === 401 || response.status === 403) {
+        throw new Error("LambdaTest rejected these credentials. Check the username and access key and try again.");
+    }
+    if (!response.ok) {
+        throw new Error(`LambdaTest validation failed with status ${response.status}.`);
+    }
+    const payload = await response.json();
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        throw new Error("LambdaTest returned an unexpected validation response.");
+    }
+    const plan = readPlanLabel(payload);
+    const parallelLimit = readParallelLimit(payload);
+    const summary = readSummary(payload, plan, parallelLimit);
+    return {
+        plan,
+        parallelLimit,
+        summary
+    };
+}
+async function requestDevicesForRegion(creds, region) {
+    const response = await fetch(`${DEVICE_LIST_URL}?region=${encodeURIComponent(region)}`, {
+        method: "GET",
+        headers: {
+            Authorization: lambdaTestAdapter.getAuthHeader(creds)
+        }
+    });
+    if (response.status === 401 || response.status === 403) {
+        throw new Error("LambdaTest rejected these credentials. Reconnect LambdaTest and try refreshing devices again.");
+    }
+    if (!response.ok) {
+        throw new Error(`LambdaTest device catalog failed with status ${response.status}.`);
+    }
+    return unwrapDevicePayload(await response.json());
+}
+async function requestDevices(creds) {
+    const regionPayloads = await Promise.all(DEVICE_REGIONS.map((region) => requestDevicesForRegion(creds, region)));
+    const deduped = new Map();
+    for (const payload of regionPayloads.flat()) {
+        if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+            continue;
+        }
+        const platform = normalizePlatform(payload.platform) ??
+            normalizePlatform(payload.platformName) ??
+            normalizePlatform(payload.os) ??
+            normalizePlatform(payload.os_type) ??
+            normalizePlatform(payload.osType);
+        const deviceName = normalizeString(payload.device_name) ??
+            normalizeString(payload.deviceName) ??
+            normalizeString(payload.device) ??
+            normalizeString(payload.name);
+        const osVersion = normalizeString(payload.platform_version) ??
+            normalizeString(payload.platformVersion) ??
+            normalizeString(payload.os_version) ??
+            normalizeString(payload.osVersion) ??
+            normalizeString(payload.version);
+        if (!platform || !deviceName || !osVersion) {
+            continue;
+        }
+        const key = `${platform}::${deviceName}::${osVersion}`;
+        if (!deduped.has(key)) {
+            deduped.set(key, {
+                id: key,
+                name: deviceName,
+                deviceName,
+                platform,
+                osVersion
+            });
+        }
+    }
+    return [...deduped.values()].sort((left, right) => {
+        if (left.platform !== right.platform) {
+            return left.platform.localeCompare(right.platform);
+        }
+        if (left.name !== right.name) {
+            return left.name.localeCompare(right.name);
+        }
+        return sortOsVersionsDescending([left.osVersion ?? "", right.osVersion ?? ""])[0] === (left.osVersion ?? "") ? -1 : 1;
+    });
+}
+function readUploadedAppEntries(payload) {
+    if (Array.isArray(payload)) {
+        return payload;
+    }
+    if (typeof payload !== "object" || payload === null) {
+        return [];
+    }
+    const candidates = [payload.data, payload.apps, payload.files, payload.results];
+    for (const candidate of candidates) {
+        if (Array.isArray(candidate)) {
+            return candidate;
+        }
+    }
+    return [];
+}
+async function uploadRealDeviceApp(creds, localPath) {
+    const fileContents = await readFile(localPath);
+    const fileName = localPath.split(/[\\/]/).pop() ?? "app";
+    const form = new FormData();
+    form.append("appFile", new Blob([new Uint8Array(fileContents)]), fileName);
+    const response = await fetch(APP_UPLOAD_URL, {
+        method: "POST",
+        headers: {
+            Authorization: lambdaTestAdapter.getAuthHeader(creds)
+        },
+        body: form
+    });
+    if (response.status === 401 || response.status === 403) {
+        throw new Error("LambdaTest rejected these credentials. Reconnect LambdaTest and try again.");
+    }
+    if (!response.ok) {
+        throw new Error(`LambdaTest app upload failed with status ${response.status}.`);
+    }
+    const payload = await response.json();
+    if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+        throw new Error("LambdaTest returned an unexpected app upload response.");
+    }
+    const remotePath = normalizeRemoteAppRef(payload.app_url) ??
+        normalizeRemoteAppRef(payload.appUrl) ??
+        normalizeRemoteAppRef(payload.appURL) ??
+        normalizeRemoteAppRef(payload.value) ??
+        normalizeRemoteAppRef(payload.id);
+    if (!remotePath) {
+        throw new Error("LambdaTest did not return a valid app reference.");
+    }
+    const id = normalizeString(payload.app_id) ??
+        normalizeString(payload.appId) ??
+        normalizeString(payload.id) ??
+        remotePath;
+    return {
+        id,
+        remotePath
+    };
+}
+async function fetchUploadedApps(creds, platformType) {
+    const response = await fetch(`${APP_DATA_URL}?type=${encodeURIComponent(platformType)}&level=user`, {
+        method: "GET",
+        headers: {
+            Authorization: lambdaTestAdapter.getAuthHeader(creds)
+        }
+    });
+    if (response.status === 401 || response.status === 403) {
+        throw new Error("LambdaTest rejected these credentials. Reconnect LambdaTest and try again.");
+    }
+    if (!response.ok) {
+        throw new Error(`LambdaTest uploaded-app lookup failed with status ${response.status}.`);
+    }
+    return readUploadedAppEntries(await response.json());
+}
+async function lookupUploadedApp(creds, ref) {
+    const lists = await Promise.all(["android", "ios"].map((platformType) => fetchUploadedApps(creds, platformType)));
+    for (const item of lists.flat()) {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            continue;
+        }
+        const remotePath = normalizeRemoteAppRef(item.app_url) ??
+            normalizeRemoteAppRef(item.appUrl) ??
+            normalizeRemoteAppRef(item.appURL) ??
+            normalizeRemoteAppRef(item.url) ??
+            normalizeRemoteAppRef(item.value);
+        if (!remotePath) {
+            continue;
+        }
+        const customId = normalizeString(item.app_id) ??
+            normalizeString(item.appId) ??
+            normalizeString(item.id) ??
+            normalizeString(item.name);
+        if (remotePath === ref.remotePath || (customId && customId === ref.id)) {
+            return item;
+        }
+    }
+    return null;
+}
+/** @type {import("../adapter").CloudProviderAdapter} */
+export const lambdaTestAdapter = {
+    id: "lambdatest",
+    displayName: "LambdaTest",
+    async validateCredentials(creds) {
+        try {
+            const account = await requestConcurrency(creds);
+            return {
+                ok: true,
+                message: account.summary ?? "LambdaTest credentials validated successfully.",
+                account
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to validate LambdaTest credentials.";
+            if (/ENOTFOUND|fetch failed|network|timed out|ECONN/i.test(message)) {
+                return {
+                    ok: false,
+                    message: "Could not reach LambdaTest. Check your network connection and try again."
+                };
+            }
+            return {
+                ok: false,
+                message
+            };
+        }
+    },
+    async getAccountInfo(creds) {
+        return requestConcurrency(creds);
+    },
+    async getAvailableDevices(creds) {
+        return requestDevices(creds);
+    },
+    async uploadApp(creds, localPath) {
+        return uploadRealDeviceApp(creds, localPath);
+    },
+    async getAppStatus(creds, ref) {
+        const match = await lookupUploadedApp(creds, ref);
+        if (!match) {
+            return {
+                status: "missing",
+                message: "Uploaded app reference is missing or has expired on LambdaTest."
+            };
+        }
+        return {
+            status: "uploaded",
+            message: "Uploaded app reference is still available on LambdaTest."
+        };
+    },
+    async deleteApp(_creds, _ref) {
+        return notImplemented("deleteApp");
+    },
+    buildCapabilities(opts) {
+        const ltOptions = {
+            platformName: opts.platform,
+            deviceName: opts.deviceName,
+            platformVersion: opts.osVersion,
+            app: opts.app,
+            isRealMobile: true,
+            w3c: true,
+            build: opts.buildName ?? "droid-cua",
+            name: opts.sessionName ?? `${opts.deviceName} ${opts.platform === "ios" ? "iOS" : "Android"} ${opts.osVersion ?? ""}`.trim(),
+            video: true,
+            console: true
+        };
+        if (opts.platform === "android") {
+            ltOptions.visual = true;
+            ltOptions.devicelog = true;
+        }
+        else {
+            ltOptions.network = false;
+        }
+        return {
+            "lt:options": ltOptions
+        };
+    },
+    getHubUrl() {
+        return HUB_URL;
+    },
+    getAuthHeader(creds) {
+        const username = typeof creds.username === "string" ? creds.username : "";
+        const accessKey = typeof creds.accessKey === "string" ? creds.accessKey : "";
+        return `Basic ${Buffer.from(`${username}:${accessKey}`).toString("base64")}`;
+    },
+    async getSessionArtifacts(_creds, sessionId) {
+        return {
+            dashboardUrl: `https://automation.lambdatest.com/logs/?sessionID=${encodeURIComponent(sessionId)}`
+        };
+    },
+    async setSessionStatus(_creds, _sessionId, _status) {
+        return notImplemented("setSessionStatus");
+    }
+};

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

@@ -1,5 +1,6 @@
 import { browserStackAdapter } from "./browserstack/adapter.js";
-const availableAdapters = [browserStackAdapter];
+import { lambdaTestAdapter } from "./lambdatest/adapter.js";
+const availableAdapters = [browserStackAdapter, lambdaTestAdapter];
 export function listCloudProviderAdapters() {
     return availableAdapters;
 }

package/build/src/device/interface.js

@@ -47,7 +47,7 @@ export const SUPPORTED_ACTIONS = [
     'type', // Enter text
     'scroll', // Scroll by (scroll_x, scroll_y)
     'drag', // Drag from start to end via path
-    'keypress', // Press a single mobile-safe key (ESC/ESCAPE maps to home)
+    'keypress', // Press a single mobile-safe key (Android ESC/ESCAPE maps to Back; iOS ignores ESC/ESCAPE)
     'wait', // Wait for UI to settle
     'screenshot' // Capture screen (handled by engine, not backend)
 ];

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

@@ -16,7 +16,10 @@ function normalizeMobileKeypress(keys = []) {
         throw new Error(`Unsupported mobile key chord: ${keys.join(", ")}. Use taps and text entry instead.`);
     }
     const key = String(keys[0]).trim().toUpperCase();
-    if (key === "ESC" || key === "ESCAPE" || key === "HOME") {
+    if (key === "ESC" || key === "ESCAPE") {
+        return { kind: "noop", originalKey: keys[0], label: "Ignored ESC key" };
+    }
+    if (key === "HOME") {
         return { kind: "button", originalKey: keys[0], mapped: "home" };
     }
     if (key === "ENTER" || key === "RETURN") {
@@ -125,7 +128,10 @@ export async function handleModelAction(simulatorId, action, scale = 1.0, contex
             }
             case "keypress": {
                 const normalized = normalizeMobileKeypress(action.keys);
-                if (normalized.kind === "button") {
+                if (normalized.kind === "noop") {
+                    addOutput({ type: "info", text: `Ignoring keypress: ${normalized.originalKey}`, ...meta({ keys: [normalized.originalKey], ignored: true }) });
+                }
+                else if (normalized.kind === "button") {
                     addOutput({ type: "action", text: "Pressing Home button", ...meta({ keys: [normalized.originalKey], mapped: normalized.mapped }) });
                     await appium.pressButton(session.sessionId, normalized.mapped);
                 }

package/build/src/device/loadmill.js

@@ -2,6 +2,7 @@
  * Loadmill instruction handling for script execution
  */
 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";
     return rawBaseUrl.replace(/\/api\/?$/, "");
@@ -43,7 +44,7 @@ export function extractLoadmillCommand(userInput) {
  * @returns {Promise<{success: boolean, error?: string}>}
  */
 export async function executeLoadmillInstruction(command, isHeadlessMode, context, stepContext = null) {
-    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const addOutput = context?.addOutput || printCliOutput;
     const meta = {
         runId: context?.runId,
         stepId: stepContext?.stepId,
@@ -82,7 +83,7 @@ export async function executeLoadmillInstruction(command, isHeadlessMode, contex
  * @returns {Promise<{success: boolean, error?: string}>}
  */
 export async function handleLoadmillFailure(command, error, isHeadlessMode, context, stepContext = null, suiteRunId = null) {
-    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const addOutput = context?.addOutput || printCliOutput;
     const meta = {
         runId: context?.runId,
         stepId: stepContext?.stepId,
@@ -146,7 +147,7 @@ export async function handleLoadmillFailure(command, error, isHeadlessMode, cont
  * @param {Object|null} stepContext - Optional step context metadata
  */
 export function handleLoadmillSuccess(command, result, context, stepContext = null) {
-    const addOutput = context?.addOutput || ((item) => console.log(item.text || item));
+    const addOutput = context?.addOutput || printCliOutput;
     const meta = {
         runId: context?.runId,
         stepId: stepContext?.stepId,

package/build/src/device/openai.js

@@ -1,4 +1,6 @@
 import OpenAI from "openai";
+import { buildTestRevisionSystemPrompt } from "../prompts/editor.js";
+import { buildAppContextCompactionInput } from "../prompts/execution.js";
 import { logger } from "../utils/logger.js";
 import { CuaDebugTracer } from "../utils/cua-debug-tracer.js";
 let openai = null;
@@ -96,6 +98,20 @@ function mapCuaError(err, cuaModel) {
     }
     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"));
+}
 function getOpenAI() {
     if (!openai) {
         openai = new OpenAI({
@@ -115,27 +131,26 @@ export async function reviseTestScript(originalScript, revisionRequest) {
         model: "gpt-4o",
         messages: [{
                 role: "system",
-                content: `You are editing a test script based on user feedback.
-
-Current test script:
-${originalScript}
-
-User's revision request:
-${revisionRequest}
-
-Apply the user's changes and output the revised test script.
-
-FORMAT RULES:
-- One simple instruction per line (NO numbers, NO bullets)
-- Use imperative commands: "Open X", "Click Y", "Type Z"
-- Include "assert: <condition>" lines to validate expected behavior
-- End with "exit"
-
-Output only the revised test script, nothing else.`
+                content: buildTestRevisionSystemPrompt(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();
     const includeInitialScreenshot = cuaModel === "computer-use-preview" && !previousResponseId && !callId;
@@ -174,15 +189,6 @@ export async function sendCUARequest({ messages, screenshotBase64, previousRespo
     }
     catch (err) {
         cuaDebugTracer.onError(trace, err);
-        const responseError = err?.error && typeof err.error === "object" ? err.error : null;
-        const requestIdFromHeaders = err?.headers && typeof err.headers === "object"
-            ? err.headers["x-request-id"] || err.headers["request-id"] || null
-            : null;
-        err.localRequestId = trace.localRequestId;
-        err.request_id = err?.request_id || responseError?.request_id || requestIdFromHeaders || null;
-        err.previous_response_id = previousResponseId || null;
-        err.last_response_output_types = trace.lastResponseMeta?.outputTypes ?? [];
-        err.request_config_hash = trace.requestConfigHash;
         throw mapCuaError(err, cuaModel);
     }
 }