opera-devtools-mcp 0.2.4 → 0.4.0

package/build/src/tools/screenshot.js

@@ -3,85 +3,244 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { zod } from '../third_party/index.js';
-import { ToolCategory } from './categories.js';
-import { definePageTool } from './ToolDefinition.js';
-export const screenshot = definePageTool({
-    name: 'take_screenshot',
-    description: `Take a screenshot of the page or element.`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        // Not read-only due to filePath param.
-        readOnlyHint: false,
-    },
-    schema: {
-        format: zod
-            .enum(['png', 'jpeg', 'webp'])
-            .default('png')
-            .describe('Type of format to save the screenshot as. Default is "png"'),
-        quality: zod
-            .number()
-            .min(0)
-            .max(100)
-            .optional()
-            .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
-        uid: zod
-            .string()
-            .optional()
-            .describe('The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.'),
-        fullPage: zod
-            .boolean()
-            .optional()
-            .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
-        filePath: zod
-            .string()
-            .optional()
-            .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
-    },
-    blockedByDialog: true,
-    handler: async (request, response, context) => {
-        context.validatePath(request.params.filePath);
-        if (request.params.uid && request.params.fullPage) {
-            throw new Error('Providing both "uid" and "fullPage" is not allowed.');
-        }
-        let pageOrHandle;
-        if (request.params.uid) {
-            pageOrHandle = await request.page.getElementByUid(request.params.uid);
-        }
-        else {
-            pageOrHandle = request.page.pptrPage;
-        }
-        const format = request.params.format;
-        const quality = format === 'png' ? undefined : request.params.quality;
-        const screenshot = await pageOrHandle.screenshot({
-            type: format,
-            fullPage: request.params.fullPage,
-            quality,
-            optimizeForSpeed: true, // Bonus: optimize encoding for speed
-        });
-        if (request.params.uid) {
-            response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
         }
-        else if (request.params.fullPage) {
-            response.appendResponseLine('Took a screenshot of the full current page.');
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
         }
-        else {
-            response.appendResponseLine("Took a screenshot of the current page's viewport.");
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
         }
-        if (request.params.filePath) {
-            const result = await context.saveFile(screenshot, request.params.filePath, `.${format}`);
-            response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
         }
-        else if (screenshot.length >= 2_000_000) {
-            const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.${request.params.format}`);
-            response.appendResponseLine(`Saved screenshot to ${filepath}.`);
-        }
-        else {
-            response.attachImage({
-                mimeType: `image/${request.params.format}`,
-                data: Buffer.from(screenshot).toString('base64'),
-            });
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+async function getSourceBox(page, element, fullPage) {
+    if (element) {
+        const box = await element.boundingBox();
+        return box ?? undefined;
+    }
+    if (fullPage) {
+        const dims = await page.evaluate(() => ({
+            width: Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0),
+            height: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0),
+        }));
+        if (dims.width <= 0 || dims.height <= 0) {
+            return undefined;
         }
-    },
+        return { x: 0, y: 0, width: dims.width, height: dims.height };
+    }
+    const viewport = page.viewport();
+    if (viewport) {
+        return { x: 0, y: 0, width: viewport.width, height: viewport.height };
+    }
+    // The browser is launched and connected with `defaultViewport: null`, so
+    // `page.viewport()` stays null until something emulates one. Fall back to the
+    // window's own dimensions, which is the area a viewport screenshot captures.
+    const dims = await page.evaluate(() => ({
+        width: window.innerWidth,
+        height: window.innerHeight,
+    }));
+    if (dims.width <= 0 || dims.height <= 0) {
+        return undefined;
+    }
+    return { x: 0, y: 0, width: dims.width, height: dims.height };
+}
+function computeDownscaleClip(box, maxWidth, maxHeight) {
+    const widthScale = maxWidth !== undefined ? Math.min(1, maxWidth / box.width) : 1;
+    const heightScale = maxHeight !== undefined ? Math.min(1, maxHeight / box.height) : 1;
+    const scale = Math.min(widthScale, heightScale);
+    if (scale >= 1) {
+        return undefined;
+    }
+    // Skip degenerate sub-pixel results.
+    if (Math.round(box.width * scale) < 1 || Math.round(box.height * scale) < 1) {
+        return undefined;
+    }
+    return {
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: box.height,
+        scale,
+    };
+}
+export const screenshot = definePageTool(args => {
+    const { screenshotFormat, screenshotQuality, screenshotMaxWidth, screenshotMaxHeight, } = args ?? {};
+    const defaultFormat = screenshotFormat ?? 'png';
+    return {
+        name: 'take_screenshot',
+        description: `Take a screenshot of the page or element.`,
+        annotations: {
+            category: ToolCategory.DEBUGGING,
+            // Not read-only due to filePath param.
+            readOnlyHint: false,
+        },
+        schema: {
+            format: zod
+                .enum(['png', 'jpeg', 'webp'])
+                .default(defaultFormat)
+                .describe(`Type of format to save the screenshot as. Default is "${defaultFormat}"`),
+            quality: zod
+                .number()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
+            uid: zod
+                .string()
+                .optional()
+                .describe('The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.'),
+            fullPage: zod
+                .boolean()
+                .optional()
+                .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
+            filePath: zod
+                .string()
+                .optional()
+                .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
+        },
+        blockedByDialog: true,
+        verifyFilesSchema: {
+            filePath: true,
+        },
+        handler: async (request, response, context) => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (request.params.uid && request.params.fullPage) {
+                    throw new Error('Providing both "uid" and "fullPage" is not allowed.');
+                }
+                const page = request.page.pptrPage;
+                const element = __addDisposableResource(env_1, request.params.uid
+                    ? await request.page.getElementByUid(request.params.uid)
+                    : undefined, false);
+                const format = request.params.format;
+                const quality = format === 'png'
+                    ? undefined
+                    : (request.params.quality ?? screenshotQuality);
+                const fullPage = request.params.fullPage ?? false;
+                // `getElementByUid` mints a fresh ElementHandle per call, so dispose it
+                // once the capture is done to avoid leaking a remote object for the life
+                // of the page's execution context.
+                let screenshot;
+                // Compute a downscale clip when --screenshot-max-width or
+                // --screenshot-max-height is set and the source exceeds either bound.
+                // The smaller scale factor wins so both bounds are respected while
+                // preserving aspect ratio.
+                let clip;
+                if (screenshotMaxWidth !== undefined ||
+                    screenshotMaxHeight !== undefined) {
+                    const box = await getSourceBox(page, element, fullPage);
+                    if (box) {
+                        clip = computeDownscaleClip(box, screenshotMaxWidth, screenshotMaxHeight);
+                    }
+                }
+                if (clip) {
+                    // page.screenshot with clip lets the CDP scale param downscale the
+                    // capture for viewport, full-page and element shots alike. We rely on
+                    // Puppeteer's default of captureBeyondViewport=true when a clip is
+                    // present so element/full-page captures below the fold still work.
+                    screenshot = await page.screenshot({
+                        type: format,
+                        quality,
+                        optimizeForSpeed: true,
+                        clip,
+                    });
+                }
+                else if (element) {
+                    screenshot = await element.screenshot({
+                        type: format,
+                        quality,
+                        optimizeForSpeed: true,
+                    });
+                }
+                else {
+                    screenshot = await page.screenshot({
+                        type: format,
+                        fullPage,
+                        quality,
+                        optimizeForSpeed: true,
+                    });
+                }
+                if (request.params.uid) {
+                    response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
+                }
+                else if (fullPage) {
+                    response.appendResponseLine('Took a screenshot of the full current page.');
+                }
+                else {
+                    response.appendResponseLine("Took a screenshot of the current page's viewport.");
+                }
+                // Narrow `format` at the point of use: in the factory form of
+                // definePageTool TS widens the Schema generic, which loses the literal
+                // union from zod.enum on request.params.format.
+                const extension = format === 'jpeg' ? '.jpeg' : format === 'webp' ? '.webp' : '.png';
+                if (request.params.filePath) {
+                    const result = await context.saveFile(screenshot, request.params.filePath, extension);
+                    response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
+                }
+                else if (screenshot.length >= 2_000_000) {
+                    const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot${extension}`);
+                    response.appendResponseLine(`Saved screenshot to ${filepath}.`);
+                }
+                else {
+                    response.attachImage({
+                        mimeType: `image/${format}`,
+                        data: Buffer.from(screenshot).toString('base64'),
+                    });
+                }
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        },
+    };
 });
 //# sourceMappingURL=screenshot.js.map

package/build/src/tools/script.js

@@ -3,29 +3,74 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { zod } from '../third_party/index.js';
-import { appendWaitForResult } from '../WaitForHelper.js';
 import { ToolCategory } from './categories.js';
 import { defineTool, pageIdSchema } from './ToolDefinition.js';
 export const evaluateScript = defineTool(cliArgs => {
     return {
         name: 'evaluate_script',
-        description: `Evaluate a JavaScript function inside the currently selected page${cliArgs?.categoryExtensions ? ' or service worker' : ''}. Returns the response as JSON,
-so returned values have to be JSON-serializable.`,
+        description: `Evaluate a JavaScript function inside the currently selected page${cliArgs?.categoryExtensions ? ' or service worker' : ''}. Returns the response as JSON, so returned values have to be JSON-serializable.`,
         annotations: {
             category: ToolCategory.DEBUGGING,
             readOnlyHint: false,
         },
         schema: {
+            ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
             function: zod.string().describe(`A JavaScript function declaration to be executed by the tool in the currently selected page.
-Example without arguments: \`() => {
-  return document.title
-}\` or \`async () => {
-  return await fetch("example.com")
-}\`.
-Example with arguments: \`(el) => {
-  return el.innerText;
-}\`
+Example without arguments: \`() => document.title\` or \`async () => await fetch("example.com")\`.
+Example with arguments: \`(el) => el.innerText\`
 `),
             args: zod
                 .array(zod
@@ -33,11 +78,18 @@ Example with arguments: \`(el) => {
                 .describe('The uid of an element on the page from the page content snapshot'))
                 .optional()
                 .describe(`An optional list of arguments to pass to the function.`),
+            filePath: zod
+                .string()
+                .optional()
+                .describe('The absolute or relative path to a file to save the script output to. If omitted, the output is returned inline.'),
             dialogAction: zod
                 .string()
                 .optional()
                 .describe('Handle dialogs while execution. "accept", "dismiss", or string for response of window.prompt. Defaults to accept.'),
-            ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
+            waitForStableDom: zod
+                .boolean()
+                .optional()
+                .describe('Whether to wait for the DOM to settle. Pass false if the script only reads data. Defaults to true.'),
             ...(cliArgs?.categoryExtensions
                 ? {
                     serviceWorkerId: zod
@@ -48,62 +100,95 @@ Example with arguments: \`(el) => {
                 : {}),
         },
         blockedByDialog: true,
+        verifyFilesSchema: {
+            filePath: true,
+        },
         handler: async (request, response, context) => {
-            const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, } = request.params;
-            if (cliArgs?.categoryExtensions && serviceWorkerId) {
-                if (uidArgs && uidArgs.length > 0) {
-                    throw new Error('args (element uids) cannot be used when evaluating in a service worker.');
-                }
-                if (pageId) {
-                    throw new Error('specify either a pageId or a serviceWorkerId.');
-                }
-                const worker = await getWebWorker(context, serviceWorkerId);
-                const result = await context
-                    .getSelectedMcpPage()
-                    .waitForEventsAfterAction(async () => {
-                    await performEvaluation(worker, fnString, [], response);
-                }, { handleDialog: dialogAction ?? 'accept' });
-                appendWaitForResult(response, result);
-                return;
-            }
-            const mcpPage = cliArgs?.experimentalPageIdRouting
-                ? context.getPageById(request.params.pageId)
-                : context.getSelectedMcpPage();
-            const page = mcpPage.pptrPage;
-            const args = [];
+            const env_1 = { stack: [], error: void 0, hasError: false };
             try {
+                const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, filePath, waitForStableDom, } = request.params;
+                if (cliArgs?.categoryExtensions && serviceWorkerId) {
+                    if (uidArgs && uidArgs.length > 0) {
+                        throw new Error('args (element uids) cannot be used when evaluating in a service worker.');
+                    }
+                    if (pageId) {
+                        throw new Error('specify either a pageId or a serviceWorkerId.');
+                    }
+                    const worker = await getWebWorker(context, serviceWorkerId);
+                    const result = await context
+                        .getSelectedMcpPage()
+                        .waitForEventsAfterAction(async () => {
+                        await performEvaluation(worker, fnString, [], response, {
+                            filePath,
+                            context,
+                        });
+                    }, 
+                    // Service workers cannot interact with the DOM, so never wait for it.
+                    { handleDialog: dialogAction ?? 'accept', waitForStableDom: false });
+                    if (result.dialogHandled) {
+                        context.getSelectedMcpPage().clearDialog();
+                    }
+                    response.attachWaitForResult(result);
+                    return;
+                }
+                const mcpPage = cliArgs?.experimentalPageIdRouting
+                    ? context.getPageById(request.params.pageId)
+                    : context.getSelectedMcpPage();
+                const page = mcpPage.pptrPage;
+                const args = [];
+                const stack = __addDisposableResource(env_1, new DisposableStack(), false);
                 const frames = new Set();
                 for (const uid of uidArgs ?? []) {
                     const handle = await mcpPage.getElementByUid(uid);
                     frames.add(handle.frame);
+                    stack.use(handle);
                     args.push(handle);
                 }
                 const evaluatable = await getPageOrFrame(page, frames);
                 const result = await mcpPage.waitForEventsAfterAction(async () => {
-                    await performEvaluation(evaluatable, fnString, args, response);
-                }, { handleDialog: dialogAction ?? 'accept' });
-                appendWaitForResult(response, result);
+                    await performEvaluation(evaluatable, fnString, args, response, {
+                        filePath,
+                        context,
+                    });
+                }, { handleDialog: dialogAction ?? 'accept', waitForStableDom });
+                response.attachWaitForResult(result);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
             }
             finally {
-                void Promise.allSettled(args.map(arg => arg.dispose()));
+                __disposeResources(env_1);
             }
         },
     };
 });
-const performEvaluation = async (evaluatable, fnString, args, response) => {
-    const fn = await evaluatable.evaluateHandle(`(${fnString})`);
+const performEvaluation = async (evaluatable, fnString, args, response, options) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
     try {
+        const fn = __addDisposableResource(env_2, await evaluatable.evaluateHandle(`(${fnString})`), false);
         const result = await evaluatable.evaluate(async (fn, ...args) => {
             // @ts-expect-error no types for function fn
             return JSON.stringify(await fn(...args));
         }, fn, ...args);
-        response.appendResponseLine('Script ran on page and returned:');
-        response.appendResponseLine('```json');
-        response.appendResponseLine(`${result}`);
-        response.appendResponseLine('```');
+        if (options?.filePath) {
+            const data = new TextEncoder().encode(result ?? 'undefined');
+            const { filename } = await options.context.saveFile(data, options.filePath, '.json');
+            response.appendResponseLine(`Script ran on page. Output saved to ${filename}.`);
+        }
+        else {
+            response.appendResponseLine('Script ran on page and returned:');
+            response.appendResponseLine('```json');
+            response.appendResponseLine(`${result}`);
+            response.appendResponseLine('```');
+        }
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
     }
     finally {
-        void fn.dispose();
+        __disposeResources(env_2);
     }
 };
 const getPageOrFrame = async (page, frames) => {

package/build/src/tools/slim/tools.js

@@ -16,6 +16,7 @@ export const screenshot = definePageTool({
     },
     schema: {},
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response, context) => {
         const page = request.page;
         const screenshot = await page.pptrPage.screenshot({
@@ -37,6 +38,7 @@ export const navigate = definePageTool({
         url: zod.string().describe('URL to navigate to'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
         const page = request.page;
         const options = {
@@ -71,6 +73,7 @@ export const evaluate = definePageTool({
         script: zod.string().describe(`JS script to run on the page`),
     },
     blockedByDialog: true,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
         const page = request.page;
         try {

package/build/src/tools/snapshot.js

@@ -27,8 +27,10 @@ in the DevTools Elements panel (if any).`,
             .describe('The absolute path, or a path relative to the current working directory, to save the snapshot to instead of attaching it to the response.'),
     },
     blockedByDialog: true,
-    handler: async (request, response, context) => {
-        context.validatePath(request.params.filePath);
+    verifyFilesSchema: {
+        filePath: true,
+    },
+    handler: async (request, response) => {
         response.includeSnapshot({
             verbose: request.params.verbose ?? false,
             filePath: request.params.filePath,
@@ -50,9 +52,10 @@ export const waitFor = definePageTool({
         ...timeoutSchema,
     },
     blockedByDialog: true,
-    handler: async (request, response, context) => {
+    verifyFilesSchema: {},
+    handler: async (request, response) => {
         const page = request.page;
-        await context.waitForTextOnPage(request.params.text, request.params.timeout, page.pptrPage);
+        await page.waitForTextOnPage(request.params.text, request.params.timeout);
         response.appendResponseLine(`Element matching one of ${JSON.stringify(request.params.text)} found.`);
         response.includeSnapshot();
     },

package/build/src/tools/thirdPartyDeveloper.js

@@ -9,19 +9,20 @@ import { definePageTool } from './ToolDefinition.js';
 export const listThirdPartyDeveloperTools = definePageTool({
     name: 'list_3p_developer_tools',
     description: `Lists all third-party developer tools the page exposes for providing runtime information.
-  Third-party developer tools can be called via the 'execute_3p_developer_tool()' MCP tool.
-  Alternatively, third-party developer tools can be executed by calling 'evaluate_script' and adding the
-  following command to the script:
-  'window.__dtmcp.executeTool(toolName, params)'
-  This might be helpful when the third-party developer tools return non-serializable values or when composing
-  third-party developer tools with additional functionality.`,
+Third-party developer tools can be called via the 'execute_3p_developer_tool()' MCP tool.
+Alternatively, third-party developer tools can be executed by calling 'evaluate_script' and adding the
+following command to the script:
+\`window.__dtmcp.executeTool(toolName, params)\`
+This might be helpful when the third-party developer tools return non-serializable values or when composing
+third-party developer tools with additional functionality.`,
     annotations: {
         category: ToolCategory.THIRD_PARTY,
         readOnlyHint: true,
     },
     schema: {},
     blockedByDialog: false,
-    handler: async (_request, response, _context) => {
+    verifyFilesSchema: {},
+    handler: async (_request, response) => {
         response.setListThirdPartyDeveloperTools();
     },
 });
@@ -40,6 +41,7 @@ export const executeThirdPartyDeveloperTool = definePageTool({
             .describe('The JSON-stringified parameters to pass to the tool'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: {},
     handler: async (request, response) => {
         const toolName = request.params.toolName;
         let params = {};
@@ -58,8 +60,16 @@ export const executeThirdPartyDeveloperTool = definePageTool({
                 throw new Error(`Failed to parse params as JSON: ${errorMessage}`);
             }
         }
-        const toolGroup = request.page.getThirdPartyDeveloperTools();
-        const tool = toolGroup?.tools.find(t => t.name === toolName);
+        const toolGroups = request.page.getThirdPartyDeveloperTools();
+        let tool;
+        if (toolGroups) {
+            for (const group of toolGroups) {
+                tool = group.tools?.find(t => t.name === toolName);
+                if (tool) {
+                    break;
+                }
+            }
+        }
         if (!tool) {
             throw new Error(`Tool ${toolName} not found`);
         }