askui 0.10.1 → 0.10.2

package/dist/esm/execution/execution-runtime.js

@@ -8,22 +8,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { ControlCommandCode } from '../core/ui-control-commands';
-import { CustomElement } from '../core/model/test-case-dto';
+import { CustomElement } from '../core/model/custom-element';
 import { RepeatError } from './repeat-error';
 import { delay } from './misc';
 import { ControlCommandError } from './control-command-error';
 import { logger } from '../lib/logger';
 import { Base64Image } from '../utils/base_64_image/base-64-image';
 export class ExecutionRuntime {
-    constructor(uiControllerClient, inferenceClient) {
+    constructor(uiControllerClient, inferenceClient, stepReporter) {
         this.uiControllerClient = uiControllerClient;
         this.inferenceClient = inferenceClient;
+        this.stepReporter = stepReporter;
         this.EXEC_REPETITION_COUNT = 25;
         this.PREDICT_COMMAND_RETRY_COUNT = 2;
     }
-    executeTestStep(step) {
+    connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.executeCommand(step);
+            return this.uiControllerClient.connect();
+        });
+    }
+    disconnect() {
+        this.uiControllerClient.disconnect();
+    }
+    startVideoRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.uiControllerClient.startVideoRecording();
+        });
+    }
+    stopVideoRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.uiControllerClient.stopVideoRecording();
+        });
+    }
+    readVideoRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.uiControllerClient.readVideoRecording();
+            return response.data.video;
         });
     }
     requestControl(controlCommand) {
@@ -31,25 +51,22 @@ export class ExecutionRuntime {
             yield this.uiControllerClient.requestControl(controlCommand);
         });
     }
-    /**
-     * @param {TestStep} step - Test step used for predicting command.
-     */
-    executeCommand(step) {
-        var _a;
+    executeInstruction(instruction) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            const controlCommand = yield this.predictCommandWithRetry(step);
+            const controlCommand = yield this.predictCommandWithRetry(instruction);
             if (controlCommand.code === ControlCommandCode.OK) {
                 return this.requestControl(controlCommand);
             }
             if (controlCommand.tryToRepeat) {
                 yield this.requestControl(controlCommand);
-                return this.executeCommandRepeatedly(step);
+                return this.executeCommandRepeatedly(instruction);
             }
-            throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
+            throw new ControlCommandError((_c = (_b = (_a = controlCommand.actions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '');
         });
     }
-    executeCommandRepeatedly(step) {
-        var _a;
+    executeCommandRepeatedly(instruction) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             /* eslint-disable no-await-in-loop */
             for (let repeatCount = this.EXEC_REPETITION_COUNT; repeatCount >= 0; repeatCount -= 1) {
@@ -58,7 +75,7 @@ export class ExecutionRuntime {
                         + 'from a single test step reached');
                 }
                 logger.debug('Repeat command execution....');
-                const controlCommand = yield this.predictCommandWithRetry(step);
+                const controlCommand = yield this.predictCommandWithRetry(instruction);
                 if (controlCommand.code === ControlCommandCode.OK) {
                     break;
                 }
@@ -66,7 +83,7 @@ export class ExecutionRuntime {
                     yield this.requestControl(controlCommand);
                 }
                 else {
-                    throw new ControlCommandError(((_a = controlCommand.actions[0]) === null || _a === void 0 ? void 0 : _a.text) || '');
+                    throw new ControlCommandError((_c = (_b = (_a = controlCommand.actions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : '');
                 }
             }
         });
@@ -76,9 +93,10 @@ export class ExecutionRuntime {
      * --> retry with linear back-off
      */
     /* eslint-disable-next-line consistent-return */
-    predictCommandWithRetry(step) {
+    predictCommandWithRetry(instruction) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            let command = yield this.predictCommand(step);
+            let command = yield this.predictCommand(instruction);
             /* eslint-disable no-await-in-loop */
             for (let k = 0; k < this.PREDICT_COMMAND_RETRY_COUNT; k += 1) {
                 if (command.code === ControlCommandCode.OK) {
@@ -87,28 +105,56 @@ export class ExecutionRuntime {
                 const msUntilRetry = k * 1000;
                 logger.debug(`Wait ${msUntilRetry} and retry predicting command...`);
                 yield delay(msUntilRetry);
-                command = yield this.predictCommand(step);
+                command = yield this.predictCommand(instruction, new ControlCommandError((_c = (_b = (_a = command.actions) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : ''));
             }
             /* eslint-enable no-await-in-loop */
             return command;
         });
     }
-    getImageIfRequired(instruction) {
+    isImageRequiredByConfig() {
+        return this.stepReporter.config.withScreenshots === 'begin'
+            || this.stepReporter.config.withScreenshots === 'always';
+    }
+    isImageRequired(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const isImageRequired = yield this.inferenceClient.isImageRequired(instruction);
-            if (!isImageRequired) {
-                return undefined;
-            }
-            const screenshotResponse = yield this.uiControllerClient.requestScreenshot();
-            return screenshotResponse.data.image;
+            if (this.isImageRequiredByConfig())
+                return Promise.resolve(true);
+            return this.inferenceClient.isImageRequired(instruction);
+        });
+    }
+    isAnnotationRequired() {
+        return this.stepReporter.config.withDetectedElements === 'begin'
+            || this.stepReporter.config.withDetectedElements === 'always';
+    }
+    getScreenshot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestScreenshotResponse = yield this.uiControllerClient.requestScreenshot();
+            return requestScreenshotResponse.data.image;
+        });
+    }
+    buildSnapshot(instruction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const createdAt = new Date();
+            const screenshot = (yield this.isImageRequired(instruction))
+                ? yield this.getScreenshot() : undefined;
+            const annotation = this.isAnnotationRequired() ? yield this.annotateImage() : undefined;
+            return {
+                createdAt,
+                screenshot,
+                detectedElements: annotation === null || annotation === void 0 ? void 0 : annotation.detected_elements,
+            };
         });
     }
-    predictCommand(step) {
+    predictCommand(instruction, retryError) {
         return __awaiter(this, void 0, void 0, function* () {
-            const image = yield this.getImageIfRequired(step.instruction);
-            const controlCommand = yield this.inferenceClient.predictControlCommand(step.instruction, step.customElements, image);
-            if (step.secretText !== undefined) {
-                controlCommand.setTextToBeTyped(step.secretText);
+            const snapshot = yield this.buildSnapshot(instruction.value);
+            if (retryError !== undefined)
+                this.stepReporter.onStepRetry(snapshot, retryError);
+            else
+                this.stepReporter.onStepBegin(snapshot);
+            const controlCommand = yield this.inferenceClient.predictControlCommand(instruction.value, instruction.customElements, snapshot.screenshot);
+            if (instruction.secretText !== undefined) {
+                controlCommand.setTextToBeTyped(instruction.secretText);
             }
             return controlCommand;
         });

package/dist/esm/execution/inference-client.d.ts

@@ -1,6 +1,6 @@
 import { HttpClientGot } from '../utils/http/http-client-got';
 import { ControlCommand } from '../core/ui-control-commands';
-import { CustomElement } from '../core/model/test-case-dto';
+import { CustomElement } from '../core/model/custom-element';
 import { Annotation } from '../core/annotation/annotation';
 import { DetectedElement } from '../core/model/annotation-result/detected-element';
 import { ModelCompositionBranch } from './model-composition-branch';

package/dist/esm/execution/reporter.d.ts

@@ -0,0 +1,132 @@
+import { DetectedElement } from "@/core/model/annotation-result/detected-element";
+import { CustomElement } from "@/core/model/custom-element";
+export interface Snapshot {
+    readonly createdAt: Date;
+    readonly screenshot?: string | undefined;
+    readonly detectedElements?: Readonly<Readonly<DetectedElement>>[] | undefined;
+}
+export interface Instruction {
+    readonly value: string;
+    readonly valueHumanReadable: string;
+    readonly customElements?: Readonly<Readonly<CustomElement>>[];
+    readonly secretText?: string | undefined;
+}
+export interface Step {
+    readonly instruction: Readonly<Instruction>;
+    readonly status: StepStatus;
+    /**
+     * A snapshot of the state of the screen before the step is ran which is nearly immediately after the call to `.exec()`
+     */
+    readonly begin?: Snapshot | undefined;
+    /**
+     * The duration of the step in milliseconds based on the start and end time. If the step is still running, this property is undefined.
+     */
+    readonly duration?: number | undefined;
+    /**
+     * A snapshot of the state of the screen after the step has been run. If the step is still running or still pending, this property is undefined.
+     */
+    readonly end?: Snapshot | undefined;
+    /**
+     * When a step failed or is erroneous, this property contains the error.
+     */
+    readonly error?: Error | undefined;
+    readonly runs: Readonly<StepRun[]>;
+    readonly retries: Readonly<StepRun[]>;
+    readonly retryCount: number;
+    readonly firstRun?: StepRun | undefined;
+    readonly lastRun?: StepRun | undefined;
+    /**
+     * retryCount > 0.
+     */
+    readonly flaky: boolean;
+}
+export interface StepRun {
+    readonly status: StepStatus;
+    readonly begin?: Snapshot | undefined;
+    readonly end?: Snapshot | undefined;
+    readonly duration?: number | undefined;
+    readonly error?: Error | undefined;
+}
+declare class askuiStep implements Step {
+    instruction: Instruction;
+    runs: Readonly<StepRun[]>;
+    constructor(instruction: Instruction);
+    get status(): StepStatus;
+    get begin(): Snapshot | undefined;
+    get end(): Snapshot | undefined;
+    get error(): Error | undefined;
+    get retries(): StepRun[];
+    get retryCount(): number;
+    get firstRun(): StepRun | undefined;
+    get lastRun(): StepRun | undefined;
+    get flaky(): boolean;
+    get duration(): number | undefined;
+    onBegin(snapshot: Snapshot): askuiStep;
+    onRetry(snapshot: Snapshot, error: Error): askuiStep;
+    onEnd(snapshot: Snapshot, error?: Error): askuiStep;
+    private determineLastRunStatus;
+}
+/**
+ * - `passed`: the step passed
+ * - `failed`: the step failed because of a failed (implicit/explicit) assertion, e.g., an element could not be found
+ * - `pending`: the step is waiting for a previous step to pass
+ * - `running`: the step is currently running (including retries)
+ * - `skipped`: the step was skipped, e.g., because a previous step failed or because workflow was skipped
+ * - `erroneous`: the step could not be run because of a runtime error, e.g., the user has no usage left, response of inference backend cannot be processed, e.g., because lib version is outdated, etc. (currently not supported, everything "failed")
+ */
+export declare type StepStatus = 'passed' | 'failed' | 'pending' | 'running' | 'erroneous';
+export declare type StepStatusEnd = 'passed' | 'failed' | 'erroneous';
+/**
+ * Can be used to report on a step run.
+ *
+ * The reporter is an interface (instead of a class) so that the it may be implemented by a class that already extends another class, e.g., the reporter of a test framework.
+ */
+export interface Reporter {
+    config?: ReporterConfig;
+    onStepBegin?(step: Step): Promise<void>;
+    onStepRetry?(step: Step): Promise<void>;
+    onStepEnd?(step: Step): Promise<void>;
+}
+export declare type SnapshotDetailLevel = 
+/**
+ * Details of snapshot, e.g., screenshot or detected elements, may or may not be available depending on if they are required by the step. There are not guarantees made.
+ */
+'required' | 
+/**
+ * Details are available when the step fails, e.g., for debugging. Includes everything of required.
+ */
+'onFailure' | 
+/**
+ * Details are available also when the command is started, e.g., for detecting why a certain element was interacted with. Includes everything of onFailure.
+ */
+'begin' | 
+/**
+ * Details are available always, e.g., before and after a step has been run no matter if it failed or not for debugging.
+ */
+'always';
+export interface ReporterConfig {
+    withScreenshots?: SnapshotDetailLevel;
+    withDetectedElements?: SnapshotDetailLevel;
+}
+export declare const DEFAULT_REPORTER: {
+    config: {
+        readonly withScreenshots: "onFailure";
+        readonly withDetectedElements: "onFailure";
+    };
+    onStepBegin: (_step: Step) => Promise<void>;
+    onStepRetry: (_step: Step) => Promise<void>;
+    onStepEnd: (_step: Step) => Promise<void>;
+};
+export declare class StepReporter {
+    private reporter;
+    currentStep?: askuiStep | undefined;
+    constructor(reporter: Required<Reporter> & {
+        config: Required<ReporterConfig>;
+    });
+    get config(): Required<ReporterConfig>;
+    resetStep(instruction: Instruction): void;
+    onStepBegin(snapshot: Snapshot): Promise<void>;
+    onStepRetry(snapshot: Snapshot, error: Error): Promise<void>;
+    onStepEnd(snapshot: Snapshot, error?: Error): Promise<void>;
+}
+export {};

package/dist/esm/execution/reporter.js

@@ -0,0 +1,142 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// retries could be modeled as totally new steps only that we set the retry no at the beginning, it is undefined if there is no retry or 0 --> user could filter out the retries for the report and has to get the last retry to find out when the step actually ended and the snapshot at that point in time
+// Where do I save the error of the first step, what state does the first step have?
+// We could point back from retry to original step, but then we have to save the original step in the retry step, which is not nice
+// retry should be handled like completely new step but the state of the whole state is not failed --> if a passed step can have an error, then this is fine 
+// how do we determine if it is erroneous or failed?
+class askuiStep {
+    constructor(instruction) {
+        this.instruction = instruction;
+        this.runs = [];
+    }
+    get status() {
+        var _a, _b;
+        return (_b = (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 'pending';
+    }
+    get begin() {
+        var _a;
+        return (_a = this.firstRun) === null || _a === void 0 ? void 0 : _a.begin;
+    }
+    get end() {
+        var _a;
+        return (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.end;
+    }
+    get error() {
+        var _a;
+        return (_a = this.lastRun) === null || _a === void 0 ? void 0 : _a.error;
+    }
+    get retries() {
+        var _a, _b;
+        return (_b = (_a = this.runs) === null || _a === void 0 ? void 0 : _a.slice(1)) !== null && _b !== void 0 ? _b : [];
+    }
+    get retryCount() {
+        var _a, _b;
+        return (_b = (_a = this.retries) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+    }
+    get firstRun() {
+        var _a;
+        return (_a = this.runs) === null || _a === void 0 ? void 0 : _a[0];
+    }
+    get lastRun() {
+        var _a;
+        return (_a = this.runs) === null || _a === void 0 ? void 0 : _a[this.runs.length - 1];
+    }
+    get flaky() {
+        return this.retryCount > 0;
+    }
+    get duration() {
+        if (this.begin !== undefined && this.end !== undefined) {
+            return this.end.createdAt.getTime() - this.begin.createdAt.getTime();
+        }
+        return undefined;
+    }
+    onBegin(snapshot) {
+        this.runs = [...this.runs, {
+                status: 'running',
+                begin: snapshot,
+            }];
+        return this;
+    }
+    onRetry(snapshot, error) {
+        this.onEnd(snapshot, error);
+        this.onBegin(snapshot);
+        return this;
+    }
+    onEnd(snapshot, error) {
+        this.runs = [...this.runs.slice(0, -1), Object.assign(Object.assign({}, this.lastRun), { status: this.determineLastRunStatus(error), end: snapshot, error, duration: snapshot.createdAt.getTime() - this.lastRun.begin.createdAt.getTime() })];
+        return this;
+    }
+    determineLastRunStatus(error) {
+        if (error !== undefined) {
+            return 'failed';
+        }
+        return 'passed';
+    }
+}
+export const DEFAULT_REPORTER = {
+    config: {
+        withScreenshots: 'onFailure',
+        withDetectedElements: 'onFailure',
+    },
+    onStepBegin: (_step) => {
+        return Promise.resolve();
+    },
+    onStepRetry: (_step) => {
+        return Promise.resolve();
+    },
+    onStepEnd: (_step) => {
+        return Promise.resolve();
+    },
+};
+export class StepReporter {
+    constructor(reporter) {
+        this.reporter = reporter;
+    }
+    get config() {
+        return this.reporter.config;
+    }
+    resetStep(instruction) {
+        this.currentStep = new askuiStep(instruction);
+    }
+    onStepBegin(snapshot) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentStep === undefined)
+                throw new Error('Cannot begin step if step is undefined.');
+            if (this.currentStep.status !== 'pending')
+                throw new Error('Cannot begin step that is not pending.');
+            this.currentStep.onBegin(snapshot);
+            yield ((_b = (_a = this.reporter).onStepBegin) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
+        });
+    }
+    onStepRetry(snapshot, error) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentStep === undefined)
+                throw new Error('Cannot retry step if step is undefined.');
+            if (this.currentStep.status !== 'running')
+                throw new Error('Cannot retry step that has not been running.');
+            this.currentStep.onRetry(snapshot, error);
+            yield ((_b = (_a = this.reporter).onStepRetry) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
+        });
+    }
+    onStepEnd(snapshot, error) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.currentStep === undefined)
+                throw new Error('Cannot end step if step is undefined.');
+            if (this.currentStep.status !== 'running')
+                throw new Error('Cannot end step that has not been running.');
+            this.currentStep.onEnd(snapshot, error);
+            yield ((_b = (_a = this.reporter).onStepEnd) === null || _b === void 0 ? void 0 : _b.call(_a, this.currentStep));
+        });
+    }
+}

package/dist/esm/execution/ui-control-client-dependency-builder.d.ts

@@ -0,0 +1,14 @@
+import { ClientArgs, ClientArgsWithDefaults } from './ui-controller-client-interface';
+import { ExecutionRuntime } from './execution-runtime';
+import { StepReporter } from '../core/reporting';
+export declare class UiControlClientDependencyBuilder {
+    private static buildHttpClient;
+    private static buildInferenceClient;
+    private static buildUiControllerClient;
+    static build(clientArgs: ClientArgsWithDefaults): Promise<{
+        executionRuntime: ExecutionRuntime;
+        stepReporter: StepReporter;
+    }>;
+    private static buildReporter;
+    static getClientArgsWithDefaults(clientArgs: ClientArgs): Promise<ClientArgsWithDefaults>;
+}

package/dist/esm/execution/ui-control-client-dependency-builder.js

@@ -0,0 +1,68 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { HttpClientGot } from '../utils/http/http-client-got';
+import { UiControllerClient } from './ui-controller-client';
+import { InferenceClient } from './inference-client';
+import { envCredentials } from './read-environment-credentials';
+import { Analytics } from '../utils/analytics';
+import { envProxyAgents } from '../utils/proxy/proxy-builder';
+import { AnnotationLevel } from './annotation-level';
+import { ExecutionRuntime } from './execution-runtime';
+import { DEFAULT_REPORTER, StepReporter, } from '../core/reporting';
+export class UiControlClientDependencyBuilder {
+    static buildHttpClient(clientArgs) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const analytics = new Analytics();
+            const analyticsHeaders = yield analytics.getAnalyticsHeaders();
+            const analyticsCookies = yield analytics.getAnalyticsCookies();
+            return new HttpClientGot((_a = clientArgs.credentials) === null || _a === void 0 ? void 0 : _a.token, analyticsHeaders, analyticsCookies, clientArgs.proxyAgents);
+        });
+    }
+    static buildInferenceClient(clientArgs) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const httpClient = yield UiControlClientDependencyBuilder.buildHttpClient(clientArgs);
+            return new InferenceClient(clientArgs.inferenceServerUrl, httpClient, clientArgs.resize, (_a = clientArgs.credentials) === null || _a === void 0 ? void 0 : _a.workspaceId, clientArgs.modelComposition);
+        });
+    }
+    static buildUiControllerClient(clientArgs) {
+        return new UiControllerClient(clientArgs.uiControllerUrl);
+    }
+    static build(clientArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uiControllerClient = UiControlClientDependencyBuilder.buildUiControllerClient(clientArgs);
+            const inferenceClient = yield UiControlClientDependencyBuilder.buildInferenceClient(clientArgs);
+            const stepReporter = new StepReporter(clientArgs.reporter);
+            return {
+                executionRuntime: new ExecutionRuntime(uiControllerClient, inferenceClient, stepReporter),
+                stepReporter,
+            };
+        });
+    }
+    static buildReporter(reporterArg) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        return {
+            config: {
+                withScreenshots: (_b = (_a = reporterArg === null || reporterArg === void 0 ? void 0 : reporterArg.config) === null || _a === void 0 ? void 0 : _a.withScreenshots) !== null && _b !== void 0 ? _b : DEFAULT_REPORTER.config.withScreenshots,
+                withDetectedElements: (_d = (_c = reporterArg === null || reporterArg === void 0 ? void 0 : reporterArg.config) === null || _c === void 0 ? void 0 : _c.withDetectedElements) !== null && _d !== void 0 ? _d : DEFAULT_REPORTER.config.withDetectedElements,
+            },
+            onStepBegin: (_f = (_e = reporterArg === null || reporterArg === void 0 ? void 0 : reporterArg.onStepBegin) === null || _e === void 0 ? void 0 : _e.bind(reporterArg)) !== null && _f !== void 0 ? _f : DEFAULT_REPORTER.onStepBegin.bind(DEFAULT_REPORTER),
+            onStepRetry: (_h = (_g = reporterArg === null || reporterArg === void 0 ? void 0 : reporterArg.onStepRetry) === null || _g === void 0 ? void 0 : _g.bind(reporterArg)) !== null && _h !== void 0 ? _h : DEFAULT_REPORTER.onStepRetry.bind(DEFAULT_REPORTER),
+            onStepEnd: (_k = (_j = reporterArg === null || reporterArg === void 0 ? void 0 : reporterArg.onStepEnd) === null || _j === void 0 ? void 0 : _j.bind(reporterArg)) !== null && _k !== void 0 ? _k : DEFAULT_REPORTER.onStepEnd.bind(DEFAULT_REPORTER),
+        };
+    }
+    static getClientArgsWithDefaults(clientArgs) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, clientArgs), { uiControllerUrl: (_a = clientArgs.uiControllerUrl) !== null && _a !== void 0 ? _a : 'http://127.0.0.1:6769', inferenceServerUrl: (_b = clientArgs.inferenceServerUrl) !== null && _b !== void 0 ? _b : 'https://inference.askui.com', annotationLevel: (_c = clientArgs.annotationLevel) !== null && _c !== void 0 ? _c : AnnotationLevel.DISABLED, credentials: (_d = clientArgs.credentials) !== null && _d !== void 0 ? _d : envCredentials(), proxyAgents: (_e = clientArgs.proxyAgents) !== null && _e !== void 0 ? _e : yield envProxyAgents(), reporter: UiControlClientDependencyBuilder.buildReporter(clientArgs.reporter) });
+        });
+    }
+}

package/dist/esm/execution/ui-control-client.d.ts

@@ -1,28 +1,44 @@
-import { CustomElementJson } from '../core/model/test-case-dto';
+import { CustomElementJson } from '../core/model/custom-element-json';
 import { Exec, Executable, FluentFilters, ApiCommands } from './dsl';
 import { UiControllerClientConnectionState } from './ui-controller-client-connection-state';
 import { Annotation } from '../core/annotation/annotation';
 import { AnnotationRequest } from '../core/model/annotation-result/annotation-interface';
-import { ClientArgs } from './ui-controller-client-interface';
 import { DetectedElement } from '../core/model/annotation-result/detected-element';
+import { ClientArgs } from './ui-controller-client-interface';
 export declare class UiControlClient extends ApiCommands {
-    private httpClient;
-    private clientArgs;
-    private workspaceId?;
-    private _uiControllerClient?;
+    private config;
+    private executionRuntime;
+    private stepReporter;
     private constructor();
     static build(clientArgs?: ClientArgs): Promise<UiControlClient>;
-    private get uiControllerClient();
-    private get inferenceClient();
-    private get executionRuntime();
-    private annotateByDefault;
+    /**
+     * Connects to the askui UI Controller.
+     */
     connect(): Promise<UiControllerClientConnectionState>;
+    /**
+     * Disconnects from the askui UI Controller.
+     */
+    disconnect(): void;
+    /**
+     * Disconnects from the askui UI Controller.
+     *
+     * @deprecated Use {@link disconnect} instead.
+     */
+    close(): void;
+    startVideoRecording(): Promise<void>;
+    stopVideoRecording(): Promise<void>;
+    readVideoRecording(): Promise<string>;
+    private shouldWriteAnntotationAfterCommandExecution;
+    private shouldAnnotateAfterCommandExecution;
+    private afterCommandExecution;
     annotate(annotationRequest?: AnnotationRequest): Promise<Annotation>;
     annotateInteractively(): Promise<void>;
     private escapeSeparatorString;
-    fluentCommandExecutor(instruction: string, customElementJson?: CustomElementJson[]): Promise<void>;
+    private buildInstruction;
+    fluentCommandExecutor(instructionString: string, customElementJson?: CustomElementJson[]): Promise<void>;
     getterExecutor(instruction: string, customElementJson?: CustomElementJson[]): Promise<DetectedElement[]>;
     private secretText;
+    private getAndResetSecretText;
     /**
      * Types a text inside the filtered element.
      *
@@ -76,8 +92,4 @@ export declare class UiControlClient extends ApiCommands {
      * @return {Executable}
      */
     waitFor(delayInMs: number): Executable;
-    /**
-    * Closes the connection to the askui UI Controller
-    */
-    close(): void;
 }