@empiricalrun/test-gen 0.42.4 → 0.42.9

package/dist/agent/master/run.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTestUsingMasterAgent = void 0;
 const llm_1 = require("@empiricalrun/llm");
 const actions_1 = require("../../actions");
-const fill_1 = require("../../actions/fill");
 const skill_1 = require("../../actions/skill");
 const utils_1 = require("../../actions/utils");
 const logger_1 = require("../../bin/logger");
@@ -15,6 +14,8 @@ const browsing_1 = require("../browsing");
 const utils_2 = require("../browsing/utils");
 const skills_retriever_1 = require("../codegen/skills-retriever");
 const run_time_planner_1 = require("../planner/run-time-planner");
+const utils_3 = require("../utils");
+const action_tool_calls_1 = require("./action-tool-calls");
 const element_annotation_1 = require("./element-annotation");
 const next_action_1 = require("./next-action");
 const with_hints_1 = require("./with-hints");
@@ -134,28 +135,30 @@ async function createTestUsingMasterAgent({ task, page, testCase, options, scope
             trace: masterAgentSpan,
             llm,
             options,
-            pageScreenshot,
+            pageScreenshot: [pageScreenshot],
             actions,
+            actionTypes: action_tool_calls_1.ActionType,
             disableSkills,
+            page,
+            logger,
         });
         if (await (0, session_1.shouldStopSession)()) {
             break;
         }
         if (toolCall) {
-            const args = JSON.parse(toolCall.function.arguments);
+            const args = (0, utils_3.parseJson)(toolCall.toolCallArgs);
             const masterAgentActionSpan = masterAgentSpan?.span({
                 name: "master-agent-execute-action",
             });
             try {
                 output = {
-                    action: JSON.parse(toolCall.function.arguments).action ||
-                        JSON.parse(toolCall.function.arguments).skill,
-                    reason: JSON.parse(toolCall.function.arguments).reason,
+                    action: args.action || args.skill,
+                    reason: args.reason,
                 };
                 void testGenReporter.sendMessage(output.reason);
                 logger.log(`Next Action: ${output.action}`);
-                if (toolCall.function.name === skill_1.SKILL_USAGE) {
-                    const code = await actions.executeAction(toolCall.function.name, args, masterAgentActionSpan);
+                if (toolCall.actionType === skill_1.SKILL_USAGE) {
+                    const code = await actions.executeAction(toolCall.actionType, args, masterAgentActionSpan);
                     if (code) {
                         generatedCodeSteps.push(code);
                     }
@@ -165,15 +168,27 @@ async function createTestUsingMasterAgent({ task, page, testCase, options, scope
                     let hintsExecutionCompletion;
                     let elementAnnotation;
                     await page.waitForTimeout(2000);
-                    const actionType = JSON.parse(toolCall.function.arguments).action_type;
-                    let preference = "all";
-                    if (useActionSpecificAnnotations && (0, next_action_1.isValidActionType)(actionType)) {
+                    const actionType = toolCall.actionType;
+                    let preference = {
+                        actionType: "all",
+                    };
+                    if (useActionSpecificAnnotations && (0, action_tool_calls_1.isValidActionType)(actionType)) {
                         switch (actionType) {
-                            case fill_1.PLAYWRIGHT_FILL_ACTION_NAME:
-                                preference = "fill";
+                            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 = "all";
+                                preference = {
+                                    actionType: "all",
+                                };
                         }
                     }
                     let { annotationKeys, annotatedPageScreenshot, annotationBuffer } = await (0, element_annotation_1.getAnnotationKeys)({
@@ -181,42 +196,44 @@ async function createTestUsingMasterAgent({ task, page, testCase, options, scope
                         preference,
                         options,
                     });
-                    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: JSON.parse(toolCall.function.arguments)
-                            .element_description,
-                        annotations: annotationMapString,
-                        annotatedScreenshot: annotatedPageScreenshot,
-                        trace: masterAgentActionSpan,
-                        llm,
-                    });
-                    output.elementAnnotation = elementAnnotation;
-                    console.log("Output: ", output);
-                    await testGenReporter.sendCurrentView(annotationBuffer);
-                    const triggerHintsFlowSpan = masterAgentActionSpan?.span({
-                        name: "trigger-hints-flow",
-                        input: {
+                    if (annotationKeys.length > 0) {
+                        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: masterAgentActionSpan,
+                            llm,
+                            preference,
+                        });
+                        output.elementAnnotation = elementAnnotation;
+                        console.log("Output: ", output);
+                        await testGenReporter.sendCurrentView(annotationBuffer);
+                        const triggerHintsFlowSpan = masterAgentActionSpan?.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,
-                        },
-                    });
-                    // 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,
-                    });
+                            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) {
@@ -252,7 +269,7 @@ async function createTestUsingMasterAgent({ task, page, testCase, options, scope
                     input: {
                         action: output.action,
                         reason: output.reason,
-                        type: toolCall.function.name,
+                        type: toolCall.actionType,
                     },
                     output: {
                         success: true,
@@ -262,7 +279,7 @@ async function createTestUsingMasterAgent({ task, page, testCase, options, scope
                 disableSkills = false;
             }
             catch (e) {
-                if (toolCall.function.name === skill_1.SKILL_USAGE) {
+                if (toolCall.actionType === skill_1.SKILL_USAGE) {
                     logger.log("Disabling skill usage for next retry");
                     disableSkills = true;
                 }
@@ -270,7 +287,7 @@ async function createTestUsingMasterAgent({ task, page, testCase, options, scope
                     input: {
                         action: output.action,
                         reason: output.reason,
-                        type: toolCall.function.name,
+                        type: toolCall.actionType,
                     },
                     output: {
                         error: true,

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

@@ -0,0 +1,15 @@
+import { TraceClient } from "@empiricalrun/llm";
+import { Page } from "playwright";
+import { CustomLogger } from "../../bin/logger";
+export type FrameReference = {
+    scrollPosition: number;
+    frameScreenshot: string;
+};
+export declare function scroller({ elementDescription, page, trace, frameReference, logger, }: {
+    elementDescription: string;
+    page: Page;
+    trace?: TraceClient;
+    frameReference?: FrameReference;
+    logger?: CustomLogger;
+}): Promise<FrameReference[]>;
+//# sourceMappingURL=scroller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scroller.d.ts","sourceRoot":"","sources":["../../../src/agent/master/scroller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAahD,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAoZF,wBAAsB,QAAQ,CAAC,EAC7B,kBAAkB,EAClB,IAAI,EACJ,KAAK,EACL,cAAc,EACd,MAAM,GACP,EAAE;IACD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CA6D5B"}

package/dist/agent/master/scroller.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scroller = void 0;
+const llm_1 = require("@empiricalrun/llm");
+const vision_1 = require("@empiricalrun/llm/vision");
+const constants_1 = require("../../constants");
+const utils_1 = require("../utils");
+const action_tool_calls_1 = require("./action-tool-calls");
+const element_annotation_1 = require("./element-annotation");
+let usedAnnotations = [];
+// This checks whether scroll is possible or not
+// If the div annotation is undefined, we check the scrollability of the page
+// else we check for the element
+async function isScrollable({ scrollDirection, page, divAnnotation, }) {
+    if (divAnnotation) {
+        return await page.evaluate(({ scrollDirection, divAnnotation }) => {
+            if (
+            // @ts-ignore
+            window?.annotationInstance?.annotations?.[divAnnotation]) {
+                let element = // @ts-ignore
+                 window?.annotationInstance?.annotations?.[divAnnotation]?.node;
+                if (scrollDirection === "up") {
+                    return element.scrollTop > 0;
+                }
+                else {
+                    return (element.scrollHeight > element.clientHeight + element.scrollTop);
+                }
+            }
+            return false;
+        }, { scrollDirection, divAnnotation });
+    }
+    return await page.evaluate(({ scrollDirection }) => {
+        if (scrollDirection === "up") {
+            return window.scrollY > 0;
+        }
+        else {
+            return (document.documentElement.scrollHeight >
+                window.innerHeight + window.scrollY);
+        }
+    }, { scrollDirection });
+}
+// Performs scroll on page or the element
+// If the div annotation is undefined, we scroll the page
+// else we scroll the element
+async function scroll({ scrollBy, page, direction, divAnnotation, logger, }) {
+    if (divAnnotation) {
+        logger?.log("Scrolling the div since element is not in view");
+        return await page.evaluate(({ scrollBy, direction, divAnnotation }) => {
+            if (
+            // @ts-ignore
+            window?.annotationInstance?.annotations?.[divAnnotation]) {
+                let element = // @ts-ignore
+                 window?.annotationInstance?.annotations?.[divAnnotation]?.node;
+                let scrollHeight = scrollBy || element.clientHeight;
+                element.scrollBy(0, scrollHeight * (direction === "up" ? -1 : 1));
+                return scrollHeight;
+            }
+            return 0;
+        }, { scrollBy, direction, divAnnotation });
+    }
+    logger?.log("Scrolling the page since element is not in view");
+    return await page.evaluate(({ scrollBy, direction }) => {
+        let scrollHeight = scrollBy || window.innerHeight;
+        window.scrollBy(0, scrollHeight * (direction === "up" ? -1 : 1));
+        return scrollHeight;
+    }, { scrollBy, direction });
+}
+// Scrolls the page to top
+async function scrollToTop(page) {
+    await page.evaluate(() => {
+        window.scrollTo({ top: 0 });
+    });
+}
+// Checks if the element is visible in the current frame
+async function isElementVisibleInFrame({ elementDescription, page, trace, logger, }) {
+    const buffer = await page.screenshot();
+    const frameScreenshot = buffer.toString("base64");
+    const systemMessage = {
+        role: "system",
+        content: `
+You are a web automation tool having extraordinary capabilities of going through the webpage screenshots. You are given a task to identify whether the element with given element description is present on the screen.
+You need to make a decision whether the element is visible or not. Only consider an element to be visible if it's completely visible, otherwise respond false.`,
+    };
+    const userMessage = {
+        role: "user",
+        content: [
+            {
+                type: "text",
+                text: `
+Element description:
+${elementDescription}
+
+----            
+
+Follow the instructions before responding:
+- Scan through the content in the screenshot
+- While scanning check whether there is any element for which the given element description matches.
+- If it matches set is_visible as true
+- else set is_visible as false
+            `,
+            },
+            {
+                type: "text",
+                text: "Screenshot",
+            },
+            {
+                type: "image_url",
+                image_url: {
+                    url: (0, vision_1.imageFormatForProvider)(constants_1.DEFAULT_MODEL_PROVIDER, frameScreenshot),
+                },
+            },
+        ],
+    };
+    const tool = {
+        type: "function",
+        function: {
+            name: "is-element-visible",
+            description: "Is the element with given element description present in the screenshot",
+            parameters: {
+                type: "object",
+                properties: {
+                    reason: {
+                        type: "string",
+                        description: "Explain why the element is marked as visible and its location. The reason should be clear and concise.",
+                    },
+                    is_visible: {
+                        type: "boolean",
+                        description: "Boolean value for whether the element is completely visible in the screenshot.",
+                    },
+                },
+                required: ["reason", "is_visible"],
+            },
+        },
+    };
+    const messages = [
+        systemMessage,
+        userMessage,
+    ];
+    const scrollSpan = trace?.span({
+        name: "is-element-visible-after-scroll",
+        input: {
+            elementDescription,
+            messages,
+        },
+    });
+    const llm = new llm_1.LLM({
+        provider: constants_1.DEFAULT_MODEL_PROVIDER,
+        defaultModel: constants_1.DEFAULT_MODEL,
+    });
+    const completion = await llm.createChatCompletion({
+        messages,
+        modelParameters: {
+            ...constants_1.DEFAULT_MODEL_PARAMETERS,
+            tool_choice: "required",
+            temperature: 1,
+        },
+        trace: scrollSpan,
+        tools: [tool],
+    });
+    let isVisible = false;
+    const toolCall = completion?.tool_calls?.[0];
+    scrollSpan?.end({ output: toolCall });
+    if (toolCall) {
+        const args = (0, utils_1.parseJson)(toolCall.function.arguments);
+        isVisible = args.is_visible || false;
+    }
+    else {
+        logger?.error(`No tool call found in completion. [Trace](${trace?.getTraceUrl()})`);
+    }
+    return {
+        isVisible,
+        frameScreenshot,
+    };
+}
+// Returns the element annotation to scroll on
+// if there is no element matching the description we return "NA"
+async function getDivAnnotationToScrollOn({ elementDescription, page, trace, logger, }) {
+    const preference = {
+        actionType: action_tool_calls_1.ActionType.SCROLL,
+    };
+    let { annotationKeys, annotatedPageScreenshot } = await (0, element_annotation_1.getAnnotationKeys)({
+        page,
+        preference: {
+            actionType: action_tool_calls_1.ActionType.SCROLL,
+        },
+        options: {},
+    });
+    // Remove the used annotations from the list
+    annotationKeys = annotationKeys.filter((key) => !usedAnnotations.includes(key.elementID));
+    if (annotationKeys.length === 0) {
+        return;
+    }
+    const annotationKeysString = annotationKeys
+        ?.map((a) => `${a.elementID}:${a.text}`)
+        .join("\n");
+    const annotationsSpan = trace?.span({
+        name: "get-div-annotation",
+        input: {
+            elementDescription,
+            annotationKeys,
+            annotatedPageScreenshot,
+            preference,
+        },
+    });
+    const systemMessage = {
+        role: "system",
+        content: `
+You are an expert in describing the images and it's content. You will be provided with an annotated screenshot where scrollable divs are annotated. 
+    
+The annotation is done by drawing a red box around the element and a small yellow box on it which contains unique element id.
+
+You are given a "Annotations" which contains list of unique element Id and description of the element separated by ":". 
+
+You are also given the description of the element which can be present inside the annotated element. The description includes information about how the element looks, it's position etc.
+
+Your task is to provide the annotation of the div on which the scroll action needs to be performed based on whether the provided element is inside the div. You can use the description of the annotated element as well. E.g. text in the div contains the text as described in the element description.
+
+You also need to extract the relevant information like the element text or position from the provided element description, this can be used to match the div content with the element.
+
+If there is a match provide the annotation for the div else respond with "NA".
+
+Follow steps to fulfil your task:
+- If the provided "Annotations" is empty, respond with "NA"
+- For each element Id, read the description for the div element
+- If the description contains the element description or anything on similar lines
+- Respond with the element Id
+- If none of the description contains the element description respond with "NA"
+- If the specified element Id is not found in the "Annotations" section, the response is invalid.
+    `,
+    };
+    const userMessage = {
+        role: "user",
+        content: [
+            {
+                type: "text",
+                text: `
+Element description:
+${elementDescription}
+
+Annotations:
+${annotationKeysString}`,
+            },
+            {
+                type: "image_url",
+                image_url: {
+                    url: (0, vision_1.imageFormatForProvider)(constants_1.DEFAULT_MODEL_PROVIDER, annotatedPageScreenshot),
+                },
+            },
+        ],
+    };
+    const messages = [
+        systemMessage,
+        userMessage,
+    ];
+    const annotationToolAction = {
+        name: "element_annotation",
+        schema: {
+            type: "function",
+            function: {
+                name: "element_annotation",
+                description: "Handles annotations for elements",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        element: {
+                            type: "string",
+                            description: "Relevant information from the provided element description.",
+                        },
+                        reason: {
+                            type: "string",
+                            description: "Explain why this element is selected. The reason should be clear and align with the task or purpose.",
+                        },
+                        element_annotation: {
+                            type: "string",
+                            description: "Return the unique element ID for the element on which the action needs to be performed.",
+                        },
+                    },
+                    required: ["element", "reason", "element_annotation"],
+                },
+            },
+        },
+    };
+    const llm = new llm_1.LLM({
+        provider: constants_1.DEFAULT_MODEL_PROVIDER,
+        defaultModel: constants_1.DEFAULT_MODEL,
+    });
+    const completion = await llm.createChatCompletion({
+        messages,
+        modelParameters: {
+            ...constants_1.DEFAULT_MODEL_PARAMETERS,
+            tool_choice: "required",
+            temperature: 1,
+        },
+        trace: annotationsSpan,
+        traceName: "get-element-from-action",
+        //@ts-ignore
+        tools: [annotationToolAction.schema],
+    });
+    const toolCall = completion?.tool_calls?.[0];
+    annotationsSpan?.end({ output: toolCall });
+    if (toolCall) {
+        const args = (0, utils_1.parseJson)(toolCall.function.arguments);
+        const isAnnotationPresentInKeys = annotationKeys.some((annotation) => annotation.elementID === args.element_annotation);
+        if (args.element_annotation !== "NA" && isAnnotationPresentInKeys) {
+            usedAnnotations.push(args.element_annotation);
+            return args.element_annotation;
+        }
+    }
+    else {
+        logger?.error(`No tool call found in completion. [Trace](${trace?.getTraceUrl()})`);
+    }
+    return;
+}
+// Scrolls the page and returns the reference to the frame in which the element is visible
+async function scroller({ elementDescription, page, trace, frameReference, logger, }) {
+    await scrollToTop(page);
+    if (frameReference) {
+        await scroll({
+            scrollBy: frameReference.scrollPosition,
+            page,
+            direction: "down",
+        });
+        return [frameReference];
+    }
+    let referenceImages = [];
+    let scrolledHeight = 0;
+    let isScrollAvailable = true;
+    const divAnnotation = await getDivAnnotationToScrollOn({
+        elementDescription,
+        page,
+        trace,
+        logger,
+    });
+    while (isScrollAvailable) {
+        // Perform action to check for visibility
+        const { isVisible, frameScreenshot } = await isElementVisibleInFrame({
+            elementDescription,
+            page,
+            trace,
+            logger,
+        });
+        if (isVisible) {
+            usedAnnotations = [];
+            referenceImages.push({
+                scrollPosition: scrolledHeight,
+                frameScreenshot,
+            });
+            // TODO: remove this to support multiple images
+            break;
+        }
+        isScrollAvailable = await isScrollable({
+            scrollDirection: "down",
+            page,
+            divAnnotation,
+        });
+        if (isScrollAvailable) {
+            scrolledHeight += await scroll({
+                page,
+                divAnnotation,
+                direction: "down",
+                logger,
+            });
+        }
+    }
+    if (referenceImages.length === 0) {
+        logger?.log("Element not found in the current scroll");
+    }
+    await (0, llm_1.flushAllTraces)();
+    return referenceImages;
+}
+exports.scroller = scroller;

package/dist/agent/master/with-hints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-hints.d.ts","sourceRoot":"","sources":["../../../src/agent/master/with-hints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAQlD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,eAAO,MAAM,0BAA0B;iBAMxB,OAAO,8BAA8B;;oBAElC,MAAM;6BACG,MAAM;MAC7B,MAAM,GAAG,OAAO,yBAAyB,EAiC5C,CAAC;AAEF,eAAO,MAAM,gBAAgB;6BAOF;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B;0BACqB,OAAO,MAAM,EAAE,GAAG,CAAC;aAChC,iBAAiB;SACrB,GAAG;;MAEN,QAAQ;IACV,sBAAsB,EAAE,OAAO,CAAC;IAChC,wBAAwB,EAAE,OAAO,qBAAqB,GAAG,SAAS,CAAC;CACpE,CAuGA,CAAC"}
+{"version":3,"file":"with-hints.d.ts","sourceRoot":"","sources":["../../../src/agent/master/with-hints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AASlD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,eAAO,MAAM,0BAA0B;iBAMxB,OAAO,8BAA8B;;oBAElC,MAAM;6BACG,MAAM;MAC7B,MAAM,GAAG,OAAO,yBAAyB,EAiC5C,CAAC;AAEF,eAAO,MAAM,gBAAgB;6BAOF;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B;0BACqB,OAAO,MAAM,EAAE,GAAG,CAAC;aAChC,iBAAiB;SACrB,GAAG;;MAEN,QAAQ;IACV,sBAAsB,EAAE,OAAO,CAAC;IAChC,wBAAwB,EAAE,OAAO,qBAAqB,GAAG,SAAS,CAAC;CACpE,CAyGA,CAAC"}

package/dist/agent/master/with-hints.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.triggerHintsFlow = exports.getUserMessageWithForHints = void 0;
 const vision_1 = require("@empiricalrun/llm/vision");
+const assert_1 = require("../../actions/assert");
 const click_1 = require("../../actions/click");
 const fill_1 = require("../../actions/fill");
 const hover_1 = require("../../actions/hover");
@@ -92,7 +93,9 @@ const triggerHintsFlow = async ({ outputFromGetNextAction, generatedAnnotations,
         });
         const canTriggerHintsFlow = completion?.tool_calls?.some((currentToolCall) => currentToolCall.function.name === fill_1.PLAYWRIGHT_FILL_ACTION_NAME ||
             currentToolCall.function.name === click_1.PLAYWRIGHT_CLICK_ACTION_NAME ||
-            currentToolCall.function.name === hover_1.PLAYWRIGHT_HOVER_ACTION_NAME);
+            currentToolCall.function.name === hover_1.PLAYWRIGHT_HOVER_ACTION_NAME ||
+            currentToolCall.function.name ===
+                assert_1.PLAYWRIGHT_ASSERT_TEXT_VISIBILITY_ACTION_NAME);
         trace?.event({
             name: "can-trigger-hints-flow",
             output: {

package/dist/agent/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function parseJson(args: string): any;
+//# sourceMappingURL=utils.d.ts.map

package/dist/agent/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/agent/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,OAMrC"}

package/dist/agent/utils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJson = void 0;
+function parseJson(args) {
+    try {
+        return JSON.parse(args);
+    }
+    catch (e) {
+        console.error("Failed to parse JSON", e);
+    }
+}
+exports.parseJson = parseJson;

package/dist/bin/utils/platform/web/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/bin/utils/platform/web/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMhD,OAAO,EAGL,IAAI,EAEJ,UAAU,EAEX,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,eAAO,MAAM,gCAAgC,eAC/B,UAAU,KACrB,MAgBF,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,YAAY,EACZ,MAAM,EACN,OAAO,GACR,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG;IACF,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB,CA2CA;AAwBD,wBAAsB,0CAA0C,CAC9D,QAAQ,EAAE,MAAM,oBA+BjB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,GAAG,SAAS,GACrB,IAAI,GAAG,SAAS,CA4BlB;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA8C7D;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,mCAWjB;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,iBAShD;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,iBAgBrE;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,UAE5E;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,iBAMpD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAcpD;AAED,wBAAsB,iCAAiC,CAAC,QAAQ,EAAE,MAAM,+BAoBvE;AA+CD,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,UAoCtB;AAED,eAAO,MAAM,6BAA6B;qBAKvB,MAAM;iBACV,MAAM;YACX,MAAM,EAAE;YA2DjB,CAAC;AAEF,eAAO,MAAM,iCAAiC,cACjC,MAAM,EAAE,gBACL,MAAM,sBAyBrB,CAAC;AAEF,wBAAsB,qBAAqB,CAAC,EAC1C,YAAY,EACZ,QAAQ,EACR,MAAM,GACP,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,iBAgDA;AAED,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EAAE,iBAsBzB;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACpB,WAYA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,UAOA;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CA4B5E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/bin/utils/platform/web/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMhD,OAAO,EAGL,IAAI,EAEJ,UAAU,EAEX,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,eAAO,MAAM,gCAAgC,eAC/B,UAAU,KACrB,MAgBF,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,YAAY,EACZ,MAAM,EACN,OAAO,GACR,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG;IACF,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,IAAI,GAAG,SAAS,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;CACnB,CA2CA;AAwBD,wBAAsB,0CAA0C,CAC9D,QAAQ,EAAE,MAAM,oBA+BjB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,GAAG,SAAS,GACrB,IAAI,GAAG,SAAS,CA4BlB;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CA8C7D;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,mCAWjB;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,iBAWhD;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,WAAW,iBAgBrE;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,UAE5E;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,iBAMpD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,UAcpD;AAED,wBAAsB,iCAAiC,CAAC,QAAQ,EAAE,MAAM,+BAoBvE;AA+CD,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,UAoCtB;AAED,eAAO,MAAM,6BAA6B;qBAKvB,MAAM;iBACV,MAAM;YACX,MAAM,EAAE;YA2DjB,CAAC;AAEF,eAAO,MAAM,iCAAiC,cACjC,MAAM,EAAE,gBACL,MAAM,sBAyBrB,CAAC;AAEF,wBAAsB,qBAAqB,CAAC,EAC1C,YAAY,EACZ,QAAQ,EACR,MAAM,GACP,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,iBAgDA;AAED,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EAAE,iBAsBzB;AAED,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACpB,WAYA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,UAOA;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CA4B5E;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQnD"}

package/dist/bin/utils/platform/web/index.js

@@ -229,6 +229,8 @@ exports.stripAndPrependImports = stripAndPrependImports;
 async function lintErrors(filePath) {
     const eslint = new eslint_1.ESLint({
         fix: true,
+        // useEslintrc: false,
+        // overrideConfigFile: path.join(process.cwd(), ".eslintrc.js"),
         useEslintrc: true,
     });
     const [result] = await eslint.lintFiles(filePath);