askui 0.7.1 → 0.8.0

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

@@ -14,6 +14,7 @@ export declare class InferenceClient {
     isImageRequired(instruction: string): Promise<boolean>;
     private resizeIfNeeded;
     inference(customElements?: CustomElement[], image?: string, instruction?: string): Promise<ControlCommand | Annotation>;
+    private static logMetaInformation;
     predictControlCommand(instruction: string, customElements?: CustomElement[], image?: string): Promise<ControlCommand>;
     getDetectedElements(instruction: string, image: string, customElements?: CustomElement[]): Promise<DetectedElement[]>;
     predictImageAnnotation(image: string, customElements?: CustomElement[]): Promise<Annotation>;

package/dist/cjs/execution/inference-client.js

@@ -19,6 +19,7 @@ const annotation_1 = require("../core/annotation/annotation");
 const transformations_1 = require("../utils/transformations");
 const inference_response_error_1 = require("./inference-response-error");
 const config_error_1 = require("./config-error");
+const logger_1 = require("../lib/logger");
 class InferenceClient {
     constructor(baseUrl, httpClient, resize, workspaceId, apiVersion = 'v3') {
         this.baseUrl = baseUrl;
@@ -27,7 +28,9 @@ class InferenceClient {
         this.workspaceId = workspaceId;
         this.apiVersion = apiVersion;
         const versionedBaseUrl = (0, url_join_1.default)(this.baseUrl, 'api', this.apiVersion);
-        this.url = workspaceId ? (0, url_join_1.default)(versionedBaseUrl, 'workspaces', workspaceId) : versionedBaseUrl;
+        this.url = workspaceId
+            ? (0, url_join_1.default)(versionedBaseUrl, 'workspaces', workspaceId)
+            : versionedBaseUrl;
         if (this.resize !== undefined && this.resize <= 0) {
             throw new config_error_1.ConfigurationError(`Resize must be a positive number. The current resize value "${this.resize}" is not valid.`);
         }
@@ -36,17 +39,17 @@ class InferenceClient {
     isImageRequired(instruction) {
         return __awaiter(this, void 0, void 0, function* () {
             const url = (0, url_join_1.default)(this.url, 'instruction', 'is-image-required');
-            const httpBody = {
+            const requestBody = {
                 instruction,
             };
-            const httpResponse = yield this.httpClient.post(url, httpBody);
-            return httpResponse.isImageRequired;
+            const response = yield this.httpClient.post(url, requestBody);
+            return response.body.isImageRequired;
         });
     }
     // eslint-disable-next-line class-methods-use-this
     resizeIfNeeded(customElements, image) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!(image) || customElements.length > 0 || this.resize === undefined) {
+            if (!image || customElements.length > 0 || this.resize === undefined) {
                 return { base64Image: image, resizeRatio: 1 };
             }
             return (0, transformations_1.resizeBase64ImageWithSameRatio)(image, this.resize);
@@ -55,16 +58,22 @@ class InferenceClient {
     inference(customElements = [], image, instruction) {
         return __awaiter(this, void 0, void 0, function* () {
             const resizedImage = yield this.resizeIfNeeded(customElements, image);
-            const httpBody = {
+            const requestBody = {
                 image: resizedImage.base64Image,
                 instruction,
                 customElements,
             };
             const url = (0, url_join_1.default)(this.url, 'inference');
-            const httpResponse = yield this.httpClient.post(url, httpBody);
-            return ui_control_commands_1.InferenceResponse.fromJson(httpResponse, resizedImage.resizeRatio, image);
+            const response = yield this.httpClient.post(url, requestBody);
+            InferenceClient.logMetaInformation(response);
+            return ui_control_commands_1.InferenceResponse.fromJson(response.body, resizedImage.resizeRatio, image);
         });
     }
+    static logMetaInformation(response) {
+        if (response.headers['askui-usage-warnings'] !== undefined) {
+            logger_1.logger.warn(response.headers['askui-usage-warnings']);
+        }
+    }
     predictControlCommand(instruction, customElements = [], image) {
         return __awaiter(this, void 0, void 0, function* () {
             const inferenceResponse = yield this.inference(customElements, image, instruction);

package/dist/cjs/execution/ui-control-client.js

@@ -110,6 +110,7 @@ class UiControlClient extends dsl_1.ApiCommands {
                     customElements,
                     secretText,
                 });
+                this.secretText = undefined;
                 yield this.annotateByDefault(test_case_result_dto_1.TestStepState.PASSED, customElements);
                 return yield Promise.resolve();
             }

package/dist/cjs/utils/http/http-client-got.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { OptionsOfJSONResponseBody } from 'got';
 import http from 'http';
 import https from 'https';
@@ -17,6 +18,9 @@ export declare class HttpClientGot {
     } | undefined);
     private initHeaders;
     private injectHeadersAndCookies;
-    post<T>(url: string, data: Record<string | number | symbol, unknown>): Promise<T>;
+    post<T>(url: string, data: Record<string | number | symbol, unknown>): Promise<{
+        headers: http.IncomingHttpHeaders;
+        body: T;
+    }>;
     get<T>(url: string, options?: OptionsOfJSONResponseBody): Promise<T>;
 }

package/dist/cjs/utils/http/http-client-got.js

@@ -30,18 +30,26 @@ class HttpClientGot {
     }
     initHeaders(token, customHeaders = {}) {
         const credentials = token ? new credentials_1.Credentials(token) : undefined;
-        this.headers = Object.assign(Object.assign({}, (credentials ? { Authorization: `Basic ${credentials === null || credentials === void 0 ? void 0 : credentials.base64Encoded}` } : {})), customHeaders);
+        this.headers = Object.assign(Object.assign({}, (credentials
+            ? { Authorization: `Basic ${credentials === null || credentials === void 0 ? void 0 : credentials.base64Encoded}` }
+            : {})), customHeaders);
     }
     injectHeadersAndCookies(url, options) {
         const cookieJar = new tough_cookie_1.CookieJar();
-        Object.keys(this.cookies).map((key) => `${key}=${this.cookies[key]}`).forEach((cookie) => {
+        Object.keys(this.cookies)
+            .map((key) => `${key}=${this.cookies[key]}`)
+            .forEach((cookie) => {
             cookieJar.setCookieSync(cookie, url);
         });
         return Object.assign(Object.assign({}, options), { headers: this.headers, cookieJar });
     }
     post(url, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            const options = this.injectHeadersAndCookies(url, { json: data, responseType: 'json', throwHttpErrors: false });
+            const options = this.injectHeadersAndCookies(url, {
+                json: data,
+                responseType: 'json',
+                throwHttpErrors: false,
+            });
             const { body, statusCode, headers } = yield this.askuiGot.post(url, options);
             if (headers['deprecation'] !== undefined) {
                 lib_1.logger.warn(headers['deprecation']);
@@ -49,7 +57,7 @@ class HttpClientGot {
             if (statusCode !== 200) {
                 throw (0, custom_errors_1.httpClientErrorHandler)(statusCode, JSON.stringify(body));
             }
-            return body;
+            return { headers, body };
         });
     }
     get(url, options = { responseType: 'json' }) {

package/dist/esm/core/inference-response/inference-response.d.ts

@@ -1,15 +1,11 @@
 import { ControlCommand } from '../ui-control-commands/control-command';
 import { Annotation } from '../annotation/annotation';
-export declare class InferenceResponse {
-    type: string;
-    data: ControlCommand | Annotation;
-    constructor(type: string, data: ControlCommand | Annotation);
-    static fromJson(json: unknown, resizeRatio?: number, image?: string): ControlCommand | Annotation;
-    static createModels(type: string, data: ControlCommand | Annotation, resizeRatio: number, image?: string): ControlCommand | Annotation;
-    static models: Models;
+import { ModelType } from './model-type';
+export interface InferenceResponseBody {
+    type: ModelType;
+    data: ModelType extends 'COMMANDS' ? ControlCommand : Annotation;
 }
-interface Models {
-    DETECTED_ELEMENTS: CallableFunction;
-    COMMANDS: CallableFunction;
+export declare class InferenceResponse {
+    static fromJson(json: InferenceResponseBody, resizeRatio?: number, image?: string): ControlCommand | Annotation;
+    static createModels(type: ModelType, data: ModelType extends 'COMMANDS' ? ControlCommand : Annotation, resizeRatio: number, image?: string): ControlCommand | Annotation;
 }
-export {};

package/dist/esm/core/inference-response/inference-response.js

@@ -1,21 +1,16 @@
 import { ControlCommand } from '../ui-control-commands/control-command';
 import { Annotation } from '../annotation/annotation';
+import { InvalidModelTypeError } from './invalid-model-type-error';
 export class InferenceResponse {
-    constructor(type, data) {
-        this.type = type;
-        this.data = data;
-    }
     static fromJson(json, resizeRatio = 1, image) {
-        const inferenceResponse = json;
-        return this.createModels(inferenceResponse.type, inferenceResponse.data, resizeRatio, image);
+        return this.createModels(json.type, json.data, resizeRatio, image);
     }
     static createModels(type, data, resizeRatio, image) {
-        return this.models[type](data, resizeRatio, image);
+        if (type === 'COMMANDS')
+            return ControlCommand.fromJson(data, resizeRatio);
+        if (type === 'DETECTED_ELEMENTS') {
+            return Annotation.fromJson({ image, detected_elements: data.detected_elements }, resizeRatio);
+        }
+        throw new InvalidModelTypeError(type);
     }
 }
-InferenceResponse.models = {
-    DETECTED_ELEMENTS: (data, resizeRatio, image) => Annotation
-        .fromJson({ image, detected_elements: data.detected_elements }, resizeRatio),
-    COMMANDS: (data, resizeRatio) => ControlCommand
-        .fromJson(data, resizeRatio),
-};

package/dist/esm/core/inference-response/invalid-model-type-error.d.ts

@@ -0,0 +1,4 @@
+import { ModelType } from './model-type';
+export declare class InvalidModelTypeError extends Error {
+    constructor(type: ModelType);
+}

package/dist/esm/core/inference-response/invalid-model-type-error.js

@@ -0,0 +1,5 @@
+export class InvalidModelTypeError extends Error {
+    constructor(type) {
+        super(`Invalid model type: ${type}`);
+    }
+}

package/dist/esm/core/inference-response/model-type.d.ts

@@ -0,0 +1 @@
+export declare type ModelType = 'DETECTED_ELEMENTS' | 'COMMANDS';

package/dist/esm/core/inference-response/model-type.js

@@ -0,0 +1 @@
+export {};