@empiricalrun/playwright-utils 0.22.7 → 0.23.0

package/bundled/test-gen/actions/next-task.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NextTaskAction = exports.NEXT_TASK = void 0;
+exports.NEXT_TASK = "next_task";
+exports.NextTaskAction = {
+    name: exports.NEXT_TASK,
+    schema: {
+        type: "function",
+        function: {
+            name: exports.NEXT_TASK,
+            description: "take the next action base on the provided task",
+            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 should be a separate action.
+Each action should take the task to completion, if not the action is invalid.`,
+                    },
+                    listOfAnnotations: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                elementID: {
+                                    type: "string",
+                                },
+                                text: {
+                                    type: "string",
+                                },
+                            },
+                            required: ["elementId", "text"],
+                        },
+                        description: "A list which contains mapping of all the unique element IDs within the yellow box on the screen to their corresponding texts/icons. If an element is an icon, return 'Icon: <description of icon>'.",
+                    },
+                    unannotatedElements: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                        description: "A list of text/icon of elements which are unannotated, clickable and are present on the screen. An element is annotated if there is a red box drawn around it. If an element is an icon, return 'Icon: <description of icon>'.",
+                    },
+                    elementAnnotation: {
+                        type: "string",
+                        description: "If the element is present in listOfAnnotations, return the element ID; otherwise, return empty string ''.",
+                    },
+                },
+                required: ["reason", "action", "elementAnnotation"],
+            },
+        },
+    },
+};

package/bundled/test-gen/actions/press.d.ts

@@ -0,0 +1,4 @@
+import { PlaywrightActionGenerator, PressActionArgs } from "../types";
+export declare const PLAYWRIGHT_PRESS_ACTION_NAME = "keyboard_press_on_element";
+export declare const pressActionGenerator: PlaywrightActionGenerator<PressActionArgs>;
+//# sourceMappingURL=press.d.ts.map

package/bundled/test-gen/actions/press.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"press.d.ts","sourceRoot":"","sources":["../../src/actions/press.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAItE,eAAO,MAAM,4BAA4B,8BAA8B,CAAC;AAExE,eAAO,MAAM,oBAAoB,EAAE,yBAAyB,CAC1D,eAAe,CA6DhB,CAAC"}

package/bundled/test-gen/actions/press.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pressActionGenerator = exports.PLAYWRIGHT_PRESS_ACTION_NAME = void 0;
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+exports.PLAYWRIGHT_PRESS_ACTION_NAME = "keyboard_press_on_element";
+const pressActionGenerator = (page) => {
+    return {
+        execute: async ({ args }) => {
+            const css = args.css_selector;
+            const locator = await (0, utils_1.getPlaywrightLocatorUsingCssSelector)(css, args.xpath, page.pwPageInstance, args?.elementAnnotation);
+            const exec = new Function("page", `return page.${locator}.press("${args.key}", { timeout: 3000 })`);
+            await exec(page.pwPageInstance);
+            return {
+                locator,
+            };
+        },
+        // TODO: args transformer to be kept at a single place
+        template: (args, options) => {
+            return {
+                code: `await ${page.name}.${options.locator}.press("${args.key}");`,
+            };
+        },
+        name: exports.PLAYWRIGHT_PRESS_ACTION_NAME,
+        schema: {
+            type: "function",
+            function: {
+                name: exports.PLAYWRIGHT_PRESS_ACTION_NAME,
+                description: "Focuses the matching element and presses a combination of the keys",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: constants_1.DEFAULT_ACTION_REASON_PROMPT,
+                        },
+                        key: {
+                            type: "string",
+                            description: "The key to press on the keyboard after focusing the element. Example: F1 - F12, Digit0- Digit9, KeyA- KeyZ, Backquote, Minus, Equal, Backslash, Backspace, Tab, Delete, Escape, ArrowDown, End, Enter, Home, Insert, PageDown, PageUp, ArrowRight, ArrowUp, etc.",
+                        },
+                        xpath: {
+                            type: "string",
+                            description: "XPath selector to identify the element uniquely and click it. When creating XPATH selector, ensure they are unique and specific enough to select only one element, even if there are multiple elements of the same type (like multiple h1 elements)",
+                        },
+                        css_selector: {
+                            type: "string",
+                            description: "CSS selector to identify the element uniquely.When creating CSS selectors, ensure they are unique to the page and specific enough to select only one element.",
+                        },
+                    },
+                    required: ["reason", "key", "xpath", "css_selector"],
+                },
+            },
+        },
+    };
+};
+exports.pressActionGenerator = pressActionGenerator;

package/bundled/test-gen/actions/skill.d.ts

@@ -0,0 +1,21 @@
+import { PlaywrightActionGenerator, SkillActionArgs } from "../types";
+export declare const SKILL_USAGE = "skill_usage";
+export type Skill = {
+    testStep: string;
+    filePath: string;
+    usageExample: string;
+    reason: string;
+};
+declare class TestCaseSkills {
+    private skills;
+    constructor(skills: Skill[]);
+    getAvailableSkills(): Skill[];
+    updateSkills(skills: Skill[]): void;
+}
+export declare const testCaseSkills: TestCaseSkills;
+export declare function extractSkillFromArgs(args: Record<string, any>): {
+    skillDetails: Skill | undefined;
+};
+export declare const skillActionGenerator: PlaywrightActionGenerator<SkillActionArgs>;
+export {};
+//# sourceMappingURL=skill.d.ts.map

package/bundled/test-gen/actions/skill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../src/actions/skill.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,yBAAyB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEtE,eAAO,MAAM,WAAW,gBAAgB,CAAC;AAEzC,MAAM,MAAM,KAAK,GAAG;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,cAAM,cAAc;IACN,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK,EAAE;IAEnC,kBAAkB;IAIlB,YAAY,CAAC,MAAM,EAAE,KAAK,EAAE;CAG7B;AAED,eAAO,MAAM,cAAc,gBAAyB,CAAC;AAErD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;EAO7D;AAED,eAAO,MAAM,oBAAoB,EAAE,yBAAyB,CAC1D,eAAe,CAkHhB,CAAC"}

package/bundled/test-gen/actions/skill.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillActionGenerator = exports.extractSkillFromArgs = exports.testCaseSkills = exports.SKILL_USAGE = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const api_1 = __importDefault(require("tsx/cjs/api"));
+const use_skill_1 = require("../agent/codegen/use-skill");
+const web_1 = require("../bin/utils/platform/web");
+exports.SKILL_USAGE = "skill_usage";
+class TestCaseSkills {
+    skills;
+    constructor(skills) {
+        this.skills = skills;
+    }
+    getAvailableSkills() {
+        return this.skills;
+    }
+    updateSkills(skills) {
+        this.skills = skills;
+    }
+}
+exports.testCaseSkills = new TestCaseSkills([]);
+function extractSkillFromArgs(args) {
+    const availableSkills = exports.testCaseSkills.getAvailableSkills();
+    const { skill } = args;
+    const [skillDetails] = availableSkills.filter((skillDetails) => skillDetails.testStep === skill);
+    return { skillDetails };
+}
+exports.extractSkillFromArgs = extractSkillFromArgs;
+const skillActionGenerator = (page, options) => {
+    const availableSkills = exports.testCaseSkills.getAvailableSkills();
+    return {
+        execute: async ({ args, trace }) => {
+            const { skill, action } = args;
+            const [skillDetails] = availableSkills.filter((skillDetails) => skillDetails.testStep === skill);
+            if (!skillDetails) {
+                throw new Error(`No skill found for ${skill}`);
+            }
+            const skillFilePath = skillDetails.filePath;
+            // This assumes repoDir is process.cwd()
+            const [lastDir] = process.cwd().split("/").reverse();
+            const dir = `${process.cwd()}/${lastDir}`;
+            const module = await api_1.default.require(`./${skillFilePath}`, dir);
+            const skillFile = await promises_1.default.readFile(skillFilePath, "utf-8");
+            const imports = Object.keys(module);
+            const code = await (0, use_skill_1.generateSkillUsageCode)({
+                task: action,
+                sampleUsageMethod: skillDetails.usageExample,
+                importPathForSkill: skillFilePath,
+                scopeVariablesMapStr: JSON.stringify(options.stateVariables || {}, null, 2),
+                pageVariableName: page.name,
+                skillMethodDefinition: skillFile,
+                trace,
+            });
+            console.log("Usage code generated", code);
+            const stateVarKeys = Object.keys(options.stateVariables || {});
+            const newVariablesSpan = trace?.span({
+                name: "new-state-variables",
+            });
+            const newVariables = (0, web_1.getVariableDeclarationsFromCode)(code);
+            newVariablesSpan?.end({
+                output: {
+                    newVariables,
+                },
+            });
+            const exec = new Function(page.name, ...imports, ...stateVarKeys, 
+            // assuming all POMs are async methods and the LLM should respond with await keyword
+            `
+        return (async () => {
+          ${code}
+          return {
+            ${newVariables.join(",")}
+          }
+        })()`);
+            // extract the state variables after execution
+            const newStateVariables = await exec(page.pwPageInstance, ...imports.map((i) => module[i]), ...stateVarKeys.map((s) => options.stateVariables[s]));
+            options.setStateVariables({
+                ...options.stateVariables,
+                ...newStateVariables,
+            });
+            return {
+                locator: code,
+            };
+        },
+        template: (args, options) => {
+            const code = `${options.locator}`;
+            const skill = args.skill;
+            const [skillDetails] = availableSkills.filter((skillDetails) => skillDetails.testStep === skill);
+            return {
+                code,
+                importPath: skillDetails?.filePath,
+            };
+        },
+        name: exports.SKILL_USAGE,
+        schema: {
+            type: "function",
+            function: {
+                name: exports.SKILL_USAGE,
+                description: "Ability to use already defined skills in the form of page object models to execute a particular task.",
+                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 action for which this skill needs to be used. Mention all details about the action so that it could be used by the skill",
+                        },
+                        skill: {
+                            type: "string",
+                            enum: availableSkills.map((skill) => skill.testStep),
+                            description: `skill to use. Choose one of the available skills: ${availableSkills
+                                .map((skill) => skill.testStep)
+                                .join(", ")}`,
+                        },
+                    },
+                    required: ["reason", "action", "skill"],
+                },
+            },
+        },
+    };
+};
+exports.skillActionGenerator = skillActionGenerator;

package/bundled/test-gen/actions/text-content.d.ts

@@ -0,0 +1,4 @@
+import { PlaywrightActionGenerator, TextContentActionArgs } from "../types";
+export declare const PLAYWRIGHT_TEXT_CONTENT_ACTION_NAME = "text_content";
+export declare const textContentActionGenerator: PlaywrightActionGenerator<TextContentActionArgs>;
+//# sourceMappingURL=text-content.d.ts.map

package/bundled/test-gen/actions/text-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-content.d.ts","sourceRoot":"","sources":["../../src/actions/text-content.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAI5E,eAAO,MAAM,mCAAmC,iBAAiB,CAAC;AAElE,eAAO,MAAM,0BAA0B,EAAE,yBAAyB,CAChE,qBAAqB,CA2DtB,CAAC"}

package/bundled/test-gen/actions/text-content.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textContentActionGenerator = exports.PLAYWRIGHT_TEXT_CONTENT_ACTION_NAME = void 0;
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+exports.PLAYWRIGHT_TEXT_CONTENT_ACTION_NAME = "text_content";
+const textContentActionGenerator = (page, options) => {
+    return {
+        execute: async ({ args }) => {
+            const locator = await (0, utils_1.getPlaywrightLocatorUsingCssSelector)(args.css_selector, args.xpath, page.pwPageInstance, args?.elementAnnotation);
+            const exec = new Function("page", `return page.${locator}.textContent()`);
+            const textContent = await exec(page.pwPageInstance);
+            options.setStateVariables({
+                ...options.stateVariables,
+                [args.variable_name]: textContent,
+            });
+            return {
+                locator,
+            };
+        },
+        template: (args, options) => {
+            return {
+                code: `const ${args.variable_name} = await ${page.name}.${options.locator}.textContent();`,
+            };
+        },
+        name: exports.PLAYWRIGHT_TEXT_CONTENT_ACTION_NAME,
+        schema: {
+            type: "function",
+            function: {
+                name: exports.PLAYWRIGHT_TEXT_CONTENT_ACTION_NAME,
+                description: "extract text content of the element",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        reason: {
+                            type: "string",
+                            description: constants_1.DEFAULT_ACTION_REASON_PROMPT,
+                        },
+                        variable_name: {
+                            type: "string",
+                            description: "name of the variable to store the text content. The variable name should describe what the text content is about.",
+                        },
+                        xpath: {
+                            type: "string",
+                            description: "XPath selector to identify the element uniquely and click it. When creating XPATH selector, ensure they are unique and specific enough to select only one element, even if there are multiple elements of the same type (like multiple h1 elements)",
+                        },
+                        css_selector: {
+                            type: "string",
+                            description: "CSS selector to identify the element uniquely.When creating CSS selectors, ensure they are unique to the page and specific enough to select only one element.",
+                        },
+                    },
+                    required: ["reason", "variable_name", "xpath", "css_selector"],
+                },
+            },
+        },
+    };
+};
+exports.textContentActionGenerator = textContentActionGenerator;

package/bundled/test-gen/actions/utils/index.d.ts

@@ -0,0 +1,10 @@
+import { Page } from "playwright";
+declare global {
+    interface Window {
+        playwright: any;
+        jQuery: any;
+    }
+}
+export declare function getPlaywrightLocatorUsingCssSelector(cssSelector: string, xpath: string, page: Page, elementAnnotation?: string): Promise<any>;
+export declare function getPageVarName(): string;
+//# sourceMappingURL=index.d.ts.map

package/bundled/test-gen/actions/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/actions/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,UAAU,EAAE,GAAG,CAAC;QAChB,MAAM,EAAE,GAAG,CAAC;KACb;CACF;AAED,wBAAsB,oCAAoC,CACxD,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,IAAI,EACV,iBAAiB,CAAC,EAAE,MAAM,gBAkH3B;AAED,wBAAgB,cAAc,WAG7B"}

package/bundled/test-gen/actions/utils/index.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageVarName = exports.getPlaywrightLocatorUsingCssSelector = void 0;
+async function getPlaywrightLocatorUsingCssSelector(cssSelector, xpath, page, elementAnnotation) {
+    // TODO: analyse other solutions than just css. Also find other solutions to support :has-text -> prompting ?
+    // jquery doesnt support :has-text. neither css. Only playwright locator supports this selector though.
+    const sanitizedCssSelectorForJQuery = cssSelector
+        ?.replaceAll(":has-text", ":contains")
+        ?.replaceAll(":text", ":contains");
+    return await page.evaluate((locator) => {
+        const elementAnnotation = locator?.elementAnnotation;
+        let selectedElem;
+        if (elementAnnotation &&
+            // @ts-ignore
+            window?.annotationInstance?.annotations?.[elementAnnotation]) {
+            selectedElem =
+                // @ts-ignore
+                window?.annotationInstance?.annotations?.[elementAnnotation]?.node;
+            const elementDepth = 
+            //@ts-ignore
+            window?.annotationInstance?.annotations?.[elementAnnotation].depth;
+            const frameLocatorStr = elementDepth
+                // @ts-ignore
+                .map((e, index) => {
+                const locator = index === 0
+                    ? //To handle the parent iframe
+                        window.playwright.generateLocator(e)
+                    : elementDepth[index - 1].contentWindow.playwright.generateLocator(e);
+                return locator.replace(/^locator\(/, "frameLocator(");
+            })
+                .join(".");
+            let elementLocator;
+            //If the element is inside an iframe, we need to append the locator for the iframe
+            if (elementDepth.length > 0) {
+                elementLocator =
+                    elementDepth[elementDepth.length - 1].contentWindow.playwright.generateLocator(selectedElem);
+            }
+            else {
+                elementLocator = window.playwright.generateLocator(selectedElem);
+            }
+            return frameLocatorStr
+                ? `${frameLocatorStr}.${elementLocator}`
+                : elementLocator;
+        }
+        else if (locator.xpath) {
+            try {
+                const xpath = locator.xpath.replaceAll("text()", "normalize-space()");
+                const result = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
+                let node = result.iterateNext();
+                const elements = [];
+                // Store all matched elements
+                while (node) {
+                    elements.push(node);
+                    node = result.iterateNext();
+                }
+                // Find the least deep nesting (i.e., with the fewest child elements)
+                let minChildCount = Infinity;
+                const leastNestedElements = [];
+                elements.forEach((el) => {
+                    //@ts-ignore
+                    const childCount = el.children.length; // Count direct child elements
+                    if (childCount < minChildCount) {
+                        minChildCount = childCount;
+                        leastNestedElements.length = 0;
+                        leastNestedElements.push(el);
+                    }
+                    else if (childCount === minChildCount) {
+                        leastNestedElements.push(el);
+                    }
+                });
+                selectedElem = leastNestedElements[0];
+            }
+            catch (e) {
+                // ignore error
+            }
+        }
+        if (!selectedElem) {
+            const elements = window.jQuery(locator.cssForJq);
+            let elIdx = 0;
+            Array.from(elements).some((el, i) => {
+                if (window.jQuery(el).is(":visible")) {
+                    elIdx = i;
+                    return true;
+                }
+                return false;
+            });
+            //@ts-ignore
+            selectedElem = elements[elIdx];
+        }
+        else {
+            console.log("using xpath locator");
+        }
+        if (!selectedElem) {
+            throw Error(`Unable to find element, css: ${locator.css}`);
+        }
+        return window.playwright.generateLocator(selectedElem);
+    }, {
+        css: cssSelector,
+        cssForJq: sanitizedCssSelectorForJQuery,
+        xpath: xpath,
+        elementAnnotation,
+    });
+}
+exports.getPlaywrightLocatorUsingCssSelector = getPlaywrightLocatorUsingCssSelector;
+function getPageVarName() {
+    // eslint-disable-next-line turbo/no-undeclared-env-vars
+    return process.env.PAGE_VAR_NAME || "page";
+}
+exports.getPageVarName = getPageVarName;

package/bundled/test-gen/agent/browsing/index.d.ts

@@ -0,0 +1,15 @@
+import { LLM, TraceClient } from "@empiricalrun/llm";
+import { Page } from "playwright";
+import { PlaywrightActions } from "../../actions";
+export type BrowserAgentAction = {
+    action: string;
+    code: string | undefined;
+};
+export declare function executeTaskUsingBrowsingAgent({ action, page, actions, llm, trace, }: {
+    action: string;
+    page: Page;
+    actions: PlaywrightActions;
+    llm?: LLM;
+    trace?: TraceClient;
+}): Promise<BrowserAgentAction | undefined>;
+//# sourceMappingURL=index.d.ts.map

package/bundled/test-gen/agent/browsing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agent/browsing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,GAAG,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAElC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAOlD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B,CAAC;AAEF,wBAAsB,6BAA6B,CAAC,EAClD,MAAM,EACN,IAAI,EACJ,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,iBAAiB,CAAC;IAC3B,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,GAAG,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CA8D1C"}

package/bundled/test-gen/agent/browsing/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTaskUsingBrowsingAgent = void 0;
+const llm_1 = require("@empiricalrun/llm");
+const constants_1 = require("../../constants");
+const promptTemplate_0 = "{{#section \"system\"}}\nYou are a browser automation agent who is given a task to generate code for navigation and assertion. This task is your\ngoal and you must achieve it.\n\nYou will be provided with already executed actions and basis that you need to pick the next step to achieve the task.\nRemember that the goal must be achieved.\n\nYou will be provided with the web page snapshot in the form of Document Object Model. Based on the goal and available\ntool calls you need to pick the appropriate tool call.\n\nInstructions:\n- Take actions one at a time. Do not try to take multiple actions\n- You can respond with multiple assertions in one shot\n- Do not repeat the same actions again otherwise your response will be marked INVALID\n- Avoid repeating errors which we got while executing the last action\n- Stick to the task provided to you and mark the task done once the task is complete\n- Do not execute any action which is not mentioned in the task\n- Do not repeat actions which are already executed more than twice otherwise your response will be marked INVALID\n- Always refer to \"Executed actions\" before deciding your next action for completion of the task.\n- End the task done if all actions required for task are executed\n{{/section}}\n\n{{#section \"user\"}}\nTask:\n{{task}}\n\nCurrent page snapshot:\n{{pageSnapshot}}\n{{/section}}";
+const reporter_1 = require("../../reporter");
+const html_1 = require("../../utils/html");
+const utils_1 = require("../utils");
+async function executeTaskUsingBrowsingAgent({ action, page, actions, llm, trace, }) {
+    let generatedCodeSteps;
+    const tools = actions.getBrowsingActionSchemas();
+    const testgenUpdatesReporter = new reporter_1.TestGenUpdatesReporter();
+    const browsingAgentSpan = trace?.span({
+        name: `browsing-agent`,
+        input: {
+            action,
+        },
+    });
+    const pageContentSpan = browsingAgentSpan?.span({
+        name: "page-content",
+    });
+    const pageContent = await page.content();
+    pageContentSpan?.end({ output: { pageContent } });
+    const sanitizationSpan = browsingAgentSpan?.span({
+        name: "page-sanitization",
+    });
+    const pageSnapshot = (0, html_1.sanitizeHtml)(pageContent);
+    sanitizationSpan?.end({ output: { pageSnapshot } });
+    const promptSpan = browsingAgentSpan?.span({ name: "page-prompt" });
+    const messages = (0, llm_1.compilePrompt)(promptTemplate_0, { pageSnapshot, task: action });
+    promptSpan?.end({ output: { messages } });
+    llm =
+        llm ||
+            new llm_1.LLM({
+                provider: constants_1.DEFAULT_MODEL_PROVIDER,
+            });
+    const completion = await llm.createChatCompletion({
+        model: "o3-mini-2025-01-31",
+        messages,
+        tools,
+        trace: browsingAgentSpan,
+        modelParameters: {
+            tool_choice: "required",
+        },
+    });
+    const toolCalls = completion?.tool_calls || [];
+    const toolCallsSpan = browsingAgentSpan?.span({ name: "tool-calls" });
+    for (const i in toolCalls) {
+        const toolCall = toolCalls[i];
+        const args = (0, utils_1.parseJson)(toolCall.function.arguments);
+        try {
+            const code = await actions.executeAction(toolCall.function.name, (0, utils_1.parseJson)(toolCall.function.arguments), toolCallsSpan);
+            generatedCodeSteps = {
+                // Passing reason as action, in order to pass the correct action that took place to runtime planner
+                action: args.reason,
+                code,
+            };
+        }
+        catch (e) {
+            void testgenUpdatesReporter.sendMessage(e.message);
+            throw e;
+        }
+    }
+    toolCallsSpan?.end({ output: { toolCalls, generatedCodeSteps } });
+    return generatedCodeSteps;
+}
+exports.executeTaskUsingBrowsingAgent = executeTaskUsingBrowsingAgent;

package/bundled/test-gen/agent/browsing/run.d.ts

@@ -0,0 +1,19 @@
+type GenerateTestsType = {
+    testFilePath: string;
+    filePathToUpdate: string;
+    pwProjectsFilter: string[];
+    testGenToken: string;
+    repoDir: string;
+};
+/**
+ *
+ * Function to generate tests using master agent
+ * @export
+ * @param {GenerateTestsType} {
+ *   testFilePath,
+ *   filePathToUpdate,
+ * }
+ */
+export declare function generateTestsUsingMasterAgent({ testFilePath, filePathToUpdate, pwProjectsFilter, testGenToken, repoDir, }: GenerateTestsType): Promise<void>;
+export {};
+//# sourceMappingURL=run.d.ts.map

package/bundled/test-gen/agent/browsing/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/agent/browsing/run.ts"],"names":[],"mappings":"AAkBA,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,6BAA6B,CAAC,EAClD,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,OAAO,GACR,EAAE,iBAAiB,iBA6EnB"}