donobu 2.23.0 → 2.23.2

package/dist/playwrightTestExtensions.js

@@ -1,688 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.test = void 0;
-exports.getOrCreateDonobuStack = getOrCreateDonobuStack;
-exports.getOrCreateDefaultGptClient = getOrCreateDefaultGptClient;
-exports.getBrowserStorageState = getBrowserStorageState;
-exports.getBrowserStorageStateFixture = getBrowserStorageStateFixture;
-exports.anthropicClient = anthropicClient;
-exports.anthropicClientFixture = anthropicClientFixture;
-exports.anthropicAwsBedrockClient = anthropicAwsBedrockClient;
-exports.anthropicAwsBedrockClientFixture = anthropicAwsBedrockClientFixture;
-exports.googleGeminiClient = googleGeminiClient;
-exports.googleGeminiClientFixture = googleGeminiClientFixture;
-exports.openAiClient = openAiClient;
-exports.openAiClientFixture = openAiClientFixture;
-exports.vercelAiClientFixture = vercelAiClientFixture;
-exports.createGptClient = createGptClient;
-exports.gptClientFixture = gptClientFixture;
-/**
- * This code extends the Playwright Page object and test fixture with
- * test-related Donobu methods.
- */
-const uuid_1 = require("uuid");
-const test_1 = require("@playwright/test");
-const RequestContextHolder_1 = require("./managers/RequestContextHolder");
-const ToolManager_1 = require("./managers/ToolManager");
-const InteractionVisualizer_1 = require("./managers/InteractionVisualizer");
-const PlaywrightUtils_1 = require("./utils/PlaywrightUtils");
-const MiscUtils_1 = require("./utils/MiscUtils");
-const DonobuDeploymentEnvironment_1 = require("./models/DonobuDeploymentEnvironment");
-const AnalyzePageTextTool_1 = require("./tools/AnalyzePageTextTool");
-const AssertTool_1 = require("./tools/AssertTool");
-const GptClient_1 = require("./clients/GptClient");
-const ChooseSelectOptionTool_1 = require("./tools/ChooseSelectOptionTool");
-const InputRandomizedEmailAddressTool_1 = require("./tools/InputRandomizedEmailAddressTool");
-const InputTextTool_1 = require("./tools/InputTextTool");
-const PressKeyTool_1 = require("./tools/PressKeyTool");
-const ScrollPageTool_1 = require("./tools/ScrollPageTool");
-const HoverOverElementTool_1 = require("./tools/HoverOverElementTool");
-const GptClientFactory_1 = require("./clients/GptClientFactory");
-const ClickTool_1 = require("./tools/ClickTool");
-const VercelAiGptClient_1 = require("./clients/VercelAiGptClient");
-const AssertPageTextTool_1 = require("./tools/AssertPageTextTool");
-const GoToWebpageTool_1 = require("./tools/GoToWebpageTool");
-const DonobuStack_1 = require("./managers/DonobuStack");
-const DonobuFlow_1 = require("./managers/DonobuFlow");
-const Logger_1 = require("./utils/Logger");
-const envVars_1 = require("./envVars");
-const TestFileUpdater_1 = require("./managers/TestFileUpdater");
-const PageInspector_1 = require("./managers/PageInspector");
-const ChangeWebBrowserTabTool_1 = require("./tools/ChangeWebBrowserTabTool");
-const CreateBrowserCookieReportTool_1 = require("./tools/CreateBrowserCookieReportTool");
-const RunAccessibilityTestTool_1 = require("./tools/RunAccessibilityTestTool");
-const ControlPanel_1 = require("./managers/ControlPanel");
-const EnvPersistenceVolatile_1 = require("./persistence/env/EnvPersistenceVolatile");
-const DonobuFlowsManager_1 = require("./managers/DonobuFlowsManager");
-const PLACEHOLDER_FLOW_URL = 'https://example.com';
-const DEFAULT_GPT_MODEL_FOR_PLATFORM = {
-    ANTHROPIC: process.env[envVars_1.ENV_VAR_NAMES.ANTHROPIC_MODEL_NAME] ||
-        'claude-3-5-sonnet-latest',
-    ANTHROPIC_AWS_BEDROCK: process.env[envVars_1.ENV_VAR_NAMES.AWS_BEDROCK_MODEL_NAME] ||
-        // TODO: This value needs to be updated.
-        undefined,
-    GOOGLE_GEMINI: process.env[envVars_1.ENV_VAR_NAMES.GOOGLE_GENERATIVE_AI_MODEL_NAME] ||
-        'gemini-2.0-flash',
-    OPENAI: process.env[envVars_1.ENV_VAR_NAMES.OPENAI_API_MODEL_NAME] || 'gpt-4o',
-};
-let donobuStack = undefined;
-let defaultGptClient = undefined;
-/**
- * Self-heals a test that has failed by creating and running a new autonomous
- * flow using the same objective of the failed test. If the new flow is
- * successful, it uses the TestFileUpdater to update the specific failed test case
- * in the original test file.
- *
- * @param testInfo The test information object that contains the failed test's
- *                 annotations and other metadata.
- * @param donobuFlowMetadata The metadata of the flow that is being self-healed.
- */
-async function selfHeal(gptClient, testInfo, donobuFlowMetadata) {
-    if (!donobuFlowMetadata || !donobuFlowMetadata.overallObjective) {
-        // We cannot self-heal without an flow metadata or objective.
-        Logger_1.appLogger.warn('Will not self-heal due to no test flow metadata and/or objective being provided.');
-        return;
-    }
-    try {
-        const donobu = await getOrCreateDonobuStack();
-        const selfHealTimeoutMs = 300000; // 5 minutes
-        testInfo.setTimeout(testInfo.timeout + selfHealTimeoutMs);
-        Logger_1.appLogger.info(`Extending the test timeout ${selfHealTimeoutMs}ms for self-healing...`);
-        Logger_1.appLogger.info('Attempting to self-heal by creating a new autonomous flow...');
-        const newFlow = await donobu.flowsManager.createFlow({
-            targetWebsite: donobuFlowMetadata.targetWebsite,
-            overallObjective: donobuFlowMetadata.overallObjective,
-            name: donobuFlowMetadata.name ?? undefined,
-            browser: donobuFlowMetadata.browser,
-            envVars: donobuFlowMetadata.envVars ?? undefined,
-            callbackUrl: undefined,
-            customTools: donobuFlowMetadata.customTools ?? undefined,
-            maxIterations: 25,
-            gptConfigNameOverride: undefined,
-            defaultMessageDuration: undefined,
-            initialRunMode: 'AUTONOMOUS',
-            isControlPanelEnabled: false,
-            allowedTools: undefined,
-            toolCallsOnStart: undefined,
-            resultJsonSchema: undefined,
-        }, gptClient);
-        Logger_1.appLogger.info('Running the new autonomous flow...');
-        await newFlow.job;
-        if (newFlow.donobuFlow.metadata.state === 'SUCCESS') {
-            Logger_1.appLogger.info('Self-heal succeeded! The new autonomous flow completed successfully. Generating revised test...');
-            const newTestCode = await donobu.flowsManager.getFlowAsPlaywrightScript(newFlow.donobuFlow.metadata.id);
-            // Save the fixed test as an attachment
-            await testInfo.attach('fixed-test.ts', {
-                body: newTestCode,
-                contentType: 'application/typescript',
-            });
-            testInfo.annotations.push({
-                type: 'self-healed',
-            });
-            // Get the failed test file path
-            const testFilePath = testInfo.file;
-            if (testFilePath) {
-                try {
-                    Logger_1.appLogger.info(`Updating test file: ${testFilePath}`);
-                    const updateSuccess = await TestFileUpdater_1.TestFileUpdater.updateTestCase(testFilePath, testInfo.title, newTestCode);
-                    if (updateSuccess) {
-                        Logger_1.appLogger.info(`Successfully updated test file with fixed test code.`);
-                    }
-                    else {
-                        Logger_1.appLogger.warn(`Test file update did not complete successfully.`);
-                    }
-                }
-                catch (fileUpdateError) {
-                    Logger_1.appLogger.error(`Error updating test file ${testFilePath}:`, fileUpdateError);
-                }
-            }
-            else {
-                Logger_1.appLogger.warn('Could not update test file: test file path is not available.');
-            }
-        }
-        else {
-            Logger_1.appLogger.error('Self-heal failed! The new autonomous flow did not complete successfully.');
-        }
-    }
-    catch (error) {
-        Logger_1.appLogger.error('Error creating new flow when attempting to self heal:', error);
-        return;
-    }
-}
-/**
- * Creates a snapshot of process.env as a Record<string, string>
- */
-function getEnvSnapshot() {
-    const envRecord = {};
-    Object.entries(process.env).forEach(([key, value]) => {
-        if (value !== undefined) {
-            envRecord[key] = value;
-        }
-    });
-    return envRecord;
-}
-async function getOrCreateDonobuStack() {
-    if (!donobuStack) {
-        donobuStack = await (0, DonobuStack_1.setupDonobuStack)(DonobuDeploymentEnvironment_1.DonobuDeploymentEnvironment.LOCAL, new RequestContextHolder_1.RequestContextHolder(), new EnvPersistenceVolatile_1.EnvPersistenceVolatile(getEnvSnapshot()));
-        return donobuStack;
-    }
-    else {
-        return donobuStack;
-    }
-}
-async function getOrCreateDefaultGptClient() {
-    if (!defaultGptClient) {
-        defaultGptClient = await createGptClient();
-        return defaultGptClient;
-    }
-    else {
-        return defaultGptClient;
-    }
-}
-async function getBrowserStorageState(flowIdOrName) {
-    return (await getOrCreateDonobuStack()).flowsManager.getBrowserStorageState(flowIdOrName);
-}
-function getBrowserStorageStateFixture(flowIdOrName) {
-    return async ({}, use) => {
-        const storage = await (await getOrCreateDonobuStack()).flowsManager.getBrowserStorageState(flowIdOrName);
-        await use(storage);
-    };
-}
-async function anthropicClient(modelName, apiKey) {
-    const divinedApiKey = apiKey || process.env[envVars_1.ENV_VAR_NAMES.ANTHROPIC_API_KEY];
-    if (!divinedApiKey) {
-        throw new Error('An API key is required to use the Anthropic API. Please provide one as an argument or set it using the ANTHROPIC_API_KEY environment variable.');
-    }
-    return GptClientFactory_1.GptClientFactory.createFromGptConfig({
-        type: 'ANTHROPIC',
-        apiKey: divinedApiKey,
-        modelName: modelName,
-    });
-}
-function anthropicClientFixture(modelName, apiKey) {
-    return async ({}, use) => {
-        const client = await anthropicClient(modelName, apiKey);
-        await use(client);
-    };
-}
-async function anthropicAwsBedrockClient(modelName, region, accessKeyId, secretAccessKey) {
-    const divinedAccessKeyId = accessKeyId || process.env[envVars_1.ENV_VAR_NAMES.AWS_ACCESS_KEY_ID];
-    const divinedSecretAccessKey = secretAccessKey || process.env[envVars_1.ENV_VAR_NAMES.AWS_SECRET_ACCESS_KEY];
-    if (!divinedAccessKeyId || !divinedSecretAccessKey) {
-        throw new Error('AWS access key ID and secret access key are required to use the Anthropic AWS Bedrock API. Please provide them as arguments or set them using the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables.');
-    }
-    return GptClientFactory_1.GptClientFactory.createFromGptConfig({
-        type: 'ANTHROPIC_AWS_BEDROCK',
-        region: region,
-        modelName: modelName,
-        accessKeyId: divinedAccessKeyId,
-        secretAccessKey: divinedSecretAccessKey,
-    });
-}
-function anthropicAwsBedrockClientFixture(modelName, region, accessKeyId, secretAccessKey) {
-    return async ({}, use) => {
-        const client = await anthropicAwsBedrockClient(modelName, region, accessKeyId, secretAccessKey);
-        await use(client);
-    };
-}
-async function googleGeminiClient(modelName, apiKey) {
-    const divinedApiKey = apiKey || process.env[envVars_1.ENV_VAR_NAMES.GOOGLE_GENERATIVE_AI_API_KEY];
-    if (!divinedApiKey) {
-        throw new Error('An API key is required to use the Google Gemini API. Please provide one as an argument or set it using the GOOGLE_GENERATIVE_AI_API_KEY environment variable.');
-    }
-    return GptClientFactory_1.GptClientFactory.createFromGptConfig({
-        type: 'GOOGLE_GEMINI',
-        apiKey: divinedApiKey,
-        modelName: modelName,
-    });
-}
-function googleGeminiClientFixture(modelName, apiKey) {
-    return async ({}, use) => {
-        const client = await googleGeminiClient(modelName, apiKey);
-        await use(client);
-    };
-}
-async function openAiClient(modelName, apiKey) {
-    const divinedApiKey = apiKey || process.env[envVars_1.ENV_VAR_NAMES.OPENAI_API_KEY];
-    if (!divinedApiKey) {
-        throw new Error('An API key is required to use the OpenAI API. Please provide one as an argument or set it using the OPENAI_API_KEY environment variable.');
-    }
-    return GptClientFactory_1.GptClientFactory.createFromGptConfig({
-        type: 'OPENAI',
-        apiKey: divinedApiKey,
-        modelName: modelName,
-    });
-}
-function openAiClientFixture(modelName, apiKey) {
-    return async ({}, use) => {
-        const client = await openAiClient(modelName, apiKey);
-        await use(client);
-    };
-}
-function vercelAiClientFixture(model) {
-    return async ({}, use) => {
-        const client = new VercelAiGptClient_1.VercelAiGptClient(model);
-        await use(client);
-    };
-}
-/**
- * This fixture resolves a GPT client based on environment variables.
- * Supplying different environment variables will result in different GPT
- * clients being created. Here is a mapping of client type to environment
- * variables for how to create the various types of clients...
- *
- * Anthropic AWS Bedrock GPT client requires:
- *  - AWS_BEDROCK_MODEL_NAME
- *  - AWS_REGION
- *  - AWS_ACCESS_KEY_ID
- *  - AWS_SECRET_ACCESS_KEY
- *
- * Anthropic GPT client requires:
- *  - ANTHROPIC_API_KEY
- *
- * Google GPT client requires:
- *  - GOOGLE_GENERATIVE_AI_API_KEY
- *
- * OpenAI GPT client requires:
- *  - OPENAI_API_KEY
- *
- * If the modelName is not specified, it will be defaulted according to the
- * DEFAULT_GPT_MODEL_FOR_PLATFORM mapping.
- */
-async function createGptClient(modelName) {
-    // Check which API keys are available
-    const hasAwsCredentials = !!DEFAULT_GPT_MODEL_FOR_PLATFORM.ANTHROPIC_AWS_BEDROCK &&
-        !!process.env[envVars_1.ENV_VAR_NAMES.AWS_ACCESS_KEY_ID] &&
-        !!process.env[envVars_1.ENV_VAR_NAMES.AWS_SECRET_ACCESS_KEY];
-    const hasAnthropicKey = !!process.env[envVars_1.ENV_VAR_NAMES.ANTHROPIC_API_KEY];
-    const hasGoogleKey = !!process.env[envVars_1.ENV_VAR_NAMES.GOOGLE_GENERATIVE_AI_API_KEY];
-    const hasOpenAiKey = !!process.env[envVars_1.ENV_VAR_NAMES.OPENAI_API_KEY];
-    // Priority order: Anthropic AWS Bedrock, Anthropic, Google, OpenAI
-    if (hasAwsCredentials) {
-        const model = modelName || DEFAULT_GPT_MODEL_FOR_PLATFORM.ANTHROPIC_AWS_BEDROCK;
-        const region = process.env[envVars_1.ENV_VAR_NAMES.AWS_REGION];
-        const accessKeyId = process.env[envVars_1.ENV_VAR_NAMES.AWS_ACCESS_KEY_ID];
-        const secretAccessKey = process.env[envVars_1.ENV_VAR_NAMES.AWS_SECRET_ACCESS_KEY];
-        return anthropicAwsBedrockClient(model, region, accessKeyId, secretAccessKey);
-    }
-    else if (hasAnthropicKey) {
-        const model = modelName || DEFAULT_GPT_MODEL_FOR_PLATFORM.ANTHROPIC;
-        return anthropicClient(model);
-    }
-    else if (hasGoogleKey) {
-        const model = modelName || DEFAULT_GPT_MODEL_FOR_PLATFORM.GOOGLE_GEMINI;
-        return googleGeminiClient(model);
-    }
-    else if (hasOpenAiKey) {
-        const model = modelName || DEFAULT_GPT_MODEL_FOR_PLATFORM.OPENAI;
-        return openAiClient(model);
-    }
-    else {
-        const donobu = await getOrCreateDonobuStack();
-        const defaultClient = (await donobu.flowsManager.createGptClient(null))
-            .gptClient;
-        if (defaultClient) {
-            return defaultClient;
-        }
-        else {
-            // No API keys are available and there is not flow-runner set up, throw an error.
-            throw new Error(`No API keys found for any supported GPT providers.
-Please set one of the following environment variables: ANTHROPIC_API_KEY, GOOGLE_GENERATIVE_AI_API_KEY, or OPENAI_API_KEY.
-Alternatively, set a flow-runner agent via POST /api/agents/flow-runner or via the Donobu app.`);
-        }
-    }
-}
-function gptClientFixture(modelName) {
-    return async ({}, use) => {
-        const client = await createGptClient(modelName);
-        await use(client);
-    };
-}
-__exportStar(require("playwright/test"), exports);
-exports.test = test_1.test.extend({
-    // 1) Declare `gptClient` as an "option" fixture with a default of `undefined`.
-    gptClient: [
-        undefined, // default
-        { option: true }, // so that test.use({ gptClient: ... }) can override
-    ],
-    // Override the default page fixture
-    page: async ({ page, gptClient }, use, testInfo) => {
-        if (!gptClient) {
-            try {
-                gptClient = await getOrCreateDefaultGptClient();
-            }
-            catch (_error) {
-                // Do nothing since we may not need a GPT client at all anyway.
-                // If something later on requires a GPT client, it will throw an error.
-            }
-        }
-        // Patch the page with "run", but do it lazily
-        const donobu = await getOrCreateDonobuStack();
-        await PlaywrightUtils_1.PlaywrightUtils.setupBasicBrowserContext(page.context());
-        let isTestRunInitialized = false;
-        let isTestRunFailed = false;
-        async function maybeInitDonobu() {
-            if (isTestRunInitialized) {
-                return;
-            }
-            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, null);
-            const donobuTestFlowMetadata = {
-                id: (0, uuid_1.v4)(),
-                name: testInfo.title,
-                createdWithDonobuVersion: MiscUtils_1.MiscUtils.DONOBU_VERSION,
-                browser: {
-                    using: {
-                        type: 'device',
-                        deviceName: 'Desktop Chromium',
-                        headless: true,
-                    },
-                },
-                envVars: allowedEnvVarsByName,
-                gptConfigName: null,
-                hasGptConfigNameOverride: false,
-                customTools: null,
-                defaultMessageDuration: 0,
-                runMode: 'DETERMINISTIC',
-                isControlPanelEnabled: false,
-                callbackUrl: null,
-                targetWebsite: PLACEHOLDER_FLOW_URL,
-                overallObjective: overallObjective,
-                allowedTools: [],
-                resultJsonSchema: null,
-                result: null,
-                inputTokensUsed: 0,
-                completionTokensUsed: 0,
-                iterations: 0,
-                maxIterations: 0,
-                startedAt: new Date().getTime(),
-                completedAt: null,
-                state: 'RUNNING_ACTION',
-                nextState: null,
-            };
-            const persistenceLayer = await donobu.flowsPersistenceFactory.createPersistenceLayer();
-            await persistenceLayer.setMetadata(donobuTestFlowMetadata);
-            page._donobuFlowMetadata = donobuTestFlowMetadata;
-            isTestRunInitialized = true;
-        }
-        const originalGoto = page.goto;
-        // 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) => {
-            await maybeInitDonobu();
-            const startedAt = new Date().getTime();
-            const flowId = page._donobuFlowMetadata.id;
-            const persistenceLayer = await donobu.flowsPersistenceFactory.createPersistenceLayer();
-            // 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.setMetadata(page._donobuFlowMetadata);
-            }
-            try {
-                const resp = await originalGoto.call(page, url, options);
-                await PlaywrightUtils_1.PlaywrightUtils.waitForPageStability(page);
-                const pageTitle = await page.title();
-                const postCallImage = await PlaywrightUtils_1.PlaywrightUtils.takeScreenshot(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.takeScreenshot(page);
-                const postCallImageId = await persistenceLayer.saveScreenShot(flowId, postCallImage);
-                const completedAt = new Date().getTime();
-                await persistenceLayer.saveToolCall(flowId, {
-                    id: MiscUtils_1.MiscUtils.createAdHocToolCallId(),
-                    toolName: 'goToWebpage',
-                    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
-                isTestRunFailed = true;
-                throw error;
-            }
-        };
-        page.run = async (toolName, toolParams, gptClientOverride) => {
-            await maybeInitDonobu();
-            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.ControlPanel(page._donobuFlowMetadata);
-            const persistenceLayer = await donobu.flowsPersistenceFactory.createPersistenceLayer();
-            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 result = await new ToolManager_1.ToolManager(ToolManager_1.ToolManager.ALL_TOOLS).invokeTool(toolCallContext, toolName, clonedParams, false);
-                await persistenceLayer.setMetadata(page._donobuFlowMetadata);
-                await persistenceLayer.saveToolCall(page._donobuFlowMetadata.id, result);
-                // 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
-                isTestRunFailed = true;
-                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) => {
-            await maybeInitDonobu();
-            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) {
-                isTestRunFailed = true;
-                throw Error('Cannot extract an object from page without a GPT client set up!');
-            }
-            try {
-                const persistenceLayer = await donobu.flowsPersistenceFactory.createPersistenceLayer();
-                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 = params.schema;
-                page._donobuFlowMetadata.result = structuredOutputMessage.output;
-                await persistenceLayer.setMetadata(page._donobuFlowMetadata);
-                return structuredOutputMessage.output;
-            }
-            catch (error) {
-                isTestRunFailed = true;
-                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 {
-            // Let Playwright continue and give tests the patched page.
-            await use(page);
-            // Check if the test status is failed in the testInfo
-            // This catches failures that were marked by Playwright itself
-            if (testInfo.status === 'failed' || testInfo.status === 'timedOut') {
-                isTestRunFailed = true;
-            }
-        }
-        catch (error) {
-            // Mark test as failed if an uncaught exception occurs during the test
-            isTestRunFailed = true;
-            throw error;
-        }
-        finally {
-            try {
-                const persistenceLayer = await donobu.flowsPersistenceFactory.createPersistenceLayer();
-                if (page._donobuFlowMetadata) {
-                    // Update metadata with final status
-                    page._donobuFlowMetadata.state = isTestRunFailed
-                        ? 'FAILED'
-                        : 'SUCCESS';
-                    page._donobuFlowMetadata.completedAt = new Date().getTime();
-                    await persistenceLayer.setMetadata(page._donobuFlowMetadata);
-                    await testInfo.attach('test-flow-metadata.json', {
-                        body: JSON.stringify(page._donobuFlowMetadata, null, 2),
-                        contentType: 'application/json',
-                    });
-                }
-            }
-            catch (error) {
-                // Log but don't throw, to ensure cleanup continues.
-                Logger_1.appLogger.error('Error during test cleanup:', error);
-            }
-            const isSelfHealEnabledEnvVar = process.env[envVars_1.ENV_VAR_NAMES.SELF_HEAL_TESTS_ENABLED]?.trim();
-            if (isTestRunFailed &&
-                (isSelfHealEnabledEnvVar === 'true' || isSelfHealEnabledEnvVar === '1')) {
-                if (!gptClient) {
-                    Logger_1.appLogger.warn('Will not self-heal due to no GPT client being set up.');
-                    return;
-                }
-                try {
-                    await selfHeal(gptClient, testInfo, page._donobuFlowMetadata);
-                }
-                catch (selfHealError) {
-                    Logger_1.appLogger.error('Error when attempting to self heal:', selfHealError);
-                }
-            }
-        }
-    },
-});
-//# sourceMappingURL=playwrightTestExtensions.js.map