@empiricalrun/test-gen 0.80.3 → 0.81.1

package/dist/agent/master/action-tool-calls.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"action-tool-calls.d.ts","sourceRoot":"","sources":["../../../src/agent/master/action-tool-calls.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU;IACpB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,KAAK,UAAU;IACf,YAAY,8BAA8B;IAC1C,WAAW,gBAAgB;IAC3B,KAAK,kBAAkB;IACvB,MAAM,WAAW;IACjB,WAAW,gBAAgB;IAC3B,OAAO,YAAY;CACpB;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,UAAU,CAEpE;AAqDD,wBAAgB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8CjC"}

package/dist/agent/master/action-tool-calls.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionType = void 0;
-exports.isValidActionType = isValidActionType;
-exports.getActionToolCalls = getActionToolCalls;
-var ActionType;
-(function (ActionType) {
-    ActionType["FILL"] = "fill";
-    ActionType["PAGE_GOTO"] = "page_goto";
-    ActionType["CLICK"] = "click";
-    ActionType["PRESS_ACTION"] = "keyboard_press_on_element";
-    ActionType["ASSERT_TEXT"] = "assert_text";
-    ActionType["HOVER"] = "hover_element";
-    ActionType["SCROLL"] = "scroll";
-    ActionType["OBSERVATION"] = "observation";
-    ActionType["UNKNOWN"] = "unknown";
-})(ActionType || (exports.ActionType = ActionType = {}));
-function isValidActionType(value) {
-    return Object.values(ActionType).includes(value);
-}
-const createActionCall = (name, description, additionalProperties = {}) => ({
-    type: "function",
-    function: {
-        name,
-        description,
-        parameters: {
-            type: "object",
-            properties: {
-                reason: {
-                    type: "string",
-                    description: "explain how this action will help to complete the task. the reason should align with the task provided",
-                },
-                action: {
-                    type: "string",
-                    description: `explain the next action in natural language.
-                The next action should be as atomic as possible, precise and should contain enough details about the action to be performed.
-                E.g. each click, key press, input, assert, observation should be a separate action.
-                Each action should take the task to completion, if not the action is invalid.
-                If the element is not visible then action should be scroll.`,
-                },
-                element_description: {
-                    type: "string",
-                    description: "The description of the element on which action needs to be taken, including its position, appearance, etc.",
-                },
-                is_element_visible: {
-                    type: "boolean",
-                    description: "A boolean to indicate whether the concerned element is visible in the screenshot.",
-                },
-                ...additionalProperties,
-            },
-            required: [
-                "reason",
-                "action",
-                "element_description",
-                "is_element_visible",
-                ...Object.keys(additionalProperties),
-            ],
-        },
-    },
-});
-function getActionToolCalls() {
-    return [
-        createActionCall(ActionType.ASSERT_TEXT, "assert whether the given element on the page is visible", {
-            assertion_text: {
-                type: "string",
-                description: "The text for which the visibility needs to be asserted.",
-            },
-        }),
-        createActionCall(ActionType.FILL, "fill the input element with a particular text"),
-        createActionCall(ActionType.CLICK, "click an element on the page"),
-        createActionCall(ActionType.PAGE_GOTO, "navigate the page to a new URL"),
-        createActionCall(ActionType.PRESS_ACTION, "Focuses the matching element and presses a combination of the keys"),
-        createActionCall(ActionType.HOVER, "hover over an element on the page"),
-        createActionCall(ActionType.SCROLL, "Scroll the page since element is not visible in the screenshot", {
-            element: {
-                type: "string",
-                description: "Element to look for after scrolling to complete the task.",
-            },
-        }),
-        createActionCall(ActionType.OBSERVATION, "Observation based on the task provided. If the task doesn't explicitly mention any browser interaction, and instead, asks questions to be answered — use this tool call", {
-            observation: {
-                type: "string",
-                description: "Observation based on the task provided.",
-            },
-        }),
-    ];
-}

package/dist/agent/master/element-annotation.d.ts

@@ -1,30 +0,0 @@
-import { LLM, TraceClient } from "@empiricalrun/llm";
-import { TestGenConfigOptions } from "@empiricalrun/shared-types/agent-workflow";
-import { Page } from "playwright";
-import { ActionType } from "./action-tool-calls";
-export declare function getElementAnnotation({ elementDescription, annotations, annotatedScreenshot, trace, llm, options, preference, }: {
-    elementDescription: string;
-    annotations: string;
-    annotatedScreenshot: string;
-    trace?: TraceClient;
-    llm?: LLM;
-    options?: TestGenConfigOptions;
-    preference: AnnotationPreference;
-}): Promise<string | undefined>;
-export type AnnotationPreference = {
-    actionType: "all" | ActionType.FILL | ActionType.ASSERT_TEXT | ActionType.SCROLL;
-    assertionText?: string | undefined;
-};
-export declare function getAnnotationKeys({ page, preference, trace, }: {
-    page: Page;
-    preference: AnnotationPreference;
-    trace?: TraceClient;
-}): Promise<{
-    annotationKeys: {
-        elementID: string;
-        text: string;
-    }[];
-    annotationBuffer: Buffer;
-    annotatedPageScreenshot: string;
-}>;
-//# sourceMappingURL=element-annotation.d.ts.map

package/dist/agent/master/element-annotation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"element-annotation.d.ts","sourceRoot":"","sources":["../../../src/agent/master/element-annotation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,GAAG,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAQlC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AA0DjD,wBAAsB,oBAAoB,CAAC,EACzC,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,KAAK,EACL,GAAG,EACH,OAAO,EACP,UAAU,GACX,EAAE;IACD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,UAAU,EAAE,oBAAoB,CAAC;CAClC,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA8C9B;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EACN,KAAK,GACL,UAAU,CAAC,IAAI,GACf,UAAU,CAAC,WAAW,GACtB,UAAU,CAAC,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC,CAAC;AAgBF,wBAAsB,iBAAiB,CAAC,EACtC,IAAI,EACJ,UAAU,EACV,KAAK,GACN,EAAE;IACD,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,oBAAoB,CAAC;IACjC,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,GAAG,OAAO,CAAC;IACV,cAAc,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtD,gBAAgB,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC,CAmFD"}

package/dist/agent/master/element-annotation.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getElementAnnotation = getElementAnnotation;
-exports.getAnnotationKeys = getAnnotationKeys;
-const llm_1 = require("@empiricalrun/llm");
-const constants_1 = require("../../constants");
-const promptTemplate_0 = "{{#section \"system\"}}\nYou are an expert in describing the images and it's content. You need to provide the descriptions of annotated elements\npresent in the image.\n\nYou will be provided with an annotated screenshot where interact-able / clickable elements are annotated. The annotation\nis done by drawing a red box around the element and a small yellow box on it which contains unique element id.\n\nYou are given a Annotations which contains list of unique element id and description of the element separated by \":\".\n\nYou are also given the description of the element on which the action needs to be taken. The description includes\ninformation about how the element looks, it's position etc.\n\nYour task is to provide the annotation of the element on which the action needs to be performed based on the element\ndescription.\n\nFollow steps to fulfil your task:\n- Using the list of all element Ids provided to you, map all the element Ids on the annotated screen and describe each\nelement.\n- For describing each element Id\n-- iterate over each element Id in annotation list\n-- check if the description is already present for the element Id in the Annotation provided to you. If present skip\ndescribing it and use it as is.\n-- if the description is NA, then identify the element in the annotated screenshot and describe it using the image or\nicon enclosed in the element.\n- Respond with the mapped element Ids as \"enriched_annotations\"\n- Based on the description provided to you and the enriched annotations, first identify the element Id whose description\nmatches the task provided\n\nNote:\n- Ensure providing the description of all the elements in the list.\n- Don't update the description if its already present in the given annotations\n- Replace all the \"NA\" with description of the element. Its position, how does it look like etc.\n- There should be no \"NA\" present in any of the element description\n{{/section}}\n\n{{#section \"user\"}}\nElement description:\n{{elementDescription}}\n\nAnnotations:\n{{annotations}}\n\n{{image annotatedScreenshot}}\n{{/section}}";
-const annotationToolAction = {
-    name: "element_annotation",
-    schema: {
-        type: "function",
-        function: {
-            name: "element_annotation",
-            description: "Handles annotations for elements and enriched annotations.",
-            parameters: {
-                type: "object",
-                properties: {
-                    enriched_annotations: {
-                        type: "array",
-                        description: "List of enriched annotations for elements.",
-                        items: {
-                            type: "object",
-                            properties: {
-                                element_id: {
-                                    type: "string",
-                                    description: "Unique element ID for the element.",
-                                },
-                                description: {
-                                    type: "string",
-                                    description: "Detailed description for the element. Must not be NA",
-                                },
-                            },
-                            required: ["element_id", "description"],
-                        },
-                    },
-                    reason: {
-                        type: "string",
-                        description: "Explain why this element is selected. The reason should be clear and align with the task or purpose.",
-                    },
-                    element: {
-                        type: "string",
-                        description: "Detailed description of the DOM element's visual characteristics and position.",
-                    },
-                    element_annotation: {
-                        type: "string",
-                        description: "Return the unique element ID for the element on which the action needs to be performed.",
-                    },
-                },
-                required: [
-                    "enriched_annotations",
-                    "reason",
-                    "element",
-                    "element_annotation",
-                ],
-            },
-        },
-    },
-};
-async function getElementAnnotation({ elementDescription, annotations, annotatedScreenshot, trace, llm, options, preference, }) {
-    const annotationsSpan = trace?.span({
-        name: "get-element-annotation",
-        input: {
-            elementDescription,
-            annotations,
-            annotatedScreenshot,
-            preference,
-        },
-    });
-    const messages = (0, llm_1.compilePrompt)(promptTemplate_0, {
-        elementDescription,
-        annotations,
-        annotatedScreenshot,
-    }, options);
-    llm =
-        llm ||
-            new llm_1.LLM({
-                provider: options?.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER,
-                defaultModel: options?.model || constants_1.DEFAULT_MODEL,
-            });
-    const completion = await llm.createChatCompletion({
-        messages,
-        modelParameters: {
-            ...constants_1.DEFAULT_MODEL_PARAMETERS,
-            ...options?.modelParameters,
-            tool_choice: "required",
-            temperature: 0.5,
-        },
-        trace: annotationsSpan,
-        traceName: "get-element-from-action",
-        //@ts-ignore
-        tools: [annotationToolAction.schema],
-    });
-    const toolCall = completion?.tool_calls?.[0];
-    annotationsSpan?.end({ output: toolCall });
-    if (toolCall && "function" in toolCall) {
-        const args = JSON.parse(toolCall.function.arguments);
-        return args.element_annotation;
-    }
-    return;
-}
-async function getAnnotationKeys({ page, preference, trace, }) {
-    const annotatedElements = await page.evaluate(({ preference, options }) => {
-        // @ts-ignore
-        window.annotationInstance = annotateElementsWithPreference({
-            options: options,
-            preference: preference,
-        });
-        const annotations = Object.entries(
-        // @ts-ignore
-        window.annotationInstance.annotations).map(([key, value]) => {
-            // Helper function to safely get text content
-            const getTextContent = (node) => {
-                try {
-                    return node?.innerText?.trim() || null;
-                }
-                catch {
-                    return null;
-                }
-            };
-            // Helper function to safely get placeholder
-            const getPlaceholder = (node) => {
-                try {
-                    return node?.placeholder?.trim() || null;
-                }
-                catch {
-                    return null;
-                }
-            };
-            return {
-                elementID: key,
-                innerText: getTextContent(value.node),
-                innerHTML: value.node.innerHTML,
-                outerHTML: value.node.outerHTML,
-                placeholder: getPlaceholder(value.node),
-            };
-        });
-        const fullPageHTML = document.documentElement.outerHTML;
-        return { annotations, fullPageHTML };
-    }, { preference, options: {} });
-    const annotationKeys = await enrichAnnotations(annotatedElements.annotations, annotatedElements.fullPageHTML, trace);
-    const annotationBuffer = await page.screenshot({
-    // path: `screenshots/screenshot-${screenshotIndex++}.png`,
-    });
-    const annotatedPageScreenshot = annotationBuffer.toString("base64");
-    await page.evaluate(() => {
-        console.log({
-            // @ts-ignore
-            disable: window?.annotationInstance?.disable,
-        });
-        if (
-        // @ts-ignore
-        window?.annotationInstance &&
-            // @ts-ignore
-            window?.annotationInstance?.destroy) {
-            // @ts-ignore
-            window?.annotationInstance?.destroy();
-        }
-    });
-    return {
-        annotationKeys,
-        annotationBuffer,
-        annotatedPageScreenshot,
-    };
-}
-async function enrichAnnotations(annotatedElements, _pageHtml, _trace) {
-    const results = [];
-    for (const element of annotatedElements) {
-        const text = element.innerText?.trim() || element.placeholder?.trim();
-        results.push({
-            elementID: element.elementID,
-            text: text || "NA",
-        });
-    }
-    return results;
-}

package/dist/agent/master/execute-browser-action.d.ts

@@ -1,24 +0,0 @@
-import { LLM, TraceClient } from "@empiricalrun/llm";
-import type { Page } from "@playwright/test";
-import { PlaywrightActions } from "../../actions";
-export declare function executeBrowserAction({ page, nextAction, flags, actions, llm, trace, }: {
-    page: Page;
-    nextAction: {
-        actionType: string;
-        toolCallArgs: string;
-    };
-    flags: {
-        useActionSpecificAnnotations: boolean;
-    };
-    actions: PlaywrightActions;
-    trace?: TraceClient | undefined;
-    llm: LLM;
-}): Promise<{
-    generatedCodeSteps: string[];
-    output: {
-        action: string;
-        reason: string;
-        elementAnnotation?: string;
-    };
-}>;
-//# sourceMappingURL=execute-browser-action.d.ts.map

package/dist/agent/master/execute-browser-action.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execute-browser-action.d.ts","sourceRoot":"","sources":["../../../src/agent/master/execute-browser-action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAUlD,wBAAsB,oBAAoB,CAAC,EACzC,IAAI,EACJ,UAAU,EACV,KAAK,EACL,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE;QACV,UAAU,EAAE,MAAM,CAAC;QACnB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,KAAK,EAAE;QACL,4BAA4B,EAAE,OAAO,CAAC;KACvC,CAAC;IACF,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAChC,GAAG,EAAE,GAAG,CAAC;CACV;;;gBAIW,MAAM;gBACN,MAAM;4BACM,MAAM;;GA+H7B"}

package/dist/agent/master/execute-browser-action.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeBrowserAction = executeBrowserAction;
-const browsing_1 = require("../browsing");
-const action_tool_calls_1 = require("./action-tool-calls");
-const element_annotation_1 = require("./element-annotation");
-const with_hints_1 = require("./with-hints");
-async function executeBrowserAction({ page, nextAction, flags, actions, llm, trace, }) {
-    const args = JSON.parse(nextAction.toolCallArgs);
-    let generatedCodeSteps = [];
-    let output = {
-        action: args.action,
-        reason: args.reason,
-    };
-    let shouldTriggerHintsFlow;
-    let hintsExecutionCompletion;
-    let elementAnnotation;
-    const actionType = nextAction.actionType;
-    let preference = {
-        actionType: "all",
-    };
-    if (flags.useActionSpecificAnnotations && (0, action_tool_calls_1.isValidActionType)(actionType)) {
-        switch (actionType) {
-            case action_tool_calls_1.ActionType.FILL:
-                preference = {
-                    actionType: action_tool_calls_1.ActionType.FILL,
-                };
-                break;
-            case action_tool_calls_1.ActionType.ASSERT_TEXT:
-                preference = {
-                    actionType: action_tool_calls_1.ActionType.ASSERT_TEXT,
-                    assertionText: args.assertion_text,
-                };
-                break;
-            default:
-                preference = {
-                    actionType: "all",
-                };
-        }
-    }
-    let { annotationKeys, annotatedPageScreenshot } = await (0, element_annotation_1.getAnnotationKeys)({
-        page,
-        preference,
-        trace,
-    });
-    if (annotationKeys.length > 0) {
-        // TODO: this string has newline characters that makes it harder to read
-        const annotationMapString = annotationKeys
-            ?.map((a) => `${a.elementID}: ${a.text}`)
-            .join("\n");
-        // Provides the annotations for all the element present on screen
-        // Also provides the annotation of element on which the action needs to be taken
-        elementAnnotation = await (0, element_annotation_1.getElementAnnotation)({
-            elementDescription: args.element_description,
-            annotations: annotationMapString,
-            annotatedScreenshot: annotatedPageScreenshot,
-            trace,
-            llm,
-            preference,
-        });
-        output.elementAnnotation = elementAnnotation;
-        console.log("Output: ", output);
-        const triggerHintsFlowSpan = trace?.span({
-            name: "trigger-hints-flow",
-            input: {
-                outputFromGetNextAction: output,
-                generatedAnnotations: annotationKeys,
-            },
-        });
-        // Provides the action whether its a click, fill etc.
-        const result = await (0, with_hints_1.triggerHintsFlow)({
-            outputFromGetNextAction: output,
-            generatedAnnotations: annotationKeys,
-            actions,
-            llm,
-            trace: triggerHintsFlowSpan,
-        });
-        shouldTriggerHintsFlow = result.shouldTriggerHintsFlow;
-        hintsExecutionCompletion = result.hintsExecutionCompletion;
-        triggerHintsFlowSpan?.end({
-            output: result,
-        });
-    }
-    if (shouldTriggerHintsFlow && hintsExecutionCompletion) {
-        const toolCalls = hintsExecutionCompletion?.tool_calls || [];
-        for (const i in toolCalls) {
-            const currentToolCall = toolCalls[i];
-            if (currentToolCall && "function" in currentToolCall) {
-                const code = await actions.executeAction(currentToolCall.function.name, {
-                    ...JSON.parse(currentToolCall.function.arguments),
-                    elementAnnotation,
-                }, trace);
-                if (code) {
-                    generatedCodeSteps.push(code);
-                }
-            }
-        }
-        if (actions.isStuckInLoop()) {
-            throw new Error("Agent is not able to figure out next action when using hints");
-        }
-    }
-    else {
-        const browserAction = await (0, browsing_1.executeTaskUsingBrowsingAgent)({
-            trace,
-            action: output.action,
-            page,
-            llm,
-            actions,
-        });
-        if (browserAction) {
-            output.action = browserAction.action;
-            if (browserAction.code) {
-                generatedCodeSteps.push(browserAction.code);
-            }
-        }
-    }
-    return {
-        generatedCodeSteps,
-        output,
-    };
-}

package/dist/agent/master/next-action.d.ts

@@ -1,22 +0,0 @@
-import { LLM, TraceClient } from "@empiricalrun/llm";
-import { TestGenConfigOptions } from "@empiricalrun/shared-types/agent-workflow";
-import { Page } from "playwright";
-import { PlaywrightActions } from "../../actions";
-import { CustomLogger } from "../../bin/logger";
-export declare function getNextAction({ page, pageScreenshot, task, executedActions, failedActions, trace, llm, options, actions, disableSkills, logger, }: {
-    page: Page;
-    pageScreenshot: string[];
-    task: string;
-    executedActions: string[];
-    failedActions: any[];
-    trace?: TraceClient;
-    llm?: LLM;
-    options?: Partial<TestGenConfigOptions>;
-    actions: PlaywrightActions;
-    disableSkills: boolean;
-    logger?: CustomLogger;
-}): Promise<{
-    actionType: string;
-    toolCallArgs: string;
-} | undefined>;
-//# sourceMappingURL=next-action.d.ts.map

package/dist/agent/master/next-action.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"next-action.d.ts","sourceRoot":"","sources":["../../../src/agent/master/next-action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,GAAG,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAUhD,wBAAsB,aAAa,CAAC,EAClC,IAAI,EACJ,cAAc,EACd,IAAI,EACJ,eAAe,EACf,aAAa,EACb,KAAK,EACL,GAAG,EACH,OAAO,EACP,OAAO,EACP,aAAa,EACb,MAAM,GACP,EAAE;IACD,IAAI,EAAE,IAAI,CAAC;IACX,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,GAAG,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACxC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB,GAAG,OAAO,CACP;IACE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,GACD,SAAS,CACZ,CAwFA"}

package/dist/agent/master/next-action.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNextAction = getNextAction;
-const llm_1 = require("@empiricalrun/llm");
-const constants_1 = require("../../constants");
-const promptTemplate_0 = "{{#section \"system\"}}\nYou are a web automation tool which is given a task to complete. You need to execute the\ntask provided to you with the help of web page screenshot, a browser automation tool or skills\nwhich are learnt while writing previous tests. \n  \nBrowser automation tool is a tool which uses Playwright and browser to execute action using\nnext_action tool call.\nSkill usage is a tool which helps to execute previously known pieces of code to achieve a task.\n\nYou will be provided with a screenshot of the webpage which you will use to extract the action\nthat needs to be taken.\n\nYou will be provided with previously executed actions by the browser automation tool and based\non the current screenshot and previously executed actions, you need to predict the next action\nto be taken.\n\nYou will also be provided with failed next action predicted by you, so that you can avoid\nsuggesting the same action again - which failed.\n\nThe next action should be as atomic as possible. e.g: scroll, click on an element, fill an input\nelement, assert, extract text from an element are valid next action as they are atomic in nature.\n\nYou also need to provide the action type using the list below, action type which is not present in\nthe list is invalid: {{validActionTypes}}\n\nYou will also be provided with skill usage tool which you can use to execute action. These skills\nare compound functions which helps you to complete your action.\n\nYou need to respond with either:\n- Next action to be taken by a browser automation tool \n- Use previously learnt skills in the form of tool call.\n  \nYou need to make a decision whether the given skill can be reused if \"YES\" respond with the\nskill else respond with the next action.\n{{/section}}\n\n{{#section \"user\"}}\nTask:\n{{task}}\n\n-----\n\nPrevious executed actions:\n{{executedActions}}\n\n-----\n\nPrevious failed actions:\n{{failedActions}}\n\n-----\n\nYou are also provided with a page screenshot for you to decide the next action.\n\nCurrent page URL: {{pageUrl}}\n\nFollow the instructions before responding:\n- Divide the task into sub tasks\n- Using previously executed actions, identify tasks are complete and which tasks needs to be executed next.\n- You will be provided a skill usage action, if the testStep matches the next action then respond with the skill usage.\n- If responding with next action, ensure next action to be detailed and explicit about what action needs to be done. Provide all the information which can be extracted from the screenshot as a part of next action.\n- Mark task as complete only when executed actions provided to you indicates that the task is done.\n- Refer to the text and references available in the screenshot to create the next action.\n- Do not take any extra actions which are not required for the execution of the task\n- If there are no further actions required based on the task, then respond with task as done.\n- Do not recommend actions which are not available in the screenshot\n\nScreenshots:\n{{images pageScreenshots}}\n\n{{/section}}\n";
-const action_tool_calls_1 = require("./action-tool-calls");
-const scroller_1 = require("./scroller");
-async function getNextAction({ page, pageScreenshot, task, executedActions, failedActions, trace, llm, options, actions, disableSkills, logger, }) {
-    const pageUrl = page.url();
-    const nextActionSpan = trace?.span({
-        name: "master-agent-next-action",
-        input: {
-            task,
-            executedActions,
-            failedActions,
-            pageUrl,
-            options,
-            pageScreenshot,
-            disableSkills,
-        },
-    });
-    const messages = (0, llm_1.compilePrompt)(promptTemplate_0, {
-        validActionTypes: Object.values(action_tool_calls_1.ActionType).join(", "),
-        task,
-        executedActions: executedActions.map((a) => a).join("\n"),
-        failedActions: failedActions.map((a) => a).join("\n"),
-        pageUrl,
-        pageScreenshots: pageScreenshot,
-    });
-    const tools = [...(0, action_tool_calls_1.getActionToolCalls)()];
-    llm =
-        llm ||
-            new llm_1.LLM({
-                provider: options?.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER,
-                defaultModel: options?.model || constants_1.DEFAULT_MODEL,
-            });
-    const completion = await llm.createChatCompletion({
-        messages,
-        modelParameters: {
-            ...constants_1.DEFAULT_MODEL_PARAMETERS,
-            ...options?.modelParameters,
-            tool_choice: "required",
-            temperature: 1,
-        },
-        trace: nextActionSpan,
-        traceName: "master-agent-llm",
-        // @ts-ignore
-        tools,
-    });
-    const toolCall = completion?.tool_calls?.[0];
-    nextActionSpan?.end({ output: toolCall });
-    if (toolCall && "function" in toolCall) {
-        const toolCallArgs = JSON.parse(toolCall.function.arguments);
-        const actionType = toolCall.function.name;
-        // If the action type is scroll, we need to scroll the page and get the reference to the frame in which the element is visible
-        // else we return the next action
-        // For scroll we have at max 2 retries
-        // If the element is not visible after 2 retries, we throw an error
-        if (actionType === "scroll" && toolCallArgs) {
-            let maxScrollRetries = 2;
-            while (maxScrollRetries--) {
-                const frames = await (0, scroller_1.scroller)({
-                    elementDescription: toolCallArgs.element,
-                    page,
-                    trace: nextActionSpan,
-                    logger,
-                });
-                if (frames.length > 0) {
-                    return getNextAction({
-                        task,
-                        executedActions,
-                        failedActions,
-                        trace,
-                        llm,
-                        options,
-                        pageScreenshot: frames.map((frame) => frame.frameScreenshot),
-                        actions,
-                        disableSkills,
-                        page,
-                        logger,
-                    });
-                }
-            }
-            if (maxScrollRetries === -1) {
-                return {
-                    actionType: action_tool_calls_1.ActionType.UNKNOWN,
-                    toolCallArgs: "",
-                };
-            }
-        }
-        return {
-            actionType,
-            toolCallArgs: toolCall?.function.arguments,
-        };
-    }
-}

package/dist/agent/master/planner.d.ts

@@ -1,15 +0,0 @@
-import { TraceClient } from "@empiricalrun/llm";
-import { Page } from "playwright/test";
-export declare function runtimePlannerWithScreenshot({ trace, task, conversation, pages, page, currentPage, }: {
-    trace?: TraceClient;
-    conversation: string[];
-    task: string;
-    pages?: Record<string, any>;
-    page: Page;
-    currentPage?: string;
-}): Promise<{
-    pageName: string;
-    isDone: boolean;
-    reason: string;
-}>;
-//# sourceMappingURL=planner.d.ts.map

package/dist/agent/master/planner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../../src/agent/master/planner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAIvC,wBAAsB,4BAA4B,CAAC,EACjD,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,KAAK,EACL,IAAI,EACJ,WAAW,GACZ,EAAE;IACD,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,IAAI,EAAE,IAAI,CAAC;IACX,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;cAsHoC,MAAM;YACV,OAAO;YACP,MAAM;GAgBtC"}