@ejazullah/browser-mcp 0.0.56

package/lib/tools/selectors.js

@@ -0,0 +1,233 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTabTool } from './tool.js';
+// Schema for CSS selector based operations
+const cssSelectorSchema = z.object({
+    selector: z.string().describe('CSS selector to target the element (e.g., "#id", ".class", "button", "[data-test=\'value\']")'),
+    attribute: z.string().optional().describe('Optional attribute to get instead of text content (e.g., "href", "src", "value")'),
+    index: z.number().optional().describe('Index of element if multiple elements match (0-based)'),
+});
+// Schema for XPath selector based operations
+const xpathSelectorSchema = z.object({
+    xpath: z.string().describe('XPath expression to target the element (e.g., "//button[@id=\'submit\']", "//div[contains(@class, \'content\')]")'),
+    attribute: z.string().optional().describe('Optional attribute to get instead of text content (e.g., "href", "src", "value")'),
+});
+// Schema for text-based locators
+const textSelectorSchema = z.object({
+    text: z.string().describe('Text content to search for in elements'),
+    elementType: z.string().optional().describe('Element type to filter by (e.g., "button", "a", "div")'),
+    exact: z.boolean().optional().default(false).describe('Whether to match text exactly or use contains'),
+    attribute: z.string().optional().describe('Optional attribute to get instead of text content'),
+});
+// Schema for role-based locators (accessibility)
+const roleSelectorSchema = z.object({
+    role: z.string().describe('ARIA role of the element (e.g., "button", "link", "textbox", "heading")'),
+    name: z.string().optional().describe('Accessible name of the element'),
+    level: z.number().optional().describe('Level for headings (1-6)'),
+    attribute: z.string().optional().describe('Optional attribute to get instead of text content'),
+});
+const getTextByCSS = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_get_text_by_css',
+        title: 'Get text by CSS selector',
+        description: 'Get text content or attribute from element using CSS selector',
+        inputSchema: cssSelectorSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            let locator = tab.page.locator(params.selector);
+            // If index is specified and multiple elements might match
+            if (params.index !== undefined) {
+                locator = locator.nth(params.index);
+            }
+            let result;
+            if (params.attribute) {
+                result = await locator.getAttribute(params.attribute) || '';
+                response.addCode(`const attributeValue = await page.locator('${params.selector}')${params.index !== undefined ? `.nth(${params.index})` : ''}.getAttribute('${params.attribute}');`);
+            }
+            else {
+                result = await locator.textContent() || '';
+                response.addCode(`const textContent = await page.locator('${params.selector}')${params.index !== undefined ? `.nth(${params.index})` : ''}.textContent();`);
+            }
+            response.addResult(`${params.attribute ? `Attribute "${params.attribute}"` : 'Text content'}: ${result}`);
+        }
+        catch (error) {
+            response.addError(`Failed to get ${params.attribute ? `attribute "${params.attribute}"` : 'text content'} using CSS selector "${params.selector}": ${error}`);
+        }
+    },
+});
+const getTextByXPath = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_get_text_by_xpath',
+        title: 'Get text by XPath',
+        description: 'Get text content or attribute from element using XPath expression',
+        inputSchema: xpathSelectorSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = tab.page.locator(`xpath=${params.xpath}`);
+            let result;
+            if (params.attribute) {
+                result = await locator.getAttribute(params.attribute) || '';
+                response.addCode(`const attributeValue = await page.locator('xpath=${params.xpath}').getAttribute('${params.attribute}');`);
+            }
+            else {
+                result = await locator.textContent() || '';
+                response.addCode(`const textContent = await page.locator('xpath=${params.xpath}').textContent();`);
+            }
+            response.addResult(`${params.attribute ? `Attribute "${params.attribute}"` : 'Text content'}: ${result}`);
+        }
+        catch (error) {
+            response.addError(`Failed to get ${params.attribute ? `attribute "${params.attribute}"` : 'text content'} using XPath "${params.xpath}": ${error}`);
+        }
+    },
+});
+const getTextByText = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_get_text_by_text',
+        title: 'Get text by text content',
+        description: 'Find element by its text content and get text or attribute',
+        inputSchema: textSelectorSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            let locator;
+            if (params.elementType) {
+                // Filter by element type first
+                if (params.exact) {
+                    locator = tab.page.locator(params.elementType).filter({ hasText: new RegExp(`^${params.text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`) });
+                }
+                else {
+                    locator = tab.page.locator(params.elementType).filter({ hasText: params.text });
+                }
+            }
+            else {
+                // Search in all elements
+                if (params.exact) {
+                    locator = tab.page.getByText(params.text, { exact: true });
+                }
+                else {
+                    locator = tab.page.getByText(params.text);
+                }
+            }
+            let result;
+            if (params.attribute) {
+                result = await locator.getAttribute(params.attribute) || '';
+                response.addCode(`const attributeValue = await page.${params.elementType ? `locator('${params.elementType}').filter({ hasText: '${params.text}' })` : `getByText('${params.text}'${params.exact ? ', { exact: true }' : ''})`}.getAttribute('${params.attribute}');`);
+            }
+            else {
+                result = await locator.textContent() || '';
+                response.addCode(`const textContent = await page.${params.elementType ? `locator('${params.elementType}').filter({ hasText: '${params.text}' })` : `getByText('${params.text}'${params.exact ? ', { exact: true }' : ''})`}.textContent();`);
+            }
+            response.addResult(`${params.attribute ? `Attribute "${params.attribute}"` : 'Text content'}: ${result}`);
+        }
+        catch (error) {
+            response.addError(`Failed to get ${params.attribute ? `attribute "${params.attribute}"` : 'text content'} for element with text "${params.text}": ${error}`);
+        }
+    },
+});
+const getTextByRole = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_get_text_by_role',
+        title: 'Get text by ARIA role',
+        description: 'Get text content or attribute from element using ARIA role',
+        inputSchema: roleSelectorSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            let locator;
+            if (params.role === 'heading' && params.level) {
+                locator = tab.page.getByRole('heading', { level: params.level, name: params.name });
+            }
+            else if (params.name) {
+                locator = tab.page.getByRole(params.role, { name: params.name });
+            }
+            else {
+                locator = tab.page.getByRole(params.role);
+            }
+            let result;
+            if (params.attribute) {
+                result = await locator.getAttribute(params.attribute) || '';
+                response.addCode(`const attributeValue = await page.getByRole('${params.role}'${params.name ? `, { name: '${params.name}' }` : ''}${params.level ? `, { level: ${params.level} }` : ''}).getAttribute('${params.attribute}');`);
+            }
+            else {
+                result = await locator.textContent() || '';
+                response.addCode(`const textContent = await page.getByRole('${params.role}'${params.name ? `, { name: '${params.name}' }` : ''}${params.level ? `, { level: ${params.level} }` : ''}).textContent();`);
+            }
+            response.addResult(`${params.attribute ? `Attribute "${params.attribute}"` : 'Text content'}: ${result}`);
+        }
+        catch (error) {
+            response.addError(`Failed to get ${params.attribute ? `attribute "${params.attribute}"` : 'text content'} for ${params.role} element: ${error}`);
+        }
+    },
+});
+// Tool to get all text from multiple elements
+const getAllText = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_get_all_text',
+        title: 'Get all text from multiple elements',
+        description: 'Get text content from all elements matching a CSS selector',
+        inputSchema: z.object({
+            selector: z.string().describe('CSS selector to target multiple elements'),
+            attribute: z.string().optional().describe('Optional attribute to get instead of text content'),
+            limit: z.number().optional().default(10).describe('Maximum number of elements to process'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = tab.page.locator(params.selector);
+            const count = await locator.count();
+            const limit = Math.min(count, params.limit || 10);
+            const results = [];
+            for (let i = 0; i < limit; i++) {
+                const elementLocator = locator.nth(i);
+                let result;
+                if (params.attribute) {
+                    result = await elementLocator.getAttribute(params.attribute) || '';
+                }
+                else {
+                    result = await elementLocator.textContent() || '';
+                }
+                if (result.trim()) {
+                    results.push(`[${i}] ${result}`);
+                }
+            }
+            response.addCode(`const elements = await page.locator('${params.selector}').all();\nconst results = await Promise.all(elements.slice(0, ${limit}).map(el => el.${params.attribute ? `getAttribute('${params.attribute}')` : 'textContent()'}));`);
+            response.addResult(`Found ${count} elements, showing first ${limit}:\n${results.join('\n')}`);
+        }
+        catch (error) {
+            response.addError(`Failed to get ${params.attribute ? `attribute "${params.attribute}"` : 'text content'} from elements matching "${params.selector}": ${error}`);
+        }
+    },
+});
+export default [
+    getTextByCSS,
+    getTextByXPath,
+    getTextByText,
+    getTextByRole,
+    getAllText,
+];

package/lib/tools/snapshot.js

@@ -0,0 +1,169 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTabTool, defineTool } from './tool.js';
+import * as javascript from '../javascript.js';
+import { generateLocator } from './utils.js';
+const snapshot = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_snapshot',
+        title: 'Page snapshot',
+        description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context, params, response) => {
+        await context.ensureTab();
+        response.setIncludeSnapshot();
+    },
+});
+export const 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'),
+});
+const 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'),
+});
+const click = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_click',
+        title: 'Click',
+        description: 'Perform click on a web page',
+        inputSchema: clickSchema,
+        type: 'destructive',
+    },
+    handle: async (tab, params, response) => {
+        response.setIncludeSnapshot();
+        // Get locator with selector information for database logging
+        const { locator, selector, resolvedSelector } = await tab.refLocatorWithSelector(params);
+        // Store element interaction data for database logging
+        response.setElementInteraction({
+            elementRef: params.ref,
+            elementDescription: params.element,
+            playwrightSelector: selector,
+            resolvedSelector: resolvedSelector,
+        });
+        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 });
+        });
+    },
+});
+const drag = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_drag',
+        title: 'Drag mouse',
+        description: 'Perform drag and drop between two elements',
+        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'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (tab, params, response) => {
+        response.setIncludeSnapshot();
+        // Get locators with selector information for database logging
+        const startInfo = await tab.refLocatorWithSelector({ ref: params.startRef, element: params.startElement });
+        const endInfo = await tab.refLocatorWithSelector({ ref: params.endRef, element: params.endElement });
+        // Store element interaction data for database logging (log start element primarily)
+        response.setElementInteraction({
+            elementRef: params.startRef,
+            elementDescription: `${params.startElement} -> ${params.endElement}`,
+            playwrightSelector: startInfo.selector,
+            resolvedSelector: startInfo.resolvedSelector,
+        });
+        await tab.waitForCompletion(async () => {
+            await startInfo.locator.dragTo(endInfo.locator);
+        });
+        response.addCode(`await page.${await generateLocator(startInfo.locator)}.dragTo(page.${await generateLocator(endInfo.locator)});`);
+    },
+});
+const hover = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_hover',
+        title: 'Hover mouse',
+        description: 'Hover over element on page',
+        inputSchema: elementSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        response.setIncludeSnapshot();
+        // Get locator with selector information for database logging
+        const { locator, selector, resolvedSelector } = await tab.refLocatorWithSelector(params);
+        // Store element interaction data for database logging
+        response.setElementInteraction({
+            elementRef: params.ref,
+            elementDescription: params.element,
+            playwrightSelector: selector,
+            resolvedSelector: resolvedSelector,
+        });
+        response.addCode(`await page.${await generateLocator(locator)}.hover();`);
+        await tab.waitForCompletion(async () => {
+            await locator.hover();
+        });
+    },
+});
+const 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.'),
+});
+const selectOption = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_select_option',
+        title: 'Select option',
+        description: 'Select an option in a dropdown',
+        inputSchema: selectOptionSchema,
+        type: 'destructive',
+    },
+    handle: async (tab, params, response) => {
+        response.setIncludeSnapshot();
+        // Get locator with selector information for database logging
+        const { locator, selector, resolvedSelector } = await tab.refLocatorWithSelector(params);
+        // Store element interaction data for database logging
+        response.setElementInteraction({
+            elementRef: params.ref,
+            elementDescription: params.element,
+            playwrightSelector: selector,
+            resolvedSelector: resolvedSelector,
+        });
+        response.addCode(`await page.${await generateLocator(locator)}.selectOption(${javascript.formatObject(params.values)});`);
+        await tab.waitForCompletion(async () => {
+            await locator.selectOption(params.values);
+        });
+    },
+});
+export default [
+    snapshot,
+    click,
+    drag,
+    hover,
+    selectOption,
+];

package/lib/tools/states.js

@@ -0,0 +1,147 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTabTool } from './tool.js';
+import { elementSchema } from './snapshot.js';
+import { generateLocator } from './utils.js';
+// Check if element is visible
+const isVisible = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_is_visible',
+        title: 'Check if element is visible',
+        description: 'Check if an element is visible on the page',
+        inputSchema: elementSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = await tab.refLocator(params);
+            const visible = await locator.isVisible();
+            response.addCode(`const isVisible = await page.${await generateLocator(locator)}.isVisible();`);
+            response.addResult(`Element is ${visible ? 'visible' : 'not visible'}`);
+        }
+        catch (error) {
+            response.addError(`Failed to check visibility: ${error}`);
+        }
+    },
+});
+// Check if element is enabled
+const isEnabled = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_is_enabled',
+        title: 'Check if element is enabled',
+        description: 'Check if an element is enabled (not disabled)',
+        inputSchema: elementSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = await tab.refLocator(params);
+            const enabled = await locator.isEnabled();
+            response.addCode(`const isEnabled = await page.${await generateLocator(locator)}.isEnabled();`);
+            response.addResult(`Element is ${enabled ? 'enabled' : 'disabled'}`);
+        }
+        catch (error) {
+            response.addError(`Failed to check if element is enabled: ${error}`);
+        }
+    },
+});
+// Check if checkbox/radio is checked
+const isChecked = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_is_checked',
+        title: 'Check if checkbox/radio is selected',
+        description: 'Check if a checkbox or radio button is checked/selected',
+        inputSchema: elementSchema,
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = await tab.refLocator(params);
+            const checked = await locator.isChecked();
+            response.addCode(`const isChecked = await page.${await generateLocator(locator)}.isChecked();`);
+            response.addResult(`Element is ${checked ? 'checked' : 'not checked'}`);
+        }
+        catch (error) {
+            response.addError(`Failed to check if element is checked: ${error}`);
+        }
+    },
+});
+// Wait for element to appear/disappear
+const waitForElement = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_wait_for_element',
+        title: 'Wait for element state',
+        description: 'Wait for an element to appear, disappear, or change state',
+        inputSchema: elementSchema.extend({
+            state: z.enum(['visible', 'hidden', 'attached', 'detached']).default('visible').describe('State to wait for'),
+            timeout: z.number().optional().default(5000).describe('Timeout in milliseconds'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = await tab.refLocator(params);
+            await locator.waitFor({
+                state: params.state,
+                timeout: params.timeout
+            });
+            response.addCode(`await page.${await generateLocator(locator)}.waitFor({ state: '${params.state}', timeout: ${params.timeout} });`);
+            response.addResult(`Element is now ${params.state}`);
+            if (params.state === 'visible' || params.state === 'attached') {
+                response.setIncludeSnapshot();
+            }
+        }
+        catch (error) {
+            response.addError(`Failed to wait for element to be ${params.state}: ${error}`);
+        }
+    },
+});
+// Count matching elements
+const getElementCount = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_get_element_count',
+        title: 'Count elements',
+        description: 'Count the number of elements matching a CSS selector',
+        inputSchema: z.object({
+            selector: z.string().describe('CSS selector to count elements'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        try {
+            const locator = tab.page.locator(params.selector);
+            const count = await locator.count();
+            response.addCode(`const count = await page.locator('${params.selector}').count();`);
+            response.addResult(`Found ${count} elements matching "${params.selector}"`);
+        }
+        catch (error) {
+            response.addError(`Failed to count elements: ${error}`);
+        }
+    },
+});
+export default [
+    isVisible,
+    isEnabled,
+    isChecked,
+    waitForElement,
+    getElementCount,
+];

package/lib/tools/tabs.js

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTool } from './tool.js';
+const listTabs = defineTool({
+    capability: 'core-tabs',
+    schema: {
+        name: 'browser_tab_list',
+        title: 'List tabs',
+        description: 'List browser tabs',
+        inputSchema: z.object({}),
+        type: 'readOnly',
+    },
+    handle: async (context, params, response) => {
+        await context.ensureTab();
+        response.setIncludeTabs();
+    },
+});
+const selectTab = defineTool({
+    capability: 'core-tabs',
+    schema: {
+        name: 'browser_tab_select',
+        title: 'Select a tab',
+        description: 'Select a tab by index',
+        inputSchema: z.object({
+            index: z.number().describe('The index of the tab to select'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context, params, response) => {
+        await context.selectTab(params.index);
+        response.setIncludeSnapshot();
+    },
+});
+const newTab = defineTool({
+    capability: 'core-tabs',
+    schema: {
+        name: 'browser_tab_new',
+        title: 'Open a new tab',
+        description: 'Open a new tab',
+        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.'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (context, params, response) => {
+        const tab = await context.newTab();
+        if (params.url)
+            await tab.navigate(params.url);
+        response.setIncludeSnapshot();
+    },
+});
+const closeTab = defineTool({
+    capability: 'core-tabs',
+    schema: {
+        name: 'browser_tab_close',
+        title: 'Close a tab',
+        description: 'Close a tab',
+        inputSchema: z.object({
+            index: z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (context, params, response) => {
+        await context.closeTab(params.index);
+        response.setIncludeSnapshot();
+    },
+});
+export default [
+    listTabs,
+    newTab,
+    selectTab,
+    closeTab,
+];

package/lib/tools/tool.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export function defineTool(tool) {
+    return tool;
+}
+export 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.\n` + tab.modalStatesMarkdown().join('\n'));
+            else if (!tool.clearsModalState && modalStates.length)
+                response.addError(`Error: Tool "${tool.schema.name}" does not handle the modal state.\n` + tab.modalStatesMarkdown().join('\n'));
+            else
+                return tool.handle(tab, params, response);
+        },
+    };
+}