donobu 2.46.1 → 2.46.3

package/dist/lib/testExtension.js

@@ -52,6 +52,7 @@ const GptApiKeysNotSetupException_1 = require("../exceptions/GptApiKeysNotSetupE
 const SmartSelector_1 = require("./SmartSelector");
 const PageAi_1 = require("./PageAi");
 const path_1 = require("path");
+const originalGotoRegistry_1 = require("./originalGotoRegistry");
 __exportStar(require("playwright/test"), exports);
 const PLACEHOLDER_FLOW_URL = 'https://example.com';
 /**
@@ -78,255 +79,15 @@ exports.test = test_1.test.extend({
     ],
     // Override the default page fixture
     page: async ({ page, gptClient, headless }, use, testInfo) => {
-        page._initialBrowserState = await getBrowserState(page, testInfo);
-        gptClient = await buttonUpGptClient(gptClient);
-        const donobu = await (0, donobuTestStack_1.getOrCreateDonobuStack)();
-        const persistenceLayer = await donobu.flowsPersistenceFactory.createPersistenceLayer();
         await PlaywrightUtils_1.PlaywrightUtils.setupBasicBrowserContext(page.context());
-        // Save the oringal goto method since we override it later. We need the
-        // original so we can delegate to it in our override.
-        page._originalGoto = page.goto;
-        page.ai = async (instruction, options) => {
-            if (!gptClient) {
-                throw new Error(`No AI connection available. Establish a connection by setting an API key via an environment variable.
-Valid options:
-  - ${envVars_1.ENV_NAMES.ANTHROPIC_API_KEY}
-  - ${envVars_1.ENV_NAMES.GOOGLE_GENERATIVE_AI_API_KEY}
-  - ${envVars_1.ENV_NAMES.OPENAI_API_KEY}`);
-            }
-            else {
-                const cacheFilepath = (0, path_1.join)((0, path_1.dirname)(testInfo.file), 'donobu.json');
-                const pageAi = new PageAi_1.PageAi(donobu, persistenceLayer, gptClient, cacheFilepath);
-                const revisedOptions = {
-                    envVars: page._donobuFlowMetadata.envVars ?? [],
-                    ...(options ? options : {}),
-                };
-                if (testInfo.retry > 0 && isSelfHealingEnabled(testInfo)) {
-                    // Blow the cache so that when we are self-healing the `page.ai` call
-                    // will use a new autonomous flow.
-                    await pageAi.deleteCachedFlow(page, instruction, revisedOptions);
-                }
-                return pageAi.ai(page, instruction, revisedOptions);
-            }
-        };
-        page.find = (selector, options) => {
-            return new SmartSelector_1.SmartSelectorImpl(page, {
-                element: [selector, ...(options?.failover ?? [])],
-                frame: options?.frame,
-            });
-        };
-        // Intercept 'page.goto' so that Donobu can later re-run it as a standard
-        // Donobu action if necessary. This can happen if you run a Playwright
-        // test using npx, but later decide to rerun that run using the Donobu UI.
-        page.goto = async (url, options) => {
-            const startedAt = new Date().getTime();
-            const flowId = page._donobuFlowMetadata.id;
-            // Update the target website to whatever the first place we are
-            // navigating to is.
-            if (page._donobuFlowMetadata.targetWebsite === PLACEHOLDER_FLOW_URL) {
-                page._donobuFlowMetadata = {
-                    ...page._donobuFlowMetadata,
-                    targetWebsite: url,
-                };
-                await persistenceLayer.setFlowMetadata(page._donobuFlowMetadata);
-            }
-            try {
-                const resp = await page._originalGoto.call(page, url, options);
-                const pageTitle = await page.title();
-                const postCallImage = await PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(page);
-                const postCallImageId = await persistenceLayer.saveScreenShot(flowId, postCallImage);
-                const completedAt = new Date().getTime();
-                await persistenceLayer.saveToolCall(flowId, {
-                    id: MiscUtils_1.MiscUtils.createAdHocToolCallId(),
-                    toolName: GoToWebpageTool_1.GoToWebpageTool.NAME,
-                    parameters: {
-                        url: url,
-                    },
-                    outcome: {
-                        isSuccessful: true,
-                        forLlm: `Successfully navigated to ${url}`,
-                        metadata: {
-                            pageTitle: pageTitle,
-                            resolvedUrl: page.url(),
-                        },
-                    },
-                    postCallImageId: postCallImageId,
-                    page: url,
-                    startedAt: startedAt,
-                    completedAt: completedAt,
-                });
-                return resp;
-            }
-            catch (error) {
-                const postCallImage = await PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(page);
-                const postCallImageId = await persistenceLayer.saveScreenShot(flowId, postCallImage);
-                const completedAt = new Date().getTime();
-                await persistenceLayer.saveToolCall(flowId, {
-                    id: MiscUtils_1.MiscUtils.createAdHocToolCallId(),
-                    toolName: GoToWebpageTool_1.GoToWebpageTool.NAME,
-                    parameters: {
-                        url: url,
-                    },
-                    outcome: {
-                        isSuccessful: false,
-                        forLlm: `FAILED! ${typeof error}: ${error.message}`,
-                        metadata: null,
-                    },
-                    postCallImageId: postCallImageId,
-                    page: url,
-                    startedAt: startedAt,
-                    completedAt: completedAt,
-                });
-                // Mark test as failed for later callback
-                testInfo.status = 'failed';
-                throw error;
-            }
-        };
-        page.run = async (toolName, toolParams, gptClientOverride) => {
-            let finalGptClient = null;
-            if (gptClientOverride) {
-                if (!(gptClientOverride instanceof GptClient_1.GptClient)) {
-                    finalGptClient = new VercelAiGptClient_1.VercelAiGptClient(gptClientOverride);
-                }
-                else {
-                    finalGptClient = gptClientOverride;
-                }
-            }
-            else if (gptClient) {
-                finalGptClient = gptClient;
-            }
-            const pageInspector = new PageInspector_1.PageInspector();
-            const controlPanel = new ControlPanel_1.NoOpControlPanel();
-            const clonedParams = toolParams
-                ? JSON.parse(JSON.stringify(toolParams))
-                : {};
-            clonedParams.rationale || (clonedParams.rationale = '');
-            const envData = await donobu.flowsManager.buildEnvData(page._donobuFlowMetadata.envVars ?? []);
-            const toolCallContext = {
-                flowsManager: donobu.flowsManager,
-                envData: envData,
-                pageInspector: pageInspector,
-                controlPanel: controlPanel,
-                persistence: persistenceLayer,
-                gptClient: finalGptClient,
-                interactionVisualizer: new InteractionVisualizer_1.InteractionVisualizer(0),
-                proposedToolCalls: [],
-                invokedToolCalls: [],
-                page: { current: page },
-                metadata: page._donobuFlowMetadata,
-                toolCallId: clonedParams.toolCallId ?? MiscUtils_1.MiscUtils.createAdHocToolCallId(),
-            };
-            try {
-                const tools = await ToolManager_1.ToolManager.allTools();
-                const result = await new ToolManager_1.ToolManager(tools).invokeTool(toolCallContext, toolName, clonedParams, false);
-                // Check if tool execution was successful
-                if (!result.outcome.isSuccessful) {
-                    throw new Error(`${toolName} execution failed: ${JSON.stringify(result, null, 2)}`);
-                }
-                return result.outcome;
-            }
-            catch (error) {
-                // Mark test as failed if an exception occurs during tool execution
-                testInfo.status = 'failed';
-                throw error;
-            }
-        };
-        page.analyzePageText = async (params, gptClientOverride) => {
-            return page.run(AnalyzePageTextTool_1.AnalyzePageTextTool.NAME, params, gptClientOverride);
-        };
-        page.assertPageText = async (params, gptClientOverride) => {
-            return page.run(AssertPageTextTool_1.AssertPageTextTool.NAME, params, gptClientOverride);
-        };
-        page.changeTab = async (url) => {
-            // The underlying tool call is mostly performative. We do it so we can
-            // record the operation occurred, but the actual page reassignment happens
-            // at the call site of this function.
-            const result = await page.run(ChangeWebBrowserTabTool_1.ChangeWebBrowserTabTool.NAME, {
-                tabUrl: url,
-            });
-            if (result.isSuccessful) {
-                // We need to return a real Page object, not just the raw URL, so we
-                // loop through the pages of the current context, knowing we will find
-                // a match.
-                return page
-                    .context()
-                    .pages()
-                    .find((tab) => tab.url() === url);
-            }
-            else {
-                throw Error(result.forLlm);
-            }
-        };
-        page.chooseSelectOption = async (params) => {
-            return page.run(ChooseSelectOptionTool_1.ChooseSelectOptionTool.NAME, params);
-        };
-        page.clickElement = async (params) => {
-            return page.run(ClickTool_1.ClickTool.NAME, params);
-        };
-        page.createCookieReport = async (gptClientOverride) => {
-            return page.run(CreateBrowserCookieReportTool_1.CreateBrowserCookieReportTool.NAME, {}, gptClientOverride);
-        };
-        page.extract = async (params, gptClientOverride) => {
-            let finalGptClient = null;
-            if (gptClientOverride) {
-                if (!(gptClientOverride instanceof GptClient_1.GptClient)) {
-                    finalGptClient = new VercelAiGptClient_1.VercelAiGptClient(gptClientOverride);
-                }
-                else {
-                    finalGptClient = gptClientOverride;
-                }
-            }
-            else if (gptClient) {
-                finalGptClient = gptClient;
-            }
-            if (!finalGptClient) {
-                testInfo.status = 'failed';
-                throw Error('Cannot extract an object from page without a GPT client set up!');
-            }
-            try {
-                const toolCallHistory = await persistenceLayer.getToolCalls(page._donobuFlowMetadata.id);
-                const structuredOutputMessage = await (0, DonobuFlow_1.extractFromPage)(params.instruction ??
-                    'Generate an object conforming to the given JSON-schema', params.schema, page, toolCallHistory, finalGptClient);
-                page._donobuFlowMetadata.resultJsonSchema = v4_1.z.toJSONSchema(params.schema);
-                page._donobuFlowMetadata.result = JSON.parse(JSON.stringify(structuredOutputMessage.output));
-                await persistenceLayer.setFlowMetadata(page._donobuFlowMetadata);
-                return structuredOutputMessage.output;
-            }
-            catch (error) {
-                testInfo.status = 'failed';
-                throw error;
-            }
-        };
-        page.hoverOverElement = async (params) => {
-            return page.run(HoverOverElementTool_1.HoverOverElementTool.NAME, params);
-        };
-        page.inputRandomizedEmailAddress = async (params) => {
-            return page.run(InputRandomizedEmailAddressTool_1.InputRandomizedEmailAddressTool.NAME, params);
-        };
-        page.inputText = async (params) => {
-            return page.run(InputTextTool_1.InputTextTool.NAME, params);
-        };
-        page.pressKey = async (params) => {
-            return page.run(PressKeyTool_1.PressKeyTool.NAME, params);
-        };
-        page.runAccessibilityTest = async () => {
-            return page.run(RunAccessibilityTestTool_1.RunAccessibilityTestTool.NAME);
-        };
-        page.scroll = async (params) => {
-            return page.run(ScrollPageTool_1.ScrollPageTool.NAME, params);
-        };
-        page.visuallyAssert = async (params, gptClientOverride) => {
-            return page.run(AssertTool_1.AssertTool.NAME, params, gptClientOverride);
-        };
-        try {
-            const overallObjective = testInfo.annotations.find((v) => {
-                return v.type === 'objective';
-            })?.description ?? null;
-            // Get the implied allowed environment variables by inspecting the objective.
-            const allowedEnvVarsByName = DonobuFlowsManager_1.DonobuFlowsManager.distillAllowedEnvVariableNames(overallObjective, testInfo.annotations
-                .filter((a) => a.type == 'ENV' && a.description)
-                .map((a) => a.description));
-            const donobuTestFlowMetadata = {
+        const overallObjective = testInfo.annotations.find((v) => v.type === 'objective')?.description ??
+            null;
+        const donobuStack = await (0, donobuTestStack_1.getOrCreateDonobuStack)();
+        const persistence = await donobuStack.flowsPersistenceFactory.createPersistenceLayer();
+        const initialBrowserState = await getBrowserState(page, testInfo);
+        const resolvedGptClient = await buttonUpGptClient(gptClient);
+        const sharedState = {
+            donobuFlowMetadata: {
                 id: (0, uuid_1.v4)(),
                 name: testInfo.title,
                 createdWithDonobuVersion: MiscUtils_1.MiscUtils.DONOBU_VERSION,
@@ -338,7 +99,9 @@ Valid options:
                         headless: headless,
                     },
                 },
-                envVars: allowedEnvVarsByName,
+                envVars: DonobuFlowsManager_1.DonobuFlowsManager.distillAllowedEnvVariableNames(overallObjective, testInfo.annotations
+                    .filter((a) => a.type == 'ENV' && a.description)
+                    .map((a) => a.description)),
                 gptConfigName: null,
                 hasGptConfigNameOverride: false,
                 customTools: null,
@@ -358,54 +121,48 @@ Valid options:
                 completedAt: null,
                 state: 'RUNNING_ACTION',
                 nextState: null,
-            };
-            await persistenceLayer.setFlowMetadata(donobuTestFlowMetadata);
-            page._donobuFlowMetadata = donobuTestFlowMetadata;
-            // Let Playwright continue and give tests the patched page.
-            await use(page);
+            },
+            donobuStack: donobuStack,
+            pageAi: undefined,
+            persistence: persistence,
+            initialBrowserState: initialBrowserState,
+            gptClient: resolvedGptClient,
+        };
+        const extend = createDonobuPageExtender(sharedState, testInfo);
+        const extendedPage = extend(page);
+        try {
+            await sharedState.persistence.setFlowMetadata(sharedState.donobuFlowMetadata);
+            await use(extendedPage);
         }
         catch (error) {
-            // Mark test as failed if an uncaught exception occurs during the test
             testInfo.status = 'failed';
             throw error;
         }
         finally {
             try {
-                if (page._donobuFlowMetadata) {
-                    // Update metadata with final status.
-                    page._donobuFlowMetadata.state =
-                        testInfo.status === 'failed' || testInfo.status === 'timedOut'
-                            ? 'FAILED'
-                            : 'SUCCESS';
-                    page._donobuFlowMetadata.completedAt = new Date().getTime();
-                    await persistenceLayer.setFlowMetadata(page._donobuFlowMetadata);
-                    await testInfo.attach('test-flow-metadata.json', {
-                        body: JSON.stringify(page._donobuFlowMetadata, null, 2),
-                        contentType: 'application/json',
-                    });
-                    // Persist the final browser state.
-                    const browserState = await BrowserUtils_1.BrowserUtils.getBrowserStorageState(page.context());
-                    await persistenceLayer.setBrowserState(page._donobuFlowMetadata.id, browserState);
-                }
+                sharedState.donobuFlowMetadata.state =
+                    testInfo.status === 'failed' || testInfo.status === 'timedOut'
+                        ? 'FAILED'
+                        : 'SUCCESS';
+                sharedState.donobuFlowMetadata.completedAt = new Date().getTime();
+                await sharedState.persistence.setFlowMetadata(sharedState.donobuFlowMetadata);
+                await testInfo.attach('test-flow-metadata.json', {
+                    body: JSON.stringify(sharedState.donobuFlowMetadata, null, 2),
+                    contentType: 'application/json',
+                });
+                const browserState = await BrowserUtils_1.BrowserUtils.getBrowserStorageState(extendedPage.context());
+                await sharedState.persistence.setBrowserState(sharedState.donobuFlowMetadata.id, browserState);
             }
             catch (error) {
-                // Log but don't throw, to ensure cleanup continues.
                 Logger_1.appLogger.error('Error during test cleanup:', error);
             }
-            // Only attempt wholesale test-file-level self-healing for a fail test if
-            // we are working with legacy tests (i.e. use an overallObjective).
-            if (testInfo.status === 'failed' &&
-                page._donobuFlowMetadata.overallObjective !== null &&
-                isSelfHealingEnabled(testInfo)) {
-                if (!page._donobuFlowMetadata) {
-                    Logger_1.appLogger.error('Will not self-heal due to no Donobu metadata being found.');
-                }
-                else if (!gptClient) {
+            if (testInfo.status === 'failed' && isSelfHealingEnabled(testInfo)) {
+                if (!sharedState.gptClient) {
                     Logger_1.appLogger.warn('Will not self-heal due to no GPT client being set up.');
                 }
                 else {
                     try {
-                        await (0, selfHealing_1.selfHeal)(gptClient, testInfo, page);
+                        await (0, selfHealing_1.selfHeal)(sharedState.gptClient, testInfo, extendedPage);
                     }
                     catch (selfHealError) {
                         Logger_1.appLogger.error('Error when attempting to self heal:', selfHealError);
@@ -415,6 +172,251 @@ Valid options:
         }
     },
 });
+function createDonobuPageExtender(sharedState, testInfo) {
+    const extend = (target) => {
+        if (!(0, originalGotoRegistry_1.hasOriginalGoto)(target)) {
+            (0, originalGotoRegistry_1.registerOriginalGoto)(target, target.goto);
+        }
+        const extended = target;
+        extended._dnb = sharedState;
+        attachDonobuMethods(extended, sharedState, testInfo, extend);
+        return extended;
+    };
+    return extend;
+}
+function attachDonobuMethods(page, sharedState, testInfo, extend) {
+    page.ai = async (instruction, options, gptClientOverride) => {
+        let finalGptClient = null;
+        if (gptClientOverride) {
+            if (!(gptClientOverride instanceof GptClient_1.GptClient)) {
+                finalGptClient = new VercelAiGptClient_1.VercelAiGptClient(gptClientOverride);
+            }
+            else {
+                finalGptClient = gptClientOverride;
+            }
+        }
+        else if (sharedState.gptClient) {
+            finalGptClient = sharedState.gptClient;
+        }
+        if (!finalGptClient) {
+            throw new Error(`No AI connection available. Establish a connection by setting an API key via an environment variable.
+Valid options:
+  - ${envVars_1.ENV_NAMES.ANTHROPIC_API_KEY}
+  - ${envVars_1.ENV_NAMES.GOOGLE_GENERATIVE_AI_API_KEY}
+  - ${envVars_1.ENV_NAMES.OPENAI_API_KEY}`);
+        }
+        if (!sharedState.pageAi) {
+            const cacheFilepath = (0, path_1.join)((0, path_1.dirname)(testInfo.file), 'donobu.json');
+            sharedState.pageAi = PageAi_1.PageAi.withFileCache(sharedState.donobuStack, sharedState.persistence, finalGptClient, cacheFilepath);
+        }
+        const revisedOptions = {
+            envVars: sharedState.donobuFlowMetadata.envVars ?? [],
+            ...(options ? options : {}),
+        };
+        if (testInfo.retry > 0) {
+            await sharedState.pageAi.invalidate(page, instruction, revisedOptions);
+        }
+        return sharedState.pageAi.ai(page, instruction, revisedOptions);
+    };
+    page.find = (selector, options) => {
+        return new SmartSelector_1.SmartSelectorImpl(page, {
+            element: [selector, ...(options?.failover ?? [])],
+            frame: options?.frame,
+        });
+    };
+    page.goto = async (url, options) => {
+        const startedAt = new Date().getTime();
+        const flowId = sharedState.donobuFlowMetadata.id;
+        if (sharedState.donobuFlowMetadata.targetWebsite === PLACEHOLDER_FLOW_URL) {
+            sharedState.donobuFlowMetadata = {
+                ...sharedState.donobuFlowMetadata,
+                targetWebsite: url,
+            };
+            await sharedState.persistence.setFlowMetadata(sharedState.donobuFlowMetadata);
+        }
+        try {
+            const originalGoto = (0, originalGotoRegistry_1.getOriginalGoto)(page);
+            const resp = await originalGoto.call(page, url, options);
+            const pageTitle = await page.title();
+            const postCallImage = await PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(page);
+            const postCallImageId = await sharedState.persistence.saveScreenShot(flowId, postCallImage);
+            const completedAt = new Date().getTime();
+            await sharedState.persistence.saveToolCall(flowId, {
+                id: MiscUtils_1.MiscUtils.createAdHocToolCallId(),
+                toolName: GoToWebpageTool_1.GoToWebpageTool.NAME,
+                parameters: {
+                    url: url,
+                },
+                outcome: {
+                    isSuccessful: true,
+                    forLlm: `Successfully navigated to ${url}`,
+                    metadata: {
+                        pageTitle: pageTitle,
+                        resolvedUrl: page.url(),
+                    },
+                },
+                postCallImageId: postCallImageId,
+                page: url,
+                startedAt: startedAt,
+                completedAt: completedAt,
+            });
+            return resp;
+        }
+        catch (error) {
+            const postCallImage = await PlaywrightUtils_1.PlaywrightUtils.takeViewportScreenshot(page);
+            const postCallImageId = await sharedState.persistence.saveScreenShot(flowId, postCallImage);
+            const completedAt = new Date().getTime();
+            await sharedState.persistence.saveToolCall(flowId, {
+                id: MiscUtils_1.MiscUtils.createAdHocToolCallId(),
+                toolName: GoToWebpageTool_1.GoToWebpageTool.NAME,
+                parameters: {
+                    url: url,
+                },
+                outcome: {
+                    isSuccessful: false,
+                    forLlm: `FAILED! ${typeof error}: ${error.message}`,
+                    metadata: null,
+                },
+                postCallImageId: postCallImageId,
+                page: url,
+                startedAt: startedAt,
+                completedAt: completedAt,
+            });
+            testInfo.status = 'failed';
+            throw error;
+        }
+    };
+    page.run = async (toolName, toolParams, gptClientOverride) => {
+        let finalGptClient = null;
+        if (gptClientOverride) {
+            if (!(gptClientOverride instanceof GptClient_1.GptClient)) {
+                finalGptClient = new VercelAiGptClient_1.VercelAiGptClient(gptClientOverride);
+            }
+            else {
+                finalGptClient = gptClientOverride;
+            }
+        }
+        else if (sharedState.gptClient) {
+            finalGptClient = sharedState.gptClient;
+        }
+        const pageInspector = new PageInspector_1.PageInspector();
+        const controlPanel = new ControlPanel_1.NoOpControlPanel();
+        const clonedParams = toolParams
+            ? JSON.parse(JSON.stringify(toolParams))
+            : {};
+        clonedParams.rationale || (clonedParams.rationale = '');
+        const envData = await sharedState.donobuStack.flowsManager.buildEnvData(sharedState.donobuFlowMetadata.envVars ?? []);
+        const toolCallContext = {
+            flowsManager: sharedState.donobuStack.flowsManager,
+            envData: envData,
+            pageInspector: pageInspector,
+            controlPanel: controlPanel,
+            persistence: sharedState.persistence,
+            gptClient: finalGptClient,
+            interactionVisualizer: new InteractionVisualizer_1.InteractionVisualizer(0),
+            proposedToolCalls: [],
+            invokedToolCalls: [],
+            page: { current: page },
+            metadata: sharedState.donobuFlowMetadata,
+            toolCallId: clonedParams.toolCallId ?? MiscUtils_1.MiscUtils.createAdHocToolCallId(),
+        };
+        try {
+            const tools = await ToolManager_1.ToolManager.allTools();
+            const result = await new ToolManager_1.ToolManager(tools).invokeTool(toolCallContext, toolName, clonedParams, false);
+            if (!result.outcome.isSuccessful) {
+                throw new Error(`${toolName} execution failed: ${JSON.stringify(result, null, 2)}`);
+            }
+            return result.outcome;
+        }
+        catch (error) {
+            testInfo.status = 'failed';
+            throw error;
+        }
+    };
+    page.analyzePageText = async (params, gptClientOverride) => {
+        return page.run(AnalyzePageTextTool_1.AnalyzePageTextTool.NAME, params, gptClientOverride);
+    };
+    page.assertPageText = async (params, gptClientOverride) => {
+        return page.run(AssertPageTextTool_1.AssertPageTextTool.NAME, params, gptClientOverride);
+    };
+    page.changeTab = async (url) => {
+        const result = await page.run(ChangeWebBrowserTabTool_1.ChangeWebBrowserTabTool.NAME, {
+            tabUrl: url,
+        });
+        if (result.isSuccessful) {
+            const matchingPage = page
+                .context()
+                .pages()
+                .find((tab) => tab.url() === url);
+            if (!matchingPage) {
+                throw new Error(`Unable to locate tab with URL ${url} after switching.`);
+            }
+            return extend(matchingPage);
+        }
+        throw Error(result.forLlm);
+    };
+    page.chooseSelectOption = async (params) => {
+        return page.run(ChooseSelectOptionTool_1.ChooseSelectOptionTool.NAME, params);
+    };
+    page.clickElement = async (params) => {
+        return page.run(ClickTool_1.ClickTool.NAME, params);
+    };
+    page.createCookieReport = async (gptClientOverride) => {
+        return page.run(CreateBrowserCookieReportTool_1.CreateBrowserCookieReportTool.NAME, {}, gptClientOverride);
+    };
+    page.extract = async (params, gptClientOverride) => {
+        let finalGptClient = null;
+        if (gptClientOverride) {
+            if (!(gptClientOverride instanceof GptClient_1.GptClient)) {
+                finalGptClient = new VercelAiGptClient_1.VercelAiGptClient(gptClientOverride);
+            }
+            else {
+                finalGptClient = gptClientOverride;
+            }
+        }
+        else if (sharedState.gptClient) {
+            finalGptClient = sharedState.gptClient;
+        }
+        if (!finalGptClient) {
+            testInfo.status = 'failed';
+            throw Error('Cannot extract an object from page without a GPT client set up!');
+        }
+        try {
+            const toolCallHistory = await sharedState.persistence.getToolCalls(sharedState.donobuFlowMetadata.id);
+            const structuredOutputMessage = await (0, DonobuFlow_1.extractFromPage)(params.instruction ??
+                'Generate an object conforming to the given JSON-schema', params.schema, page, toolCallHistory, finalGptClient);
+            sharedState.donobuFlowMetadata.resultJsonSchema = v4_1.z.toJSONSchema(params.schema);
+            sharedState.donobuFlowMetadata.result = JSON.parse(JSON.stringify(structuredOutputMessage.output));
+            await sharedState.persistence.setFlowMetadata(sharedState.donobuFlowMetadata);
+            return structuredOutputMessage.output;
+        }
+        catch (error) {
+            testInfo.status = 'failed';
+            throw error;
+        }
+    };
+    page.hoverOverElement = async (params) => {
+        return page.run(HoverOverElementTool_1.HoverOverElementTool.NAME, params);
+    };
+    page.inputRandomizedEmailAddress = async (params) => {
+        return page.run(InputRandomizedEmailAddressTool_1.InputRandomizedEmailAddressTool.NAME, params);
+    };
+    page.inputText = async (params) => {
+        return page.run(InputTextTool_1.InputTextTool.NAME, params);
+    };
+    page.pressKey = async (params) => {
+        return page.run(PressKeyTool_1.PressKeyTool.NAME, params);
+    };
+    page.runAccessibilityTest = async () => {
+        return page.run(RunAccessibilityTestTool_1.RunAccessibilityTestTool.NAME);
+    };
+    page.scroll = async (params) => {
+        return page.run(ScrollPageTool_1.ScrollPageTool.NAME, params);
+    };
+    page.visuallyAssert = async (params, gptClientOverride) => {
+        return page.run(AssertTool_1.AssertTool.NAME, params, gptClientOverride);
+    };
+}
 function isSelfHealingEnabled(testInfo) {
     if (envVars_1.ENV_NAMES.SELF_HEAL_TESTS_ENABLED in testInfo.project.metadata) {
         // Check project-specific metadata. This takes priority if it exists.