@tontoko/fast-playwright-mcp 0.0.4

package/lib/tools/navigate.js

@@ -0,0 +1,82 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/navigate.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import {
+  generateBackCode,
+  generateForwardCode,
+  generateNavigationCode
+} from "../utils/common-formatters.js";
+import { defineTabTool, defineTool } from "./tool.js";
+var navigate = defineTool({
+  capability: "core",
+  schema: {
+    name: "browser_navigate",
+    title: "Navigate to a URL",
+    description: `Navigate to a URL.expectation:{includeSnapshot:true} to see what loaded,false if you know what to do next.snapshotOptions:{selector:"#content"} to focus on main content(saves 50% tokens).diffOptions:{enabled:true} when revisiting pages to see only changes.CONSIDER batch_execute for navigate→interact workflows.`,
+    inputSchema: z.object({
+      url: z.string().describe("The URL to navigate to"),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (context, params, response) => {
+    const tab = await context.ensureTab();
+    await tab.navigate(params.url);
+    response.addCode(generateNavigationCode(params.url));
+  }
+});
+var goBack = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_navigate_back",
+    title: "Go back",
+    description: "Go back to previous page.expectation:{includeSnapshot:true} to see previous page,false if continuing workflow.diffOptions:{enabled:true} shows only what changed from forward page.USE batch_execute for back→interact sequences.",
+    inputSchema: z.object({
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, _params, response) => {
+    await tab.page.goBack();
+    response.addCode(generateBackCode());
+  }
+});
+var goForward = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_navigate_forward",
+    title: "Go forward",
+    description: "Go forward to next page.expectation:{includeSnapshot:true} to see next page,false if continuing workflow.diffOptions:{enabled:true} shows only what changed from previous page.USE batch_execute for forward→interact sequences.",
+    inputSchema: z.object({
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, _params, response) => {
+    await tab.page.goForward();
+    response.addCode(generateForwardCode());
+  }
+});
+var navigate_default = [navigate, goBack, goForward];
+export {
+  navigate_default as default
+};

package/lib/tools/network.js

@@ -0,0 +1,50 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/network.ts
+import { z } from "zod";
+import { defineTabTool } from "./tool.js";
+var requests = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_network_requests",
+    title: "List network requests",
+    description: "Returns all network requests since loading the page",
+    inputSchema: z.object({}),
+    type: "readOnly"
+  },
+  handle: async (tab, _params, response) => {
+    const requestList = await Promise.resolve(tab.requests());
+    for (const [req, res] of requestList.entries()) {
+      response.addResult(renderRequest(req, res));
+    }
+  }
+});
+function renderRequest(request, response) {
+  const result = [];
+  result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
+  if (response) {
+    result.push(`=> [${response.status()}] ${response.statusText()}`);
+  }
+  return result.join(" ");
+}
+var network_default = [requests];
+export {
+  network_default as default
+};

package/lib/tools/pdf.js

@@ -0,0 +1,46 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/pdf.ts
+import { z } from "zod";
+import { formatObject } from "../javascript.js";
+import { defineTabTool } from "./tool.js";
+var pdfSchema = z.object({
+  filename: z.string().optional().describe("File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified.")
+});
+var pdf = defineTabTool({
+  capability: "pdf",
+  schema: {
+    name: "browser_pdf_save",
+    title: "Save as PDF",
+    description: "Save page as PDF",
+    inputSchema: pdfSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.pdf`);
+    response.addCode(`await page.pdf(${formatObject({ path: fileName })});`);
+    response.addResult(`Saved page as ${fileName}`);
+    await tab.page.pdf({ path: fileName });
+  }
+});
+var pdf_default = [pdf];
+export {
+  pdf_default as default
+};

package/lib/tools/screenshot.js

@@ -0,0 +1,113 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/screenshot.ts
+import { z } from "zod";
+import { formatObject } from "../javascript.js";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTabTool } from "./tool.js";
+import { generateLocator } from "./utils.js";
+var screenshotSchema = z.object({
+  type: z.enum(["png", "jpeg"]).default("png").describe("Image format for the screenshot. Default is png."),
+  filename: z.string().optional().describe("File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified."),
+  element: z.string().optional().describe("Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too."),
+  ref: z.string().optional().describe("Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too."),
+  fullPage: z.boolean().optional().describe("When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots."),
+  expectation: expectationSchema
+}).refine((data) => {
+  return !!data.element === !!data.ref;
+}, {
+  message: "Both element and ref must be provided or neither.",
+  path: ["ref", "element"]
+}).refine((data) => {
+  return !(data.fullPage && (data.element || data.ref));
+}, {
+  message: "fullPage cannot be used with element screenshots.",
+  path: ["fullPage"]
+});
+async function prepareFileName(context, filename, fileType) {
+  const defaultName = `page-${new Date().toISOString()}.${fileType}`;
+  return await context.outputFile(filename ?? defaultName);
+}
+function createScreenshotOptions(fileType, fileName, fullPage) {
+  return {
+    type: fileType,
+    quality: fileType === "png" ? undefined : 90,
+    scale: "css",
+    path: fileName,
+    ...fullPage !== undefined && { fullPage }
+  };
+}
+function isElementScreenshotRequest(params) {
+  return !!(params.element && params.ref);
+}
+function getScreenshotTarget(params, isElementScreenshot) {
+  if (isElementScreenshot && params.element) {
+    return params.element;
+  }
+  return params.fullPage ? "full page" : "viewport";
+}
+async function getScreenshotLocator(tab, params, isElementScreenshot) {
+  if (!(isElementScreenshot && params.element && params.ref)) {
+    return null;
+  }
+  return await tab.refLocator({ element: params.element, ref: params.ref });
+}
+async function addScreenshotCode(response, locator, options) {
+  if (locator) {
+    response.addCode(`await page.${await generateLocator(locator)}.screenshot(${formatObject(options)});`);
+  } else {
+    response.addCode(`await page.screenshot(${formatObject(options)});`);
+  }
+}
+async function takeScreenshot(tab, locator, options) {
+  return locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
+}
+var screenshot = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_take_screenshot",
+    title: "Take a screenshot",
+    description: `Take a screenshot of current page.Returns image data.expectation:{includeSnapshot:false} to avoid redundant accessibility tree(screenshot≠snapshot).imageOptions:{quality:50,format:"jpeg"} for 70% size reduction.fullPage:true for entire page,element+ref for specific element.USE CASES:visual verification,documentation,error capture.`,
+    inputSchema: screenshotSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const fileType = params.type ?? "png";
+    const fileName = await prepareFileName(tab.context, params.filename, fileType);
+    const options = createScreenshotOptions(fileType, fileName, params.fullPage);
+    const isElementScreenshot = isElementScreenshotRequest(params);
+    const screenshotTarget = getScreenshotTarget(params, isElementScreenshot);
+    response.addCode(`// Screenshot ${screenshotTarget} and save it as ${fileName}`);
+    const locator = await getScreenshotLocator(tab, params, isElementScreenshot);
+    await addScreenshotCode(response, locator, options);
+    const buffer = await takeScreenshot(tab, locator, options);
+    response.addResult(`Took the ${screenshotTarget} screenshot and saved it as ${fileName}`);
+    if (!params.fullPage) {
+      response.addImage({
+        contentType: fileType === "png" ? "image/png" : "image/jpeg",
+        data: buffer
+      });
+    }
+  }
+});
+var screenshot_default = [screenshot];
+export {
+  screenshot_default as default
+};

package/lib/tools/snapshot.js

@@ -0,0 +1,158 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/snapshot.ts
+import { z } from "zod";
+import { formatObject } from "../javascript.js";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTabTool, defineTool } from "./tool.js";
+import { generateLocator } from "./utils.js";
+var snapshot = defineTool({
+  capability: "core",
+  schema: {
+    name: "browser_snapshot",
+    title: "Page snapshot",
+    description: `Capture accessibility snapshot of current page.AVOID calling directly - use expectation:{includeSnapshot:true} on other tools instead.USE CASES:Initial page inspection,debugging when other tools didn't capture needed info.snapshotOptions:{selector:"#content"} to focus on specific area.`,
+    inputSchema: z.object({
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    await context.ensureTab();
+    response.setIncludeSnapshot();
+    if (params.expectation?.snapshotOptions) {
+      const tab = context.currentTabOrDie();
+      const options = params.expectation.snapshotOptions;
+      const tabSnapshot = await tab.capturePartialSnapshot(options.selector, options.maxLength);
+      response.setTabSnapshot(tabSnapshot);
+    }
+  }
+});
+var elementSchema = z.object({
+  element: z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: z.string().describe("Exact target element reference from the page snapshot")
+});
+var clickSchema = elementSchema.extend({
+  doubleClick: z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
+  button: z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
+  expectation: expectationSchema
+});
+var click = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_click",
+    title: "Click",
+    description: `Perform click on web page.USE batch_execute for multi-click workflows.expectation:{includeSnapshot:false} when next action follows immediately,true to verify result.diffOptions:{enabled:true,format:"minimal"} shows only changes(saves 80% tokens).snapshotOptions:{selector:".result"} to focus on result area.doubleClick:true for double-click,button:"right" for context menu.`,
+    inputSchema: clickSchema,
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    const locator = await tab.refLocator(params);
+    const button = params.button;
+    const buttonAttr = button ? `{ button: '${button}' }` : "";
+    if (params.doubleClick) {
+      response.addCode(`await page.${await generateLocator(locator)}.dblclick(${buttonAttr});`);
+    } else {
+      response.addCode(`await page.${await generateLocator(locator)}.click(${buttonAttr});`);
+    }
+    await tab.waitForCompletion(async () => {
+      if (params.doubleClick) {
+        await locator.dblclick({ button });
+      } else {
+        await locator.click({ button });
+      }
+    });
+    if (params.expectation?.includeSnapshot) {
+      const newSnapshot = await tab.captureSnapshot();
+      response.setTabSnapshot(newSnapshot);
+    }
+  }
+});
+var drag = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_drag",
+    title: "Drag mouse",
+    description: `Perform drag and drop between two elements.expectation:{includeSnapshot:true,snapshotOptions:{selector:".drop-zone"}} to verify drop result.diffOptions:{enabled:true} shows only what moved.CONSIDER batch_execute if part of larger workflow.`,
+    inputSchema: z.object({
+      startElement: z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
+      startRef: z.string().describe("Exact source element reference from the page snapshot"),
+      endElement: z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
+      endRef: z.string().describe("Exact target element reference from the page snapshot"),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    const [startLocator, endLocator] = await tab.refLocators([
+      { ref: params.startRef, element: params.startElement },
+      { ref: params.endRef, element: params.endElement }
+    ]);
+    await tab.waitForCompletion(async () => {
+      await startLocator.dragTo(endLocator);
+    });
+    response.addCode(`await page.${await generateLocator(startLocator)}.dragTo(page.${await generateLocator(endLocator)});`);
+  }
+});
+var hover = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_hover",
+    title: "Hover mouse",
+    description: `Hover over element on page.expectation:{includeSnapshot:true} to capture tooltips/dropdown menus,false for simple hover.snapshotOptions:{selector:".tooltip"} to focus on tooltip area.Often followed by click - use batch_execute for hover→click sequences.`,
+    inputSchema: elementSchema.extend({
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const locator = await tab.refLocator(params);
+    response.addCode(`await page.${await generateLocator(locator)}.hover();`);
+    await tab.waitForCompletion(async () => {
+      await locator.hover();
+    });
+  }
+});
+var selectOptionSchema = elementSchema.extend({
+  values: z.array(z.string()).describe("Array of values to select in the dropdown. This can be a single value or multiple values."),
+  expectation: expectationSchema
+});
+var selectOption = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_select_option",
+    title: "Select option",
+    description: `Select option in dropdown.values:["option1","option2"] for multi-select.expectation:{includeSnapshot:false} when part of form filling(use batch),true to verify selection.snapshotOptions:{selector:"form"} for form context.USE batch_execute for form workflows with multiple selects.`,
+    inputSchema: selectOptionSchema,
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    const locator = await tab.refLocator(params);
+    response.addCode(`await page.${await generateLocator(locator)}.selectOption(${formatObject(params.values)});`);
+    await tab.waitForCompletion(async () => {
+      await locator.selectOption(params.values);
+    });
+  }
+});
+var snapshot_default = [snapshot, click, drag, hover, selectOption];
+export {
+  elementSchema,
+  snapshot_default as default
+};

package/lib/tools/tabs.js

@@ -0,0 +1,97 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/tabs.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTool } from "./tool.js";
+var listTabs = defineTool({
+  capability: "core-tabs",
+  schema: {
+    name: "browser_tab_list",
+    title: "List tabs",
+    description: "List browser tabs.Always returns tab list with titles and URLs.expectation:{includeSnapshot:false} for just tab info,true to also see current tab content.USE before tab_select to find right tab.",
+    inputSchema: z.object({
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, _params, response) => {
+    await context.ensureTab();
+    response.setIncludeTabs();
+  }
+});
+var selectTab = defineTool({
+  capability: "core-tabs",
+  schema: {
+    name: "browser_tab_select",
+    title: "Select a tab",
+    description: `Select a tab by index.expectation:{includeSnapshot:true} to see selected tab content,false if you know what's there.USE batch_execute for tab_select→interact workflows.`,
+    inputSchema: z.object({
+      index: z.number().describe("The index of the tab to select"),
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    await context.selectTab(params.index);
+    response.setIncludeSnapshot();
+  }
+});
+var newTab = defineTool({
+  capability: "core-tabs",
+  schema: {
+    name: "browser_tab_new",
+    title: "Open a new tab",
+    description: `Open a new tab.url:"https://example.com" to navigate immediately,omit for blank tab.expectation:{includeSnapshot:true} to see new tab,false if opening for later use.CONSIDER batch_execute for new_tab→navigate→interact.`,
+    inputSchema: z.object({
+      url: z.string().optional().describe("The URL to navigate to in the new tab. If not provided, the new tab will be blank."),
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const tab = await context.newTab();
+    if (params.url) {
+      await tab.navigate(params.url);
+    }
+    response.setIncludeSnapshot();
+  }
+});
+var closeTab = defineTool({
+  capability: "core-tabs",
+  schema: {
+    name: "browser_tab_close",
+    title: "Close a tab",
+    description: "Close a tab.index:N to close specific tab,omit to close current.expectation:{includeSnapshot:false} usually sufficient,true to verify remaining tabs.USE batch_execute for multi-tab cleanup.",
+    inputSchema: z.object({
+      index: z.number().optional().describe("The index of the tab to close. Closes current tab if not provided."),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (context, params, response) => {
+    await context.closeTab(params.index);
+    response.setIncludeSnapshot();
+  }
+});
+var tabs_default = [listTabs, newTab, selectTab, closeTab];
+export {
+  tabs_default as default
+};

package/lib/tools/tool.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/tool.ts
+function defineTool(tool) {
+  return tool;
+}
+function defineTabTool(tool) {
+  return {
+    ...tool,
+    handle: async (context, params, response) => {
+      const tab = context.currentTabOrDie();
+      const modalStates = tab.modalStates().map((state) => state.type);
+      if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState)) {
+        response.addError(`Error: The tool "${tool.schema.name}" can only be used when there is related modal state present.
+` + tab.modalStatesMarkdown().join(`
+`));
+      } else if (!tool.clearsModalState && modalStates.length) {
+        response.addError(`Error: Tool "${tool.schema.name}" does not handle the modal state.
+` + tab.modalStatesMarkdown().join(`
+`));
+      } else {
+        return await tool.handle(tab, params, response);
+      }
+    }
+  };
+}
+export {
+  defineTool,
+  defineTabTool
+};