donobu 1.0.0

package/dist/esm/tools/ReplayableInteraction.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayableInteraction = void 0;
+const PlaywrightUtils_1 = require("../utils/PlaywrightUtils");
+const Tool_1 = require("./Tool");
+const Logger_1 = require("../utils/Logger");
+const PageClosedException_1 = require("../exceptions/PageClosedException");
+/**
+ * Tools that specify a numbered Donobu annotation to indicate which element to
+ * interact with and support deterministic reruns should extend this interface.
+ */
+class ReplayableInteraction extends Tool_1.Tool {
+    static MAX_LOCATOR_MATCH_COUNT = 5;
+    constructor(name, description, parametersTypeNameForGptlessSchema, parametersTypeNameForGptSchema) {
+        super(name, description, parametersTypeNameForGptlessSchema, parametersTypeNameForGptSchema);
+    }
+    async call(context, parameters) {
+        const page = context.page;
+        const locators = await ReplayableInteraction.getLocatorsOrderedByMatchCount(page, parameters.selector.frame, parameters.selector.element);
+        if (!locators.length) {
+            return {
+                isSuccessful: false,
+                forLlm: 'FAILED! Unable to resolve HTML element to operate with.',
+                metadata: null,
+            };
+        }
+        return this.callCore(context, parameters, locators, parameters.selector);
+    }
+    async callFromGpt(context, parameters) {
+        const page = context.page;
+        const elementSelector = `[${PlaywrightUtils_1.PlaywrightUtils.DONOBU_INTERACTABLE_ATTRIBUTE}="${parameters.annotation}"]`;
+        let locatorData = null;
+        for (const frame of page.frames()) {
+            if (frame.isDetached()) {
+                continue;
+            }
+            const locator = frame.locator(elementSelector);
+            if ((await locator.count()) > 0) {
+                const selectorCandidates = await PlaywrightUtils_1.PlaywrightUtils.generateSelectors(locator);
+                const frameSelector = frame.parentFrame() === null
+                    ? null
+                    : await PlaywrightUtils_1.PlaywrightUtils.parseUnambiguousSelector(await frame.frameElement());
+                locatorData = {
+                    locators: [locator],
+                    selectorForReplay: {
+                        element: selectorCandidates,
+                        frame: frameSelector,
+                    },
+                };
+            }
+        }
+        if (!locatorData || !locatorData.locators.length) {
+            return {
+                isSuccessful: false,
+                forLlm: 'FAILED! Unable to resolve HTML element to operate with.',
+                metadata: null,
+            };
+        }
+        return this.callCore(context, parameters, locatorData.locators, locatorData.selectorForReplay);
+    }
+    async callCore(context, parameters, locators, selectorForReplay) {
+        const timeoutMilliseconds = 1000;
+        const page = context.page;
+        for (const locator of locators) {
+            try {
+                const count = await locator.count();
+                for (let i = 0; i < count; ++i) {
+                    try {
+                        const element = (await PlaywrightUtils_1.PlaywrightUtils.getLocatorOrItsLabel(locator.nth(i))).first();
+                        await element.scrollIntoViewIfNeeded({
+                            timeout: timeoutMilliseconds,
+                        });
+                        const box = await element.boundingBox({
+                            timeout: timeoutMilliseconds,
+                        });
+                        if (!box) {
+                            throw new Error(`Failed to retrieve element bounding box for '${element}'; element may be offscreen or detached.`);
+                        }
+                        if (parameters.rationale) {
+                            await context.toolTipper.blipToolTipAtElement(page, element, parameters.rationale);
+                        }
+                        // Hide the control panel so that it will not block an interaction if the
+                        // target element is underneath the panel.
+                        await PlaywrightUtils_1.PlaywrightUtils.hideControlPanel(context.page, context.metadata);
+                        const forLlm = await this.invoke(context, parameters, element);
+                        await PlaywrightUtils_1.PlaywrightUtils.showControlPanel(context.page, context.metadata);
+                        await PlaywrightUtils_1.PlaywrightUtils.waitForPageStability(page);
+                        return {
+                            isSuccessful: true,
+                            forLlm: forLlm,
+                            metadata: selectorForReplay,
+                        };
+                    }
+                    catch (elementError) {
+                        Logger_1.Logger.appLogger.error(`Failed to interact with element '${locator.nth(i)}' due to exception, will fail over to remaining elements (if any)`, elementError);
+                    }
+                }
+            }
+            catch (locatorError) {
+                Logger_1.Logger.appLogger.error(`Failed to interact with locator '${locator.toString()}' due to exception, will fail over to remaining locators (if any)`, locatorError);
+            }
+        }
+        return {
+            isSuccessful: false,
+            forLlm: 'FAILED! Unable to apply operatation.',
+            metadata: null,
+        };
+    }
+    /**
+     * Retrieves a list of {@link Locator} objects based on the provided selector
+     * candidates, ordered by their match count in ascending order. If the match
+     * count for a locator exceeds
+     * {@link ReplayableInteraction.MAX_LOCATOR_MATCH_COUNT}, then they are ignored, as
+     * it is considered too broad of a locator to be useful.
+     *
+     * This method iterates through a list of CSS selector candidates and creates
+     * a {@link Locator} for each candidate. It counts the number of elements that
+     * match each selector within a given page. If a frame selector is provided,
+     * it looks for the elements within the specified frame; otherwise, it
+     * searches within the entire page. Only locators with a positive match count
+     * are added to the result list.
+     *
+     * @param page - The the web page to search within.
+     * @param frameSelector - An optional CSS selector for a frame within the
+     *   page. If {@code null}, the search is performed in the entire page.
+     * @param selectorCandidates A list of CSS selector strings to be used for
+     *   locating elements.
+     * @return A list of {@link Locator} objects that have been found, ordered by
+     *   their match count in ascending order.
+     */
+    static async getLocatorsOrderedByMatchCount(page, frameSelector, selectorCandidates) {
+        try {
+            const locators = [];
+            for (const selectorCandidate of selectorCandidates) {
+                try {
+                    const elementLocator = frameSelector
+                        ? page.frameLocator(frameSelector).locator(selectorCandidate)
+                        : page.locator(selectorCandidate);
+                    const count = await elementLocator.count();
+                    if (count > 0 &&
+                        ReplayableInteraction.MAX_LOCATOR_MATCH_COUNT >= count) {
+                        locators.push(elementLocator);
+                    }
+                }
+                catch (e) {
+                    Logger_1.Logger.appLogger.warn(`Invalid selector: ${selectorCandidate}`, e);
+                }
+            }
+            // Create array of objects containing locator and its count
+            const locatorsWithCounts = await Promise.all(locators.map(async (locator) => ({
+                locator,
+                count: await locator.count(),
+            })));
+            // Sort by count and return just the locators
+            return locatorsWithCounts
+                .sort((a, b) => a.count - b.count)
+                .map((item) => item.locator);
+        }
+        catch (error) {
+            if (PlaywrightUtils_1.PlaywrightUtils.isPageClosedError(error)) {
+                throw new PageClosedException_1.PageClosedException();
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+exports.ReplayableInteraction = ReplayableInteraction;
+//# sourceMappingURL=ReplayableInteraction.js.map

package/dist/esm/tools/ReplayableInteraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplayableInteraction.js","sourceRoot":"","sources":["../../../src/tools/ReplayableInteraction.ts"],"names":[],"mappings":"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"}

package/dist/esm/tools/RunAccessibilityTestTool.d.ts

@@ -0,0 +1,14 @@
+import { Tool } from './Tool';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+export interface RunAccessibilityTestToolCoreParameters {
+}
+export interface RunAccessibilityTestToolGptParameters extends BaseToolGptParameters, RunAccessibilityTestToolCoreParameters {
+}
+export declare class RunAccessibilityTestTool extends Tool<RunAccessibilityTestToolCoreParameters, RunAccessibilityTestToolGptParameters> {
+    static readonly NAME = "runAccessibilityTest";
+    constructor();
+    call(context: ToolCallContext, _parameters: RunAccessibilityTestToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(context: ToolCallContext, parameters: RunAccessibilityTestToolGptParameters): Promise<ToolCallResult>;
+}

package/dist/esm/tools/RunAccessibilityTestTool.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunAccessibilityTestTool = void 0;
+const Tool_1 = require("./Tool");
+const JsonUtils_1 = require("../utils/JsonUtils");
+class RunAccessibilityTestTool extends Tool_1.Tool {
+    static NAME = 'runAccessibilityTest';
+    constructor() {
+        super(RunAccessibilityTestTool.NAME, 'Run an web accessibility (i.e. axe-core) test on the current webpage.', 'RunAccessibilityTestToolCoreParameters', 'RunAccessibilityTestToolGptParameters');
+    }
+    async call(context, _parameters) {
+        const page = context.page;
+        // Run the Axe-core analysis
+        const fullResultStr = (await page.evaluate(() => {
+            return window.axe.run().then((results) => {
+                return JSON.stringify(results);
+            });
+        }));
+        const fullResult = JsonUtils_1.JsonUtils.jsonStringToJsonObject(fullResultStr);
+        const violations = fullResult.violations;
+        if (!violations || violations.length === 0) {
+            return {
+                isSuccessful: true,
+                forLlm: 'No accessibility violations found.',
+                metadata: fullResult,
+            };
+        }
+        // Summarize the violations using "help" as the key
+        const violationSummary = new Map();
+        for (const violation of violations) {
+            violationSummary.set(violation.help, (violationSummary.get(violation.help) ?? 0) + violation.nodes.length);
+        }
+        // Build the summary report
+        const summaryReport = [];
+        violationSummary.forEach((count, helpText) => {
+            summaryReport.push(`${count} violations found for: ${helpText}`);
+        });
+        return {
+            isSuccessful: true,
+            forLlm: summaryReport.join('\n'),
+            metadata: fullResult,
+        };
+    }
+    async callFromGpt(context, parameters) {
+        return this.call(context, parameters);
+    }
+}
+exports.RunAccessibilityTestTool = RunAccessibilityTestTool;
+//# sourceMappingURL=RunAccessibilityTestTool.js.map

package/dist/esm/tools/RunAccessibilityTestTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunAccessibilityTestTool.js","sourceRoot":"","sources":["../../../src/tools/RunAccessibilityTestTool.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAG9B,kDAA+C;AAQ/C,MAAa,wBAAyB,SAAQ,WAG7C;IACQ,MAAM,CAAU,IAAI,GAAG,sBAAsB,CAAC;IAErD;QACE,KAAK,CACH,wBAAwB,CAAC,IAAI,EAC7B,uEAAuE,EACvE,wCAAwC,EACxC,uCAAuC,CACxC,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,IAAI,CACxB,OAAwB,EACxB,WAAmD;QAEnD,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QAE1B,4BAA4B;QAC5B,MAAM,aAAa,GAAG,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE;YAC9C,OAAQ,MAAc,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,OAAY,EAAE,EAAE;gBACrD,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAW,CAAC;QAEd,MAAM,UAAU,GAAG,qBAAS,CAAC,sBAAsB,CAAC,aAAa,CAAC,CAAC;QACnE,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QAEzC,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3C,OAAO;gBACL,YAAY,EAAE,IAAI;gBAClB,MAAM,EAAE,oCAAoC;gBAC5C,QAAQ,EAAE,UAAU;aACrB,CAAC;QACJ,CAAC;QAED,mDAAmD;QACnD,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAkB,CAAC;QAEnD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,gBAAgB,CAAC,GAAG,CAClB,SAAS,CAAC,IAAI,EACd,CAAC,gBAAgB,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CACrE,CAAC;QACJ,CAAC;QAED,2BAA2B;QAC3B,MAAM,aAAa,GAAa,EAAE,CAAC;QAEnC,gBAAgB,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;YAC3C,aAAa,CAAC,IAAI,CAAC,GAAG,KAAK,0BAA0B,QAAQ,EAAE,CAAC,CAAC;QACnE,CAAC,CAAC,CAAC;QAEH,OAAO;YACL,YAAY,EAAE,IAAI;YAClB,MAAM,EAAE,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;YAChC,QAAQ,EAAE,UAAU;SACrB,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,OAAwB,EACxB,UAAiD;QAEjD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;;AApEH,4DAqEC"}

package/dist/esm/tools/RunInlineJavaScriptCodeTool.d.ts

@@ -0,0 +1,17 @@
+import { Tool } from './Tool';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+export type RunInlineJavaScriptCodeToolCoreParameters = {
+    /**
+     * The JavaScript code to run.
+     */
+    javaScriptCode: string;
+};
+export type RunInlineJavaScriptCodeToolGptParameters = BaseToolGptParameters & RunInlineJavaScriptCodeToolCoreParameters;
+export declare class RunInlineJavaScriptCodeTool extends Tool<RunInlineJavaScriptCodeToolCoreParameters, RunInlineJavaScriptCodeToolGptParameters> {
+    static readonly NAME = "runInlineJavaScriptCode";
+    constructor();
+    call(context: ToolCallContext, parameters: RunInlineJavaScriptCodeToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(context: ToolCallContext, parameters: RunInlineJavaScriptCodeToolGptParameters): Promise<ToolCallResult>;
+}

package/dist/esm/tools/RunInlineJavaScriptCodeTool.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunInlineJavaScriptCodeTool = void 0;
+const Tool_1 = require("./Tool");
+class RunInlineJavaScriptCodeTool extends Tool_1.Tool {
+    static NAME = 'runInlineJavaScriptCode';
+    constructor() {
+        super(RunInlineJavaScriptCodeTool.NAME, `Run arbitrary JavaScript code inside of the current webpage. The entire DOM is available, ` +
+            `as well as the overall environment of the webpage itself. The JS code must be of the form:\n` +
+            '```\n' +
+            '() => {\n' +
+            '  // ...some code...\n' +
+            '  return ...some result...\n' +
+            '}\n' +
+            '```', 'RunInlineJavaScriptCodeToolCoreParameters', 'RunInlineJavaScriptCodeToolGptParameters');
+    }
+    async call(context, parameters) {
+        const result = await context.page.evaluate(parameters.javaScriptCode);
+        return {
+            isSuccessful: true,
+            forLlm: '' + JSON.stringify(result),
+            metadata: null,
+        };
+    }
+    async callFromGpt(context, parameters) {
+        return this.call(context, parameters);
+    }
+}
+exports.RunInlineJavaScriptCodeTool = RunInlineJavaScriptCodeTool;
+//# sourceMappingURL=RunInlineJavaScriptCodeTool.js.map

package/dist/esm/tools/RunInlineJavaScriptCodeTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunInlineJavaScriptCodeTool.js","sourceRoot":"","sources":["../../../src/tools/RunInlineJavaScriptCodeTool.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAe9B,MAAa,2BAA4B,SAAQ,WAGhD;IACQ,MAAM,CAAU,IAAI,GAAG,yBAAyB,CAAC;IAExD;QACE,KAAK,CACH,2BAA2B,CAAC,IAAI,EAChC,4FAA4F;YAC1F,8FAA8F;YAC9F,OAAO;YACP,WAAW;YACX,wBAAwB;YACxB,8BAA8B;YAC9B,KAAK;YACL,KAAK,EACP,2CAA2C,EAC3C,0CAA0C,CAC3C,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,IAAI,CACxB,OAAwB,EACxB,UAAqD;QAErD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;QACtE,OAAO;YACL,YAAY,EAAE,IAAI;YAClB,MAAM,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YACnC,QAAQ,EAAE,IAAI;SACf,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,OAAwB,EACxB,UAAoD;QAEpD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;;AAvCH,kEAwCC"}

package/dist/esm/tools/RunSandboxedJavaScriptCodeTool.d.ts

@@ -0,0 +1,18 @@
+import { Tool } from './Tool';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+export interface RunSandboxedJavaScriptCodeToolCoreParameters {
+    /**
+     * The JavaScript code to run.
+     */
+    javaScriptCode: string;
+}
+export interface RunSandboxedJavaScriptCodeToolGptParameters extends BaseToolGptParameters, RunSandboxedJavaScriptCodeToolCoreParameters {
+}
+export declare class RunSandboxedJavaScriptCodeTool extends Tool<RunSandboxedJavaScriptCodeToolCoreParameters, RunSandboxedJavaScriptCodeToolGptParameters> {
+    static readonly NAME = "runSandboxedJavaScriptCode";
+    constructor();
+    call(_context: ToolCallContext, parameters: RunSandboxedJavaScriptCodeToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(context: ToolCallContext, parameters: RunSandboxedJavaScriptCodeToolGptParameters): Promise<ToolCallResult>;
+}

package/dist/esm/tools/RunSandboxedJavaScriptCodeTool.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunSandboxedJavaScriptCodeTool = void 0;
+const Tool_1 = require("./Tool");
+const playwright_1 = require("playwright");
+class RunSandboxedJavaScriptCodeTool extends Tool_1.Tool {
+    static NAME = 'runSandboxedJavaScriptCode';
+    constructor() {
+        super(RunSandboxedJavaScriptCodeTool.NAME, `Run arbitrary JavaScript code in a sandboxed environment. Unlike the ` +
+            `"runInlineJavaScriptCode" tool, this tool does not have access to current ` +
+            `webpage's DOM or environment. The JS code must be of the form:\n` +
+            '```\n' +
+            '() => {\n' +
+            '  // ...some code...\n' +
+            '  return ...some result...\n' +
+            '}\n' +
+            '```', 'RunSandboxedJavaScriptCodeToolCoreParameters', 'RunSandboxedJavaScriptCodeToolGptParameters');
+    }
+    async call(_context, parameters) {
+        const sandBoxedBrowser = await playwright_1.chromium.launch({
+            headless: true,
+            chromiumSandbox: true,
+        });
+        const sandBoxedPage = await sandBoxedBrowser.newPage();
+        try {
+            const result = await sandBoxedPage.evaluate(parameters.javaScriptCode);
+            return {
+                isSuccessful: true,
+                forLlm: '' + JSON.stringify(result),
+                metadata: null,
+            };
+        }
+        finally {
+            await sandBoxedPage.close();
+            await sandBoxedBrowser.close();
+        }
+    }
+    async callFromGpt(context, parameters) {
+        return this.call(context, parameters);
+    }
+}
+exports.RunSandboxedJavaScriptCodeTool = RunSandboxedJavaScriptCodeTool;
+//# sourceMappingURL=RunSandboxedJavaScriptCodeTool.js.map

package/dist/esm/tools/RunSandboxedJavaScriptCodeTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunSandboxedJavaScriptCodeTool.js","sourceRoot":"","sources":["../../../src/tools/RunSandboxedJavaScriptCodeTool.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAG9B,2CAAsC;AAatC,MAAa,8BAA+B,SAAQ,WAGnD;IACQ,MAAM,CAAU,IAAI,GAAG,4BAA4B,CAAC;IAE3D;QACE,KAAK,CACH,8BAA8B,CAAC,IAAI,EACnC,uEAAuE;YACrE,4EAA4E;YAC5E,kEAAkE;YAClE,OAAO;YACP,WAAW;YACX,wBAAwB;YACxB,8BAA8B;YAC9B,KAAK;YACL,KAAK,EACP,8CAA8C,EAC9C,6CAA6C,CAC9C,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,IAAI,CACxB,QAAyB,EACzB,UAAwD;QAExD,MAAM,gBAAgB,GAAG,MAAM,qBAAQ,CAAC,MAAM,CAAC;YAC7C,QAAQ,EAAE,IAAI;YACd,eAAe,EAAE,IAAI;SACtB,CAAC,CAAC;QACH,MAAM,aAAa,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,CAAC;QAEvD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;YACvE,OAAO;gBACL,YAAY,EAAE,IAAI;gBAClB,MAAM,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;gBACnC,QAAQ,EAAE,IAAI;aACf,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,MAAM,aAAa,CAAC,KAAK,EAAE,CAAC;YAC5B,MAAM,gBAAgB,CAAC,KAAK,EAAE,CAAC;QACjC,CAAC;IACH,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,OAAwB,EACxB,UAAuD;QAEvD,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;;AAnDH,wEAoDC"}

package/dist/esm/tools/SaveWebpageAsPdfTool.d.ts

@@ -0,0 +1,15 @@
+import { Tool } from './Tool';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+interface SaveWebpageAsPdfToolCoreParameters {
+}
+interface SaveWebpageAsPdfToolGptParameters extends BaseToolGptParameters, SaveWebpageAsPdfToolCoreParameters {
+}
+export declare class SaveWebpageAsPdfTool extends Tool<SaveWebpageAsPdfToolCoreParameters, SaveWebpageAsPdfToolGptParameters> {
+    static readonly NAME = "saveWebpageAsPdf";
+    constructor();
+    call(context: ToolCallContext, _parameters: SaveWebpageAsPdfToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(context: ToolCallContext, parameters: SaveWebpageAsPdfToolGptParameters): Promise<ToolCallResult>;
+}
+export {};

package/dist/esm/tools/SaveWebpageAsPdfTool.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveWebpageAsPdfTool = void 0;
+const Tool_1 = require("./Tool");
+class SaveWebpageAsPdfTool extends Tool_1.Tool {
+    static NAME = 'saveWebpageAsPdf';
+    constructor() {
+        super(SaveWebpageAsPdfTool.NAME, 'Save the current webpage as a PDF.', 'SaveWebpageAsPdfToolParameters', 'SaveWebpageAsPdfToolGptParameters');
+    }
+    async call(context, _parameters) {
+        const pdfBytes = await context.page.pdf();
+        const filename = `${new Date().toISOString()}.pdf`;
+        await context.persistence.setFlowFile(context.metadata.id, filename, Buffer.from(pdfBytes));
+        return {
+            isSuccessful: true,
+            forLlm: `Successfully saved the current webpage as a PDF: ${filename}`,
+            metadata: {
+                pdfFilename: filename,
+            },
+        };
+    }
+    async callFromGpt(context, parameters) {
+        return this.call(context, parameters);
+    }
+}
+exports.SaveWebpageAsPdfTool = SaveWebpageAsPdfTool;
+//# sourceMappingURL=SaveWebpageAsPdfTool.js.map

package/dist/esm/tools/SaveWebpageAsPdfTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaveWebpageAsPdfTool.js","sourceRoot":"","sources":["../../../src/tools/SaveWebpageAsPdfTool.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAU9B,MAAa,oBAAqB,SAAQ,WAGzC;IACQ,MAAM,CAAU,IAAI,GAAG,kBAAkB,CAAC;IAEjD;QACE,KAAK,CACH,oBAAoB,CAAC,IAAI,EACzB,oCAAoC,EACpC,gCAAgC,EAChC,mCAAmC,CACpC,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,IAAI,CACxB,OAAwB,EACxB,WAA+C;QAE/C,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QAC1C,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC;QAEnD,MAAM,OAAO,CAAC,WAAW,CAAC,WAAW,CACnC,OAAO,CAAC,QAAQ,CAAC,EAAE,EACnB,QAAQ,EACR,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CACtB,CAAC;QAEF,OAAO;YACL,YAAY,EAAE,IAAI;YAClB,MAAM,EAAE,oDAAoD,QAAQ,EAAE;YACtE,QAAQ,EAAE;gBACR,WAAW,EAAE,QAAQ;aACtB;SACF,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,OAAwB,EACxB,UAA6C;QAE7C,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;;AA1CH,oDA2CC"}

package/dist/esm/tools/ScrollPageTool.d.ts

@@ -0,0 +1,18 @@
+import { Tool } from './Tool';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+export interface ScrollPageToolCoreParameters {
+    /**
+     * The direction to scroll - either UP or DOWN
+     */
+    direction: 'UP' | 'DOWN';
+}
+export interface ScrollPageToolGptParameters extends BaseToolGptParameters, ScrollPageToolCoreParameters {
+}
+export declare class ScrollPageTool extends Tool<ScrollPageToolCoreParameters, ScrollPageToolGptParameters> {
+    static readonly NAME = "scrollPage";
+    constructor();
+    call(context: ToolCallContext, parameters: ScrollPageToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(context: ToolCallContext, parameters: ScrollPageToolGptParameters): Promise<ToolCallResult>;
+}

package/dist/esm/tools/ScrollPageTool.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollPageTool = void 0;
+const Tool_1 = require("./Tool");
+const ToolCallResult_1 = require("../models/ToolCallResult");
+class ScrollPageTool extends Tool_1.Tool {
+    static NAME = 'scrollPage';
+    constructor() {
+        super(ScrollPageTool.NAME, 'Scroll the current page up or down by one viewport. This helps you see more of the ' +
+            'current page, of which may contain relevant information below the fold.', 'ScrollPageToolCoreParameters', 'ScrollPageToolGptParameters');
+    }
+    async call(context, parameters) {
+        await context.page.press('body', parameters.direction === 'DOWN' ? 'PageDown' : 'PageUp');
+        return ToolCallResult_1.ToolCallResult.successful();
+    }
+    async callFromGpt(context, parameters) {
+        return this.call(context, parameters);
+    }
+}
+exports.ScrollPageTool = ScrollPageTool;
+//# sourceMappingURL=ScrollPageTool.js.map

package/dist/esm/tools/ScrollPageTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScrollPageTool.js","sourceRoot":"","sources":["../../../src/tools/ScrollPageTool.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAE9B,6DAA0D;AAa1D,MAAa,cAAe,SAAQ,WAGnC;IACQ,MAAM,CAAU,IAAI,GAAG,YAAY,CAAC;IAE3C;QACE,KAAK,CACH,cAAc,CAAC,IAAI,EACnB,qFAAqF;YACnF,yEAAyE,EAC3E,8BAA8B,EAC9B,6BAA6B,CAC9B,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,IAAI,CACxB,OAAwB,EACxB,UAAwC;QAExC,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CACtB,MAAM,EACN,UAAU,CAAC,SAAS,KAAK,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CACxD,CAAC;QACF,OAAO,+BAAc,CAAC,UAAU,EAAE,CAAC;IACrC,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,OAAwB,EACxB,UAAuC;QAEvC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;;AAhCH,wCAiCC"}

package/dist/esm/tools/SetRunModeTool.d.ts

@@ -0,0 +1,20 @@
+import { Tool } from './Tool';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { RunMode } from '../models/FlowMetadata';
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+interface SetRunModeToolCoreParameters {
+    /**
+     * The value of the run mode to set.
+     */
+    runMode: RunMode;
+}
+interface SetRunModeToolGptParameters extends BaseToolGptParameters, SetRunModeToolCoreParameters {
+}
+export declare class SetRunModeTool extends Tool<SetRunModeToolCoreParameters, SetRunModeToolGptParameters> {
+    static readonly NAME = "setRunMode";
+    constructor();
+    call(context: ToolCallContext, parameters: SetRunModeToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(context: ToolCallContext, parameters: SetRunModeToolGptParameters): Promise<ToolCallResult>;
+}
+export {};

package/dist/esm/tools/SetRunModeTool.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetRunModeTool = void 0;
+const Tool_1 = require("./Tool");
+const ToolCallResult_1 = require("../models/ToolCallResult");
+const FlowMetadata_1 = require("../models/FlowMetadata");
+class SetRunModeTool extends Tool_1.Tool {
+    static NAME = 'setRunMode';
+    constructor() {
+        super(SetRunModeTool.NAME, `Set the run mode of this Donobu Flow, so that it can be controlled by Donobu (i.e. ${FlowMetadata_1.RunMode.AUTONOMOUS} runMode), ` +
+            `or be controlled by the user (i.e. ${FlowMetadata_1.RunMode.INSTRUCT} runMode).`, 'SetRunModeToolCoreParameters', 'SetRunModeToolGptParameters', true);
+    }
+    async call(context, parameters) {
+        context.metadata.runMode = parameters.runMode;
+        return ToolCallResult_1.ToolCallResult.successful();
+    }
+    async callFromGpt(context, parameters) {
+        return this.call(context, parameters);
+    }
+}
+exports.SetRunModeTool = SetRunModeTool;
+//# sourceMappingURL=SetRunModeTool.js.map

package/dist/esm/tools/SetRunModeTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SetRunModeTool.js","sourceRoot":"","sources":["../../../src/tools/SetRunModeTool.ts"],"names":[],"mappings":";;;AAAA,iCAA8B;AAE9B,6DAA0D;AAC1D,yDAAiD;AAajD,MAAa,cAAe,SAAQ,WAGnC;IACQ,MAAM,CAAU,IAAI,GAAG,YAAY,CAAC;IAE3C;QACE,KAAK,CACH,cAAc,CAAC,IAAI,EACnB,sFAAsF,sBAAO,CAAC,UAAU,aAAa;YACnH,sCAAsC,sBAAO,CAAC,QAAQ,YAAY,EACpE,8BAA8B,EAC9B,6BAA6B,EAC7B,IAAI,CACL,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,IAAI,CACxB,OAAwB,EACxB,UAAwC;QAExC,OAAO,CAAC,QAAQ,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAC9C,OAAO,+BAAc,CAAC,UAAU,EAAE,CAAC;IACrC,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,OAAwB,EACxB,UAAuC;QAEvC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACxC,CAAC;;AA9BH,wCA+BC"}

package/dist/esm/tools/SummarizeLearningsTool.d.ts

@@ -0,0 +1,21 @@
+import { BaseToolGptParameters } from '../models/BaseToolGptParameters';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+import { Tool } from './Tool';
+export interface SummarizeLearningsToolCoreParameters {
+}
+export interface SummarizeLearningsToolGptParameters extends BaseToolGptParameters, SummarizeLearningsToolCoreParameters {
+    /**
+     * The summary to make.
+     */
+    summary: string;
+}
+/**
+ * Tool for summarizing learnings made over the course of the flow.
+ */
+export declare class SummarizeLearningsTool extends Tool<SummarizeLearningsToolCoreParameters, SummarizeLearningsToolGptParameters> {
+    static readonly NAME = "summarizeLearnings";
+    constructor();
+    call(_context: ToolCallContext, _parameters: SummarizeLearningsToolCoreParameters): Promise<ToolCallResult>;
+    callFromGpt(_context: ToolCallContext, parameters: SummarizeLearningsToolGptParameters): Promise<ToolCallResult>;
+}

package/dist/esm/tools/SummarizeLearningsTool.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SummarizeLearningsTool = void 0;
+const Logger_1 = require("../utils/Logger");
+const Tool_1 = require("./Tool");
+/**
+ * Tool for summarizing learnings made over the course of the flow.
+ */
+class SummarizeLearningsTool extends Tool_1.Tool {
+    static NAME = 'summarizeLearnings';
+    constructor() {
+        super(SummarizeLearningsTool.NAME, 'Summarize the learnings made over the course of the Donobu flow.', 'SummarizeLearningsToolCoreParameters', 'SummarizeLearningsToolGptParameters');
+    }
+    async call(_context, _parameters) {
+        Logger_1.Logger.appLogger.warn(`${this.name} tool is being run without a GPT even though it makes no sense to do so!`);
+        return {
+            isSuccessful: true,
+            forLlm: '',
+            metadata: null,
+        };
+    }
+    async callFromGpt(_context, parameters) {
+        return {
+            isSuccessful: true,
+            forLlm: parameters.summary,
+            metadata: null,
+        };
+    }
+}
+exports.SummarizeLearningsTool = SummarizeLearningsTool;
+//# sourceMappingURL=SummarizeLearningsTool.js.map

package/dist/esm/tools/SummarizeLearningsTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SummarizeLearningsTool.js","sourceRoot":"","sources":["../../../src/tools/SummarizeLearningsTool.ts"],"names":[],"mappings":";;;AAGA,4CAAyC;AACzC,iCAA8B;AAY9B;;GAEG;AACH,MAAa,sBAAuB,SAAQ,WAG3C;IACQ,MAAM,CAAU,IAAI,GAAG,oBAAoB,CAAC;IAEnD;QACE,KAAK,CACH,sBAAsB,CAAC,IAAI,EAC3B,kEAAkE,EAClE,sCAAsC,EACtC,qCAAqC,CACtC,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,QAAyB,EACzB,WAAiD;QAEjD,eAAM,CAAC,SAAS,CAAC,IAAI,CACnB,GAAG,IAAI,CAAC,IAAI,0EAA0E,CACvF,CAAC;QACF,OAAO;YACL,YAAY,EAAE,IAAI;YAClB,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,IAAI;SACf,CAAC;IACJ,CAAC;IAEe,KAAK,CAAC,WAAW,CAC/B,QAAyB,EACzB,UAA+C;QAE/C,OAAO;YACL,YAAY,EAAE,IAAI;YAClB,MAAM,EAAE,UAAU,CAAC,OAAO;YAC1B,QAAQ,EAAE,IAAI;SACf,CAAC;IACJ,CAAC;;AAtCH,wDAuCC"}

package/dist/esm/tools/Tool.d.ts

@@ -0,0 +1,35 @@
+import { JSONSchema7 } from 'json-schema';
+import { ToolCallContext } from '../models/ToolCallContext';
+import { ToolCallResult } from '../models/ToolCallResult';
+/** Represents a tool call to be invoked by a DonobuFlow. */
+export declare abstract class Tool<NonGptParameters, GptParameters> {
+    /**
+     * This is the name for the tool that will be shared with the LLM when making requests.
+     */
+    readonly name: string;
+    /** This is the description that will be shared with the LLM when making requests. */
+    readonly description: string;
+    /** This is the JSON-schema for the tool when it is invoked by a non-LLM. */
+    readonly jsonSchema: JSONSchema7;
+    /**
+     * This is the JSON-schema that will be shared with the LLM when making
+     * requests during autonomous flows.
+     **/
+    readonly jsonSchemaForGpt: JSONSchema7;
+    /**
+     * This is the message that will be displayed in the front-end control panel when this tool is
+     * invoked, assuming the control panel is enabled.
+     */
+    readonly controlPanelMessage: string;
+    /** Returns true if this tool requires the usage of a GPT. */
+    readonly requiresGpt: boolean;
+    protected constructor(name: string, description: string, parametersTypeNameForNonGptSchema: string, parametersTypeNameForGptSchema: string, requiresGpt?: boolean);
+    /**
+     * Invoke the tool with the given context and parameters.
+     */
+    abstract call(_context: ToolCallContext, _parameters: NonGptParameters): Promise<ToolCallResult>;
+    /**
+     * Invoke the tool as made from a GPT with the given context and parameters.
+     */
+    abstract callFromGpt(_context: ToolCallContext, _parameters: GptParameters): Promise<ToolCallResult>;
+}