@empiricalrun/test-gen 0.38.28 → 0.38.30

package/dist/agent/master/run-v2.js

@@ -1,708 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTestUsingMasterAgentV2 = exports.triggerHintsFlowV2 = exports.getNextActionV2 = exports.AnnotationToolAction = void 0;
-const llm_1 = require("@empiricalrun/llm");
-const vision_1 = require("@empiricalrun/llm/vision");
-const actions_1 = require("../../actions");
-const click_1 = require("../../actions/click");
-const fill_1 = require("../../actions/fill");
-const hover_1 = require("../../actions/hover");
-const skill_1 = require("../../actions/skill");
-const utils_1 = require("../../actions/utils");
-const logger_1 = require("../../bin/logger");
-const constants_1 = require("../../constants");
-const page_1 = require("../../page");
-const reporter_1 = require("../../reporter");
-const session_1 = require("../../session");
-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 MAX_ERROR_COUNT = 2;
-function getPageVariables(stateVariables) {
-    const keys = Object.keys(stateVariables);
-    const pageVariables = keys.filter((key) => key.endsWith("Page") || key.endsWith("page"));
-    const pages = pageVariables.reduce((acc, key) => {
-        acc[key] = stateVariables[key];
-        return acc;
-    }, {});
-    return pages;
-}
-exports.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_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_annotation"],
-            },
-        },
-    },
-};
-async function getElementAnnotation({ elementDescription, annotations, annotatedScreenshot, trace, llm, options, }) {
-    const annotationsSpan = trace?.span({
-        name: "get-element-annotation",
-        input: {
-            elementDescription,
-            annotations,
-            annotatedScreenshot,
-        },
-    });
-    const systemMessage = {
-        role: "system",
-        content: `You are an expert in describing the images and it's content. You need to provide the descriptions of annotated elements present in the image.
-
-You will be provided with an annotated screenshot where interact-able / clickable elements 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 on which the action needs to be taken. The description includes information about how the element looks, it's position etc.
-
-Your task is to provide the annotation of the element on which the action needs to be performed based on the element description.
-
-Follow steps to fulfil your task:
-- Using the list of all element Ids provided to you, map all the element Ids on the annotated screen and describe each element. 
-- For describing each element Id
--- iterate over each element Id in annotation list
--- check if the description is already present for the element Id in the Annotation provided to you. If present skip describing it and use it as is.
--- if the description is NA, then identify the element in the annotated screenshot and describe it using the image or icon enclosed in the element. 
-- Respond with the mapped element Ids as "enriched_annotations"
-- Based on the description provided to you and the enriched annotations, first identify the element Id whose description matches the task provided
-
-Note:
-- Ensure providing the description of all the elements in the list.
-- Don't update the description if its already present in the given annotations
-- Replace all the "NA" with description of the element. Its position, how does it look like etc. 
-- There should be no "NA" present in any of the element description
-`,
-    };
-    const userMessage = {
-        role: "user",
-        content: [
-            {
-                type: "text",
-                text: `
-Element description:
-${elementDescription}
-
-Annotations:
-${annotations}`,
-            },
-            {
-                type: "image_url",
-                image_url: {
-                    url: (0, vision_1.imageFormatForProvider)(options?.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER, annotatedScreenshot),
-                },
-            },
-        ],
-    };
-    const messages = [
-        systemMessage,
-        userMessage,
-    ];
-    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: annotationsSpan,
-        traceName: "get-element-from-action",
-        //@ts-ignore
-        tools: [exports.AnnotationToolAction.schema],
-    });
-    const toolCall = completion?.tool_calls?.[0];
-    annotationsSpan?.end({ output: toolCall });
-    const args = JSON.parse(toolCall.function.arguments);
-    return args.element_annotation;
-}
-async function getNextActionV2({ task, executedActions, failedActions, pageUrl, trace, llm, options, pageScreenshot, actions, disableSkills, useHints = false, }) {
-    const nextActionSpan = trace?.span({
-        name: "master-agent-next-action",
-        input: {
-            task,
-            executedActions,
-            failedActions,
-            pageUrl,
-            options,
-            pageScreenshot,
-            disableSkills,
-            useHints,
-            skills: skill_1.testCaseSkills.getAvailableSkills(),
-        },
-    });
-    const promptSpan = nextActionSpan?.span({
-        name: "master-agent-prompt",
-    });
-    // assuming there is only one user message in the prompt. if there is a change in langfuse prompt format, this will need to be updated
-    const systemMessage = {
-        role: "system",
-        content: `You are an web automation tool which is given a task to complete. You need to execute the task provided to you with the help of web page screenshot, a browser automation tool or skills which are learnt while writing previous tests. 
-
-Browser automation tool is a tool which uses Playwright and browser to execute action using next_action tool call.
-Skill usage is a tool which helps to execute previously known pieces of code to achieve a task.
-
-You will be provided with a screenshot of the webpage which you will use to extract the action that needs to be taken.
-
-You will be provided with previously executed actions by the browser automation tool and based on the current screenshot and previously executed actions, you need to predict the next action to be taken.
-
-You will also be provided with failed next action predicted by you, so that you can avoid suggesting the same action again - which failed.
-
-The next action should be as atomic as possible.
-e.g: click on an element, fill an input element, assert, extract text from an element are valid next action as they are atomic in nature.
-
-You will also be provided with skill usage tool which you can use to execute action. These skills are compound functions which helps you to complete your action.
-
-You need to respond with either:
-- Next action to be taken by a browser automation tool 
-- Use previously learnt skills in the form of tool call.
-
-You need to make a decision whether the given skill can be reused if "YES" respond with the skill else respond with the next action.`,
-    };
-    const userMessage = {
-        role: "user",
-        content: [
-            {
-                type: "text",
-                text: `Task:
-        ${task}
-        
-        ----
-        
-        Previous executed actions:
-        ${executedActions.map((a) => a).join("\n")}
-        
-        ----
-        
-        Previous failed actions:
-        ${failedActions.map((a) => a).join("\n")}
-        
-        ----
-        You are also provided with a page screenshot for you to decide the next action.
-        
-        Current page URL: ${pageUrl}
-        
-        
-        Follow the instructions before responding:
-        - Divide the task into sub tasks
-        - Using previously executed actions, identify tasks are complete and which tasks needs to be executed next.
-        - You will be provided a skill usage action, if the testStep matches the next action then respond with the skill usage.
-        - 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.
-        - Mark task as complete only when executed actions provided to you indicates that the task is done.
-        - Refer to the text and references available in the screenshot to create the next action.
-        - Do not take any extra actions which are not required for the execution of the task
-        - If there are no further actions required based on the task, then respond with task as done.
-        - Do not recommend actions which are not available in the screenshot
-        `,
-            },
-            {
-                type: "text",
-                text: "Screenshot in normal mode 👇",
-            },
-            {
-                type: "image_url",
-                image_url: {
-                    url: (0, vision_1.imageFormatForProvider)(options?.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER, pageScreenshot),
-                },
-            },
-        ],
-    };
-    const messages = [
-        systemMessage,
-        userMessage,
-    ];
-    const actionSchemas = disableSkills || skill_1.testCaseSkills.getAvailableSkills().length === 0
-        ? []
-        : actions.getMasterActionSchemas();
-    const actionToolCall = {
-        name: "next_task",
-        schema: {
-            type: "function",
-            function: {
-                name: "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.`,
-                        },
-                        element_description: {
-                            type: "string",
-                            description: "The description of the element on which action needs to be taken, including its position, appearance, etc.",
-                        },
-                    },
-                    required: ["reason", "action", "element_description"],
-                },
-            },
-        },
-    };
-    const tools = [actionToolCall.schema, ...actionSchemas];
-    promptSpan?.end({ output: { messages } });
-    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 });
-    return toolCall;
-}
-exports.getNextActionV2 = getNextActionV2;
-const triggerHintsFlowV2 = async ({ outputFromGetNextAction, generatedAnnotations, page, llm, trace, }) => {
-    try {
-        const hasElementAnnotation = outputFromGetNextAction?.elementAnnotation?.length &&
-            outputFromGetNextAction?.elementAnnotation?.trim()?.length &&
-            generatedAnnotations.some(
-            //@ts-ignore
-            (annotation) => annotation.elementID === outputFromGetNextAction?.elementAnnotation);
-        trace?.event({
-            name: "has-element-annotation",
-            output: {
-                hasElementAnnotation,
-                generatedAnnotations,
-            },
-        });
-        if (!hasElementAnnotation) {
-            return {
-                shouldTriggerHintsFlow: false,
-                hintsExecutionCompletion: undefined,
-            };
-        }
-        const actions = new actions_1.PlaywrightActions(page);
-        const completion = await llm.createChatCompletion({
-            messages: [
-                {
-                    role: "system",
-                    content: `You are a browser automation agent who is given a task to generate code for navigation and assertion. This task is your goal and you must achieve it.
-
-  You need to pick the next step to achieve the task. Remember that the goal must be achieved.
-
-  Based on the goal and available tool calls you need to pick the appropriate tool call.
-
-
-  Instructions:
-  - Take actions one at a time. Do not try to take multiple actions
-  - You can respond with multiple assertions in one shot
-  - Stick to the task provided to you and mark the task done once the task is complete
-  - Do not execute any action which is not mentioned in the task`,
-                },
-                {
-                    role: "user",
-                    content: [
-                        {
-                            type: "text",
-                            text: `Task: ${outputFromGetNextAction?.action}`,
-                        },
-                    ],
-                },
-            ],
-            tools: actions.getBrowsingActionSchemas(),
-            modelParameters: {
-                temperature: 0.5,
-                max_completion_tokens: 4000,
-                tool_choice: "required",
-            },
-            trace,
-        });
-        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);
-        trace?.event({
-            name: "can-trigger-hints-flow",
-            output: {
-                canTriggerHintsFlow,
-            },
-        });
-        if (!canTriggerHintsFlow) {
-            return {
-                shouldTriggerHintsFlow: false,
-                hintsExecutionCompletion: undefined,
-            };
-        }
-        return {
-            shouldTriggerHintsFlow: true,
-            // @ts-ignore
-            hintsExecutionCompletion: completion,
-        };
-    }
-    catch (e) {
-        console.error("Error in triggerHintsFlow", e);
-        trace?.event({
-            name: "trigger-hints-flow-error",
-            output: {
-                errorMessage: e?.message,
-                errorStack: e?.stack,
-            },
-        });
-        return {
-            shouldTriggerHintsFlow: false,
-            hintsExecutionCompletion: undefined,
-        };
-    }
-};
-exports.triggerHintsFlowV2 = triggerHintsFlowV2;
-// let screenshotIndex = 0; // keeping this for local debugging
-async function createTestUsingMasterAgentV2({ task, page, testCase, options, scopeVars, }) {
-    const useHints = options?.useHints || false;
-    const logger = new logger_1.CustomLogger({ useReporter: false });
-    const testgenUpdatesReporter = new reporter_1.TestGenUpdatesReporter();
-    const session = (0, session_1.getSessionDetails)();
-    const testGenPage = new page_1.TestGenPage(page, (0, utils_1.getPageVarName)());
-    console.log("Using master agent v2");
-    // add timeout for the page to settle in
-    await page.waitForTimeout(3000);
-    const trace = llm_1.langfuseInstance?.trace({
-        name: "test-generator",
-        id: crypto.randomUUID(),
-        version: session.version,
-        metadata: {
-            generationId: session.generationId,
-            sessionId: session.sessionId,
-            testUrl: session.testUrl,
-        },
-        tags: [
-            options.metadata?.projectName,
-            options.metadata?.environment,
-        ].filter((s) => !!s),
-    });
-    if (trace) {
-        void testgenUpdatesReporter.sendMessage(`Starting master agent. [view trace](${trace?.getTraceUrl()})`);
-        logger.log(`Starting master agent: ${trace?.getTraceUrl()}`);
-        void testgenUpdatesReporter.sendAgentTraceUrl(trace.getTraceUrl());
-    }
-    const llm = new llm_1.LLM({
-        trace,
-        provider: options.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER,
-        defaultModel: options.model || constants_1.DEFAULT_MODEL,
-        providerApiKey: constants_1.MODEL_API_KEYS[options.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER],
-        // we will be using google model for larger context window, in such cases 1 million tokens is not enough
-        maxTokens: options.modelProvider === "google" ? 3000000 : 1000000,
-    });
-    const skills = await (0, skills_retriever_1.getAppropriateSkills)({
-        testCase,
-        trace,
-        //@ts-ignore
-        options,
-    });
-    skill_1.testCaseSkills.updateSkills(skills);
-    const actions = new actions_1.PlaywrightActions(testGenPage, scopeVars);
-    await (0, utils_2.injectPwLocatorGenerator)(page);
-    trace?.update({ input: { task } });
-    let isGivenTaskDone = false;
-    const masterAgentActions = [];
-    let failedActions = [];
-    let disableSkills = false;
-    while (!isGivenTaskDone) {
-        if (await (0, session_1.shouldStopSession)()) {
-            break;
-        }
-        const masterAgentSpan = trace?.span({
-            name: "master-agent",
-            input: {
-                task,
-                executedActions: masterAgentActions,
-                failedActions,
-            },
-        });
-        const plannerResp = await (0, run_time_planner_1.runtimePlanner)({
-            trace: masterAgentSpan,
-            task,
-            conversation: [...masterAgentActions],
-            pages: getPageVariables(actions.getStateVariables()),
-            currentPage: (0, utils_1.getPageVarName)(),
-        });
-        isGivenTaskDone = plannerResp.isDone;
-        if (isGivenTaskDone) {
-            await testgenUpdatesReporter.sendMessage(`${plannerResp.reason} Marking the task as done.`);
-            break;
-        }
-        if (actions.getStateVariables()[plannerResp.pageName]) {
-            // update page for the master agent
-            page = actions.getStateVariables()[plannerResp.pageName];
-            // update page in actions
-            testGenPage.updatePage({ page, name: plannerResp.pageName });
-        }
-        // inject scripts in the page
-        await (0, utils_2.injectPwLocatorGenerator)(testGenPage.pwPageInstance);
-        const buffer = await page.screenshot({
-        //This is done to improve element annotation accuracy, anyways it doesn't annotate elements which are out of viewport
-        // fullPage: true,
-        // path: `screenshots/screenshot-${screenshotIndex++}.png`, // enable this and screenshotIndex var for local debugging
-        });
-        const testGenReporter = new reporter_1.TestGenUpdatesReporter();
-        await testGenReporter.sendCurrentView(buffer);
-        const pageScreenshot = buffer.toString("base64");
-        let output;
-        let generatedCodeSteps = [];
-        if (await (0, session_1.shouldStopSession)()) {
-            break;
-        }
-        const toolCall = await getNextActionV2({
-            task,
-            executedActions: masterAgentActions,
-            failedActions,
-            pageUrl: page.url(),
-            trace: masterAgentSpan,
-            llm,
-            options,
-            pageScreenshot,
-            actions,
-            disableSkills,
-            useHints,
-        });
-        if (await (0, session_1.shouldStopSession)()) {
-            break;
-        }
-        if (toolCall) {
-            const args = JSON.parse(toolCall.function.arguments);
-            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,
-                };
-                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 (code) {
-                        generatedCodeSteps.push(code);
-                    }
-                }
-                else {
-                    let shouldTriggerHintsFlow;
-                    let hintsExecutionCompletion;
-                    let annotationKeys = [];
-                    let elementAnnotation;
-                    if (useHints) {
-                        await page.waitForTimeout(2000);
-                        annotationKeys = await page.evaluate(() => {
-                            // @ts-ignore
-                            // eslint-disable-next-line no-undef
-                            window.annotationInstance = annotateClickableElements();
-                            const annotations = Object.entries(
-                            // @ts-ignore
-                            window.annotationInstance.annotations).map(([key, value]) => ({
-                                elementID: key, // Assign the key to elementID
-                                text: 
-                                //@ts-ignore
-                                value.node.innerText?.trim() ||
-                                    //@ts-ignore
-                                    value.node.placeholder?.trim() ||
-                                    "NA",
-                            }));
-                            return annotations;
-                        });
-                        await page.waitForTimeout(2000);
-                        let annotatedPageScreenshot;
-                        const annonationBuffer = await page.screenshot({
-                        //This is done to improve element annotation accuracy, anyways it doesn't annotate elements which are out of viewport
-                        // fullPage: true,
-                        // path: `screenshots/screenshot-${screenshotIndex++}.png`,
-                        });
-                        annotatedPageScreenshot = annonationBuffer.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();
-                            }
-                        });
-                        const annotationMapString = annotationKeys
-                            ?.map((a) => `${a.elementID}:${a.text}`)
-                            .join("\n");
-                        elementAnnotation = await 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(annonationBuffer);
-                        const triggerHintsFlowSpan = masterAgentActionSpan?.span({
-                            name: "trigger-hints-flow",
-                            input: {
-                                outputFromGetNextAction: output,
-                                generatedAnnotations: annotationKeys,
-                            },
-                        });
-                        const result = await (0, exports.triggerHintsFlowV2)({
-                            outputFromGetNextAction: output,
-                            generatedAnnotations: annotationKeys,
-                            page: testGenPage,
-                            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];
-                            const code = await actions.executeAction(currentToolCall.function.name, {
-                                ...JSON.parse(currentToolCall.function.arguments),
-                                elementAnnotation,
-                            }, masterAgentActionSpan);
-                            if (code) {
-                                generatedCodeSteps.push(code);
-                            }
-                        }
-                        if (actions.isStuckInLoop()) {
-                            throw new Error("Agent is not able to figure out next action when using hints");
-                        }
-                    }
-                    else {
-                        generatedCodeSteps = await (0, browsing_1.executeTaskUsingBrowsingAgent)({
-                            trace: masterAgentActionSpan,
-                            action: output.action,
-                            logger,
-                            page,
-                            options,
-                            llm,
-                            actions,
-                        });
-                    }
-                }
-                // resetting error count as there is a successful action
-                failedActions = [];
-                masterAgentActions.push(output.action);
-                masterAgentActionSpan?.end({
-                    input: {
-                        action: output.action,
-                        reason: output.reason,
-                        type: toolCall.function.name,
-                    },
-                    output: {
-                        success: true,
-                    },
-                });
-                // enable skills after success
-                disableSkills = false;
-            }
-            catch (e) {
-                if (toolCall.function.name === skill_1.SKILL_USAGE) {
-                    logger.log("Disabling skill usage for next retry");
-                    disableSkills = true;
-                }
-                masterAgentActionSpan?.end({
-                    input: {
-                        action: output.action,
-                        reason: output.reason,
-                        type: toolCall.function.name,
-                    },
-                    output: {
-                        error: true,
-                        errorSummary: e.message,
-                    },
-                });
-                logger.error("Failed to run master agent's next task", JSON.stringify(toolCall, null, 2), e);
-                failedActions.push(output.action);
-                if (failedActions.length >= MAX_ERROR_COUNT) {
-                    const error = "Agent is not able to figure out next action, marking task as done";
-                    logger.error(error);
-                    await testgenUpdatesReporter.sendMessage(error);
-                    break;
-                }
-            }
-        }
-        trace?.update({ input: { task }, output: { output } });
-        masterAgentSpan?.end({
-            output: {
-                action: output.action,
-                reason: output.reason,
-                code: generatedCodeSteps,
-            },
-        });
-    }
-    const { code, importPaths } = actions.generateCode();
-    trace?.update({ input: { task }, output: { code } });
-    await new reporter_1.TestGenUpdatesReporter().sendCurrentView(await page.screenshot());
-    logger.success("Successfully generated code for the given task");
-    if (trace) {
-        await testgenUpdatesReporter.sendMessage(`Successfully generated code for the given task. \n View [trace](${trace.getTraceUrl()})`);
-    }
-    return {
-        code,
-        importPaths,
-    };
-}
-exports.createTestUsingMasterAgentV2 = createTestUsingMasterAgentV2;