@empiricalrun/playwright-utils 0.22.6 → 0.23.0

package/bundled/test-gen/agent/master/with-hints.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triggerHintsFlow = void 0;
+const assert_1 = require("../../actions/assert");
+const click_1 = require("../../actions/click");
+const fill_1 = require("../../actions/fill");
+const hover_1 = require("../../actions/hover");
+const constants_1 = require("../../constants");
+const triggerHintsFlow = async ({ outputFromGetNextAction, generatedAnnotations, actions, 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 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: constants_1.DEFAULT_MODEL_PARAMETERS.temperature,
+                max_completion_tokens: constants_1.DEFAULT_MODEL_PARAMETERS.max_completion_tokens,
+                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 ||
+            currentToolCall.function.name ===
+                assert_1.PLAYWRIGHT_ASSERT_TEXT_VISIBILITY_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.triggerHintsFlow = triggerHintsFlow;

package/bundled/test-gen/agent/planner/run-time-planner.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"run-time-planner.d.ts","sourceRoot":"","sources":["../../../src/agent/planner/run-time-planner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,wBAAsB,cAAc,CAAC,EACnC,KAAK,EACL,IAAI,EACJ,iBAAiB,EACjB,KAAK,EACL,WAAW,GACZ,EAAE;IACD,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5B,WAAW,EAAE,WAAW,CAAC;CAC1B;;;;GA+FA"}

package/bundled/test-gen/agent/planner/run-time-planner.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimePlanner = void 0;
+const llm_1 = require("@empiricalrun/llm");
+const promptTemplate_0 = "{{#section \"system\"}}\nYou are given a list of successfully executed actions that are done towards completing a task (which\nis also provided to you). Your goal is to analyse the list and determine if the task is completed.\n\nIf the task is not fully completed, identify which specific actions are missing\nand suggest next steps to complete the task. Assume that the conversation provided\nis entirely truthful and no additional actions were performed beyond those listed.\n\nThese actions were executed by AI agents using Playwright on a browser. These agents\nalready have access to browser tabs to execute actions. If there is a pending action,\none of the agents will execute it in the browser. However, they need your help to\nchoose which browser tab (= page) to use for the next action.\n\nTo fulfil your goal, follow these steps:\n- Divide the task into individual actions.\n- Compare each task action against the actions listed in the successfully executed actions list.\n- Identify which actions have been executed and which have not.\n- If all actions are executed, respond with the task as done.\n- If any actions are missing, respond with the task as not done, listing all actions\n  and specifying which are complete and which are missing.\n- If provided with list of pages, based on the next pending action and previously executed\n  action, identify the page on which next action needs to be taken\n{{/section}}\n\n{{#section \"user\"}}\nTask:\n{{task}}\n\n----\n\nSuccessfully executed actions:\n{{successfulActions}}\n\n----\n\nList of pages with their current URLs:\n{{pagesSummary}}\n\n\n{{/section}}\n";
+const utils_1 = require("../utils");
+async function runtimePlanner({ trace, task, successfulActions, pages, currentPage, }) {
+    const runTimePlannerSpan = trace?.span({
+        name: "runtime-planner",
+        input: {
+            task,
+            successfulActions,
+            currentPage,
+        },
+    });
+    const llm = new llm_1.LLM({ provider: "openai" });
+    // Add the current page to the page state variables
+    pages[currentPage.name] = currentPage.pwPageInstance;
+    const pagesSummary = pages
+        ? Object.entries(pages).map(([pageName, page]) => `${pageName}: Currently on ${page.url()}`)
+        : [];
+    const pageNamesEnum = Object.keys(pages);
+    const response = await llm.createChatCompletion({
+        trace: runTimePlannerSpan,
+        traceName: "runtime-planner-llm",
+        model: "gpt-4o",
+        messages: (0, llm_1.compilePrompt)(promptTemplate_0, {
+            task,
+            successfulActions: successfulActions.join("\n"),
+            pagesSummary: pagesSummary.join("\n"),
+        }),
+        tools: [
+            {
+                type: "function",
+                function: {
+                    name: "task_done",
+                    description: "end the task by calling this method",
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            actions: {
+                                type: "string",
+                                description: "actions extracted from task",
+                            },
+                            successful_actions: {
+                                type: "string",
+                                description: "successful actions mentioned in the conversation",
+                            },
+                            reason: {
+                                type: "string",
+                                description: "reasoning for identification of task status",
+                            },
+                            nextAction: {
+                                type: "string",
+                                description: "next action to be taken",
+                            },
+                            pageName: {
+                                type: "string",
+                                enum: pageNamesEnum,
+                                description: "page name for the next action.",
+                            },
+                            isDone: {
+                                type: "boolean",
+                                description: "whether the task is done",
+                            },
+                        },
+                        required: ["isDone", "reason", "pageName", "nextAction"],
+                    },
+                },
+            },
+        ],
+        modelParameters: {
+            tool_choice: "required",
+            temperature: 0.5,
+        },
+    });
+    const toolCallResp = (response?.tool_calls || [])[0];
+    if (toolCallResp) {
+        const toolCall = (0, utils_1.parseJson)(toolCallResp.function.arguments);
+        const output = {
+            pageName: toolCall.pageName,
+            isDone: toolCall.isDone,
+            reason: toolCall.reason,
+        };
+        runTimePlannerSpan?.end({
+            output,
+        });
+        return output;
+    }
+    const output = {
+        pageName: "",
+        isDone: false,
+        reason: "LLM failed to generate a valid response",
+    };
+    runTimePlannerSpan?.end({
+        output,
+    });
+    return output;
+}
+exports.runtimePlanner = runtimePlanner;

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

@@ -0,0 +1,7 @@
+import { TraceClient } from "@empiricalrun/llm";
+export declare function planTask({ task, specPath, trace, }: {
+    task: string;
+    specPath: string;
+    trace?: TraceClient;
+}): Promise<any>;
+//# sourceMappingURL=run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/agent/planner/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAcpE,wBAAsB,QAAQ,CAAC,EAC7B,IAAI,EACJ,QAAQ,EACR,KAAK,GACN,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,gBAwHA"}

package/bundled/test-gen/agent/planner/run.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planTask = void 0;
+const llm_1 = require("@empiricalrun/llm");
+const context_1 = require("../../bin/utils/context");
+const human_in_the_loop_1 = require("../../human-in-the-loop");
+const promptTemplate_0 = "{{#section \"system\"}}\nYou are an expert software engineer in test and have capability to collaborate with user to generate a test plan.\nYou are given a task to provide a high level plan to create a test for a given scenario.\n\nYou will be provided with already added Playwright tests and page object object models which you can use generate the test plan.\nTest plan should be a list of bullet points and each bullet point representing each test step.\nYou will be provided with app knowledge which can help you groom the steps in the plan.\n\n{{#if humanLoopRequired}}\nDo NOT finish until you have a complete understanding of the plan and have all the minute details of how the test should look like.\n\nALWAYS VERIFY THE PLAN WITH USER BEFORE FINISHING. THE USER SHOULD BE ABLE TO REVIEW AND GIVE GO AHEAD TO THE PLAN.\n\nDO NOT FINISH UNTIL USER EXPLICITLY CONFIRMS THE PLAN IS GOOD TO GO.\n{{/if}}\n\n### Test Plan Creation Guidelines\n\n- **Create Subtasks:**\n  - Read the task step by step and create subtasks from the given task.\n  - Do not add any new steps that are not mentioned in the task.\n\n- **Enrich Subtasks:**\n  - Read the provided app knowledge.\n  - Enrich the subtasks based on the information from the app knowledge.\n\n- **Plan:**\n  - Once all subtasks are enriched, list them as bullet points.\n  - Each bullet point must start with one of the following actions:  \n    - Open page  \n    - Click on  \n    - Fill in  \n    - Assert  \n    - Hover on  \n    - Press  \n    - Extract textContent\n  - Do not include any bullet points that do not start with the above actions.\n\n- **Additional Notes:**\n  - The final output should only contain bullet points listing the test steps.\n  - Do not add any assertions that are not mentioned in the task or app knowledge.\n  - The plan should not reference the knowledge base used to generate it.\n\n{{/section}}\n\n{{#section \"user\"}}\n\nApp knowledge:\n{{appKnowledge}}\n\n-----\n\nCurrent tests and page object model references:\n{{fileContext}}\n\n------\n\nTask:\n{{task}}\n\n------\n{{/section}}";
+const env_1 = require("../../utils/env");
+async function planTask({ task, specPath, trace, }) {
+    let fileContext = "";
+    try {
+        const { pomPrompt, testFileContent } = await (0, context_1.contextForGeneration)(specPath);
+        fileContext = `
+${testFileContent}
+${pomPrompt}
+    `;
+    }
+    catch (e) {
+        console.warn("Failed to generate file context for planner", e);
+    }
+    const plannerSpan = trace?.span({
+        name: "planner",
+        input: {
+            task,
+        },
+    });
+    // if the code in running in ci worker or github actions, disable human loop
+    const humanLoopRequired = !(0, env_1.isRunningOnCloud)();
+    const appKnowledge = await (0, context_1.fetchAppKnowledge)();
+    const messages = (0, llm_1.compilePrompt)(promptTemplate_0, {
+        appKnowledge,
+        fileContext,
+        task,
+        humanLoopRequired,
+    });
+    const llm = new llm_1.LLM({
+        provider: "openai",
+        defaultModel: "gpt-4o",
+    });
+    let maxRetries = 10;
+    const tools = [
+        {
+            type: "function",
+            function: {
+                name: "finish",
+                description: "Final output of the conversation",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        plan: {
+                            type: "string",
+                            description: "Final plan which is verified by the user",
+                        },
+                    },
+                    required: ["plan"],
+                    additionalProperties: false,
+                },
+            },
+        },
+    ];
+    if (humanLoopRequired) {
+        tools.push({
+            type: "function",
+            function: {
+                name: "send_user_message",
+                description: "Send user message",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        message: {
+                            type: "string",
+                            description: "Message to be sent to the user for any confirmation or clarification",
+                        },
+                    },
+                    required: ["message"],
+                    additionalProperties: false,
+                },
+                strict: true,
+            },
+        });
+    }
+    while (maxRetries--) {
+        const response = await llm.createChatCompletion({
+            trace: plannerSpan,
+            traceName: "planner-llm",
+            messages,
+            tools,
+            modelParameters: {
+                temperature: 0.5,
+                tool_choice: "required",
+            },
+        });
+        const toolCall = response?.tool_calls?.[0];
+        const respStr = toolCall?.function.arguments;
+        const resp = JSON.parse(respStr || "{}");
+        // TODO: handle this as a part of actions handler
+        if (toolCall?.function.name === "send_user_message") {
+            const feedback = await human_in_the_loop_1.humanLoop.getFeedback({
+                message: resp.message,
+            });
+            messages.push(response);
+            messages.push({
+                role: "tool",
+                tool_call_id: toolCall?.id,
+                content: feedback,
+            });
+        }
+        else {
+            const plan = resp.plan;
+            plannerSpan?.end({
+                output: {
+                    plan,
+                },
+            });
+            return plan;
+        }
+    }
+    // TODO: handle planner failure scenario
+    plannerSpan?.end({
+        output: {
+            plan: "",
+            error: "Failed to generate test plan",
+        },
+    });
+    return "";
+}
+exports.planTask = planTask;

package/bundled/test-gen/agent/utils.d.ts

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

package/bundled/test-gen/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/bundled/test-gen/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 with args ${args}`, e);
+    }
+}
+exports.parseJson = parseJson;

package/bundled/test-gen/bin/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/bundled/test-gen/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":""}

package/bundled/test-gen/bin/index.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const llm_1 = require("@empiricalrun/llm");
+const commander_1 = require("commander");
+const dotenv_1 = __importDefault(require("dotenv"));
+const run_1 = require("../agent/browsing/run");
+const utils_1 = require("../agent/browsing/utils");
+const repo_edit_1 = require("../agent/codegen/repo-edit");
+const run_2 = require("../agent/codegen/run");
+const diagnosis_agent_1 = require("../agent/diagnosis-agent");
+const enrich_prompt_1 = require("../agent/enrich-prompt");
+const infer_agent_1 = require("../agent/infer-agent");
+const run_3 = require("../agent/planner/run");
+const reporter_1 = require("../reporter");
+const session_1 = require("../session");
+const test_build_1 = require("../test-build");
+const logger_1 = require("./logger");
+const utils_2 = require("./utils");
+const scenarios_1 = require("./utils/scenarios");
+dotenv_1.default.config({
+    path: [".env.local", ".env"],
+});
+const flushEvents = async () => {
+    await (0, llm_1.flushAllTraces)();
+};
+process.on("beforeExit", async () => await flushEvents());
+process.on("exit", async () => await flushEvents());
+process.on("SIGINT", async () => await flushEvents());
+process.on("SIGTERM", async () => await flushEvents());
+async function resolveAgentUsingTask({ testCase, trace, }) {
+    const { response } = await (0, infer_agent_1.inferAgentBasedTask)({
+        task: testCase.steps.join("\n"),
+        trace,
+    });
+    return response;
+}
+async function runAgent(testGenConfig, testGenToken) {
+    const logger = new logger_1.CustomLogger();
+    const { specPath, testCase } = testGenConfig;
+    if (process.env.LOG_URL) {
+        try {
+            void new reporter_1.TestGenUpdatesReporter().sendLogUrl(process.env.LOG_URL);
+        }
+        catch (e) {
+            console.warn("Failed to send log url to test gen update", e);
+        }
+    }
+    const session = (0, session_1.getSessionDetails)();
+    const trace = llm_1.langfuseInstance?.trace({
+        name: "generate-test",
+        id: crypto.randomUUID(),
+        release: session.version,
+        tags: [
+            testGenConfig.options?.metadata.projectName || "",
+            testGenConfig.options?.metadata.environment || "",
+        ].filter((s) => !!s),
+    });
+    if (await (0, session_1.shouldStopSession)()) {
+        return;
+    }
+    let agentFromConfig = testGenConfig.options?.agent;
+    let agent = agentFromConfig || "auto";
+    trace?.update({
+        metadata: {
+            generationId: session.generationId,
+            sessionId: session.sessionId,
+            testUrl: session.testUrl,
+        },
+    });
+    if (trace) {
+        try {
+            void new reporter_1.TestGenUpdatesReporter().sendAgentTraceUrl(trace.getTraceUrl());
+        }
+        catch (e) {
+            console.warn("Failed to send trace url as test gen update", e);
+        }
+    }
+    // assuming if there is no test case specific test name, we need to update the test case name
+    if (!testCase.name) {
+        logger.success(`Generating code for the provided task. ${process.env.LOG_URL ? `[view log](${process.env.LOG_URL})` : ""}`);
+        await (0, repo_edit_1.repoEditAgent)({
+            trace,
+            task: testGenConfig.testCase.steps.join("\n"),
+            logger,
+        });
+        return;
+    }
+    // TODO: this needs to be moved to an orchestrator which decides what needs to be done first before executing the sub tasks
+    if (testGenConfig.testErrorDiagnosis &&
+        testGenConfig.testErrorDiagnosis.failingLine &&
+        // TODO: fix this hardcoding of user prompt - ideally its an auto fix intent
+        testCase.steps[0]?.toLowerCase().trim() == "can you please fix the test") {
+        const { task: updatedTask } = await (0, diagnosis_agent_1.createTaskUsingFailureDiagnosis)({
+            options: testGenConfig.options,
+            trace,
+            diagnosis: testGenConfig.testErrorDiagnosis,
+        });
+        if (updatedTask) {
+            testCase.steps = [updatedTask];
+        }
+    }
+    if (!agent || agent === "auto") {
+        agent = await resolveAgentUsingTask({
+            testCase,
+            trace,
+        });
+    }
+    logger.success(`Generating test using ${agent} agent. ${process.env.LOG_URL ? `[view log](${process.env.LOG_URL})` : ""}`);
+    if (testGenConfig.testErrorDiagnosis &&
+        testGenConfig.testErrorDiagnosis.failingLine) {
+        const requestedChangeResp = await (0, enrich_prompt_1.enrichPromptWithFailingLine)({
+            trace,
+            testBlock: testGenConfig.testErrorDiagnosis.failingLine,
+            testFilePath: testGenConfig.testErrorDiagnosis.failingFile,
+            suggestionForFix: testCase.steps.join("\n"),
+        });
+        testCase.steps = [requestedChangeResp.output];
+    }
+    if (agent === "plan") {
+        const task = testCase.steps.join("\n");
+        const plan = await (0, run_3.planTask)({
+            task,
+            specPath,
+            trace,
+        });
+        new logger_1.CustomLogger({ useReporter: false }).log("Generated Plan:");
+        console.log(plan);
+        await new reporter_1.TestGenUpdatesReporter().sendMessage(plan);
+    }
+    else if (agent === "code") {
+        await (0, run_2.generateTest)(testCase, specPath, testGenConfig.options, trace);
+    }
+    else {
+        // this assumes we have only one scenario in test config
+        const filePathToUpdate = await (0, utils_1.prepareFileForMasterAgent)(testGenConfig, trace);
+        void (0, session_1.updateSessionStatus)(testGenConfig.options?.metadata.testSessionId, {
+            status: "agent_live_session_started",
+        });
+        await (0, run_1.generateTestsUsingMasterAgent)({
+            testFilePath: specPath,
+            filePathToUpdate,
+            pwProjectsFilter: testGenConfig.environment?.playwrightProjects,
+            testGenToken,
+            repoDir: process.cwd(),
+        });
+    }
+    return agent;
+}
+(async function main() {
+    const program = new commander_1.Command();
+    program
+        .option("--token <token>", "Test generation token")
+        .option("--name <test-name>", "Name of the test case")
+        .option("--prompt <prompt>", "Prompt for the test case")
+        .option("--file <test-file>", "File path of the test case (inside tests dir)")
+        .option("--suites <suites>", "Comma separated list of describe blocks")
+        .parse(process.argv);
+    const options = program.opts();
+    const completedOptions = await (0, utils_2.validateAndCompleteCliOptions)(options);
+    const testGenConfig = completedOptions.token
+        ? (0, scenarios_1.loadTestConfigs)(completedOptions.token)
+        : (0, scenarios_1.buildTestConfigFromOptions)(completedOptions);
+    const testGenToken = completedOptions.token
+        ? completedOptions.token
+        : (0, scenarios_1.buildTokenFromOptions)(completedOptions);
+    (0, reporter_1.setReporterConfig)({
+        projectRepoName: testGenConfig.options?.metadata.projectRepoName,
+        testSessionId: testGenConfig.options?.metadata.testSessionId,
+        generationId: testGenConfig.options?.metadata.generationId,
+    });
+    (0, session_1.setSessionDetails)({
+        testCaseId: testGenConfig.testCase.id,
+        sessionId: testGenConfig.options?.metadata.testSessionId,
+        generationId: testGenConfig.options?.metadata.generationId,
+        projectRepoName: testGenConfig.options?.metadata.projectRepoName,
+    });
+    let testGenFailed = false;
+    let agentUsed;
+    try {
+        // download the build if it exists
+        await (0, test_build_1.downloadBuild)(testGenConfig.build || {});
+        agentUsed = await runAgent(testGenConfig, testGenToken);
+    }
+    catch (e) {
+        testGenFailed = true;
+        new logger_1.CustomLogger().error(`Failed to generate test for the scenario. ${process.env.LOG_URL ? `[view log](${process.env.LOG_URL})` : ""}`, e?.message, e?.stack);
+    }
+    if (agentUsed &&
+        agentUsed !== "code" &&
+        agentUsed !== "plan" &&
+        testGenConfig.testCase.name &&
+        testGenConfig.options) {
+        await new reporter_1.TestGenUpdatesReporter().reportGenAssets({
+            projectRepoName: testGenConfig.options.metadata.projectRepoName,
+            testName: testGenConfig.testCase.name,
+        });
+    }
+    // TODO: move these reporters to a better lifecycle
+    await (0, llm_1.flushAllTraces)();
+    await (0, logger_1.waitForLogsToFlush)();
+    await (0, session_1.endSession)();
+    if (testGenFailed) {
+        process.exit(1);
+    }
+    else {
+        process.exit(0);
+    }
+})();

package/bundled/test-gen/bin/logger/index.d.ts

@@ -0,0 +1,14 @@
+export declare class CustomLogger {
+    private useReporter;
+    constructor({ useReporter }?: {
+        useReporter?: boolean | undefined;
+    });
+    private logToReporter;
+    log(message?: string, ...optionalParams: any[]): void;
+    warn(message?: string, ...optionalParams: any[]): void;
+    success(message?: string, ...optionalParams: any[]): void;
+    error(message?: string, ...optionalParams: any[]): void;
+    logEmptyLine(): void;
+}
+export declare function waitForLogsToFlush(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/bundled/test-gen/bin/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bin/logger/index.ts"],"names":[],"mappings":"AAOA,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAAkB;gBACzB,EAAE,WAAkB,EAAE;;KAAK;IAIvC,OAAO,CAAC,aAAa;IAYrB,GAAG,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE;IAK9C,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE;IAK/C,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE;IAKlD,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE;IAKhD,YAAY;CAGb;AAED,wBAAsB,kBAAkB,kBAWvC"}