@playwright/mcp 0.0.32 → 0.0.34

package/lib/response.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { renderModalStates } from './tab.js';
 export class Response {
     _result = [];
     _code = [];
@@ -20,9 +21,10 @@ export class Response {
     _context;
     _includeSnapshot = false;
     _includeTabs = false;
-    _snapshot;
+    _tabSnapshot;
     toolName;
     toolArgs;
+    _isError;
     constructor(context, toolName, toolArgs) {
         this._context = context;
         this.toolName = toolName;
@@ -31,6 +33,13 @@ export class Response {
     addResult(result) {
         this._result.push(result);
     }
+    addError(error) {
+        this._result.push(error);
+        this._isError = true;
+    }
+    isError() {
+        return this._isError;
+    }
     result() {
         return this._result.join('\n');
     }
@@ -52,16 +61,18 @@ export class Response {
     setIncludeTabs() {
         this._includeTabs = true;
     }
-    async snapshot() {
-        if (this._snapshot !== undefined)
-            return this._snapshot;
+    async finish() {
+        // All the async snapshotting post-action is happening here.
+        // Everything below should race against modal states.
         if (this._includeSnapshot && this._context.currentTab())
-            this._snapshot = await this._context.currentTabOrDie().captureSnapshot();
-        else
-            this._snapshot = '';
-        return this._snapshot;
+            this._tabSnapshot = await this._context.currentTabOrDie().captureSnapshot();
+        for (const tab of this._context.tabs())
+            await tab.updateTitle();
     }
-    async serialize() {
+    tabSnapshot() {
+        return this._tabSnapshot;
+    }
+    serialize() {
         const response = [];
         // Start with command result.
         if (this._result.length) {
@@ -79,11 +90,16 @@ ${this._code.join('\n')}
         }
         // List browser tabs.
         if (this._includeSnapshot || this._includeTabs)
-            response.push(...(await this._context.listTabsMarkdown(this._includeTabs)));
+            response.push(...renderTabsMarkdown(this._context.tabs(), this._includeTabs));
         // Add snapshot if provided.
-        const snapshot = await this.snapshot();
-        if (snapshot)
-            response.push(snapshot, '');
+        if (this._tabSnapshot?.modalStates.length) {
+            response.push(...renderModalStates(this._context, this._tabSnapshot.modalStates));
+            response.push('');
+        }
+        else if (this._tabSnapshot) {
+            response.push(renderTabSnapshot(this._tabSnapshot));
+            response.push('');
+        }
         // Main response part
         const content = [
             { type: 'text', text: response.join('\n') },
@@ -93,6 +109,57 @@ ${this._code.join('\n')}
             for (const image of this._images)
                 content.push({ type: 'image', data: image.data.toString('base64'), mimeType: image.contentType });
         }
-        return { content };
+        return { content, isError: this._isError };
+    }
+}
+function renderTabSnapshot(tabSnapshot) {
+    const lines = [];
+    if (tabSnapshot.consoleMessages.length) {
+        lines.push(`### New console messages`);
+        for (const message of tabSnapshot.consoleMessages)
+            lines.push(`- ${trim(message.toString(), 100)}`);
+        lines.push('');
+    }
+    if (tabSnapshot.downloads.length) {
+        lines.push(`### Downloads`);
+        for (const entry of tabSnapshot.downloads) {
+            if (entry.finished)
+                lines.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
+            else
+                lines.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
+        }
+        lines.push('');
+    }
+    lines.push(`### Page state`);
+    lines.push(`- Page URL: ${tabSnapshot.url}`);
+    lines.push(`- Page Title: ${tabSnapshot.title}`);
+    lines.push(`- Page Snapshot:`);
+    lines.push('```yaml');
+    lines.push(tabSnapshot.ariaSnapshot);
+    lines.push('```');
+    return lines.join('\n');
+}
+function renderTabsMarkdown(tabs, force = false) {
+    if (tabs.length === 1 && !force)
+        return [];
+    if (!tabs.length) {
+        return [
+            '### Open tabs',
+            'No open tabs. Use the "browser_navigate" tool to navigate to a page first.',
+            '',
+        ];
     }
+    const lines = ['### Open tabs'];
+    for (let i = 0; i < tabs.length; i++) {
+        const tab = tabs[i];
+        const current = tab.isCurrentTab() ? ' (current)' : '';
+        lines.push(`- ${i}:${current} [${tab.lastTitle()}] (${tab.page.url()})`);
+    }
+    lines.push('');
+    return lines;
+}
+function trim(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    return text.slice(0, maxLength) + '...';
 }

package/lib/sessionLog.js

@@ -15,56 +15,107 @@
  */
 import fs from 'fs';
 import path from 'path';
+import { logUnhandledError } from './utils/log.js';
 import { outputFile } from './config.js';
-let sessionOrdinal = 0;
 export class SessionLog {
     _folder;
     _file;
     _ordinal = 0;
+    _pendingEntries = [];
+    _sessionFileQueue = Promise.resolve();
+    _flushEntriesTimeout;
     constructor(sessionFolder) {
         this._folder = sessionFolder;
         this._file = path.join(this._folder, 'session.md');
     }
-    static async create(config) {
-        const sessionFolder = await outputFile(config, `session-${(++sessionOrdinal).toString().padStart(3, '0')}`);
+    static async create(config, rootPath) {
+        const sessionFolder = await outputFile(config, rootPath, `session-${Date.now()}`);
         await fs.promises.mkdir(sessionFolder, { recursive: true });
         // eslint-disable-next-line no-console
         console.error(`Session: ${sessionFolder}`);
         return new SessionLog(sessionFolder);
     }
-    async log(response) {
-        const prefix = `${(++this._ordinal).toString().padStart(3, '0')}`;
-        const lines = [
-            `### Tool: ${response.toolName}`,
-            ``,
-            `- Args`,
-            '```json',
-            JSON.stringify(response.toolArgs, null, 2),
-            '```',
-        ];
-        if (response.result()) {
-            lines.push(`- Result`, '```', response.result(), '```');
-        }
-        if (response.code()) {
-            lines.push(`- Code`, '```js', response.code(), '```');
+    logResponse(response) {
+        const entry = {
+            timestamp: performance.now(),
+            toolCall: {
+                toolName: response.toolName,
+                toolArgs: response.toolArgs,
+                result: response.result(),
+                isError: response.isError(),
+            },
+            code: response.code(),
+            tabSnapshot: response.tabSnapshot(),
+        };
+        this._appendEntry(entry);
+    }
+    logUserAction(action, tab, code, isUpdate) {
+        code = code.trim();
+        if (isUpdate) {
+            const lastEntry = this._pendingEntries[this._pendingEntries.length - 1];
+            if (lastEntry.userAction?.name === action.name) {
+                lastEntry.userAction = action;
+                lastEntry.code = code;
+                return;
+            }
         }
-        const snapshot = await response.snapshot();
-        if (snapshot) {
-            const fileName = `${prefix}.snapshot.yml`;
-            await fs.promises.writeFile(path.join(this._folder, fileName), snapshot);
-            lines.push(`- Snapshot: ${fileName}`);
+        if (action.name === 'navigate') {
+            // Already logged at this location.
+            const lastEntry = this._pendingEntries[this._pendingEntries.length - 1];
+            if (lastEntry?.tabSnapshot?.url === action.url)
+                return;
         }
-        for (const image of response.images()) {
-            const fileName = `${prefix}.screenshot.${extension(image.contentType)}`;
-            await fs.promises.writeFile(path.join(this._folder, fileName), image.data);
-            lines.push(`- Screenshot: ${fileName}`);
+        const entry = {
+            timestamp: performance.now(),
+            userAction: action,
+            code,
+            tabSnapshot: {
+                url: tab.page.url(),
+                title: '',
+                ariaSnapshot: action.ariaSnapshot || '',
+                modalStates: [],
+                consoleMessages: [],
+                downloads: [],
+            },
+        };
+        this._appendEntry(entry);
+    }
+    _appendEntry(entry) {
+        this._pendingEntries.push(entry);
+        if (this._flushEntriesTimeout)
+            clearTimeout(this._flushEntriesTimeout);
+        this._flushEntriesTimeout = setTimeout(() => this._flushEntries(), 1000);
+    }
+    async _flushEntries() {
+        clearTimeout(this._flushEntriesTimeout);
+        const entries = this._pendingEntries;
+        this._pendingEntries = [];
+        const lines = [''];
+        for (const entry of entries) {
+            const ordinal = (++this._ordinal).toString().padStart(3, '0');
+            if (entry.toolCall) {
+                lines.push(`### Tool call: ${entry.toolCall.toolName}`, `- Args`, '```json', JSON.stringify(entry.toolCall.toolArgs, null, 2), '```');
+                if (entry.toolCall.result) {
+                    lines.push(entry.toolCall.isError ? `- Error` : `- Result`, '```', entry.toolCall.result, '```');
+                }
+            }
+            if (entry.userAction) {
+                const actionData = { ...entry.userAction };
+                delete actionData.ariaSnapshot;
+                delete actionData.selector;
+                delete actionData.signals;
+                lines.push(`### User action: ${entry.userAction.name}`, `- Args`, '```json', JSON.stringify(actionData, null, 2), '```');
+            }
+            if (entry.code) {
+                lines.push(`- Code`, '```js', entry.code, '```');
+            }
+            if (entry.tabSnapshot) {
+                const fileName = `${ordinal}.snapshot.yml`;
+                fs.promises.writeFile(path.join(this._folder, fileName), entry.tabSnapshot.ariaSnapshot).catch(logUnhandledError);
+                lines.push(`- Snapshot: ${fileName}`);
+            }
+            lines.push('', '');
         }
-        lines.push('', '');
-        await fs.promises.appendFile(this._file, lines.join('\n'));
+        this._sessionFileQueue = this._sessionFileQueue.then(() => fs.promises.appendFile(this._file, lines.join('\n')));
     }
 }
-function extension(contentType) {
-    if (contentType === 'image/jpeg')
-        return 'jpg';
-    return 'png';
-}

package/lib/tab.js

@@ -15,15 +15,15 @@
  */
 import { EventEmitter } from 'events';
 import { callOnPageNoTrace, waitForCompletion } from './tools/utils.js';
-import { logUnhandledError } from './log.js';
-import { ManualPromise } from './manualPromise.js';
-import { outputFile } from './config.js';
+import { logUnhandledError } from './utils/log.js';
+import { ManualPromise } from './utils/manualPromise.js';
 export const TabEvents = {
     modalState: 'modalState'
 };
 export class Tab extends EventEmitter {
     context;
     page;
+    _lastTitle = 'about:blank';
     _consoleMessages = [];
     _recentConsoleMessages = [];
     _requests = new Map();
@@ -53,6 +53,10 @@ export class Tab extends EventEmitter {
         });
         page.setDefaultNavigationTimeout(60000);
         page.setDefaultTimeout(5000);
+        page[tabSymbol] = this;
+    }
+    static forPage(page) {
+        return page[tabSymbol];
     }
     modalStates() {
         return this._modalStates;
@@ -65,14 +69,7 @@ export class Tab extends EventEmitter {
         this._modalStates = this._modalStates.filter(state => state !== modalState);
     }
     modalStatesMarkdown() {
-        const result = ['### Modal state'];
-        if (this._modalStates.length === 0)
-            result.push('- There is no modal state present');
-        for (const state of this._modalStates) {
-            const tool = this.context.tools.filter(tool => 'clearsModalState' in tool).find(tool => tool.clearsModalState === state.type);
-            result.push(`- [${state.description}]: can be handled by the "${tool?.schema.name}" tool`);
-        }
-        return result;
+        return renderModalStates(this.context, this.modalStates());
     }
     _dialogShown(dialog) {
         this.setModalState({
@@ -85,7 +82,7 @@ export class Tab extends EventEmitter {
         const entry = {
             download,
             finished: false,
-            outputFile: await outputFile(this.context.config, download.suggestedFilename())
+            outputFile: await this.context.outputFile(download.suggestedFilename())
         };
         this._downloads.push(entry);
         await download.saveAs(entry.outputFile);
@@ -104,8 +101,16 @@ export class Tab extends EventEmitter {
         this._clearCollectedArtifacts();
         this._onPageClose(this);
     }
-    async title() {
-        return await callOnPageNoTrace(this.page, page => page.title());
+    async updateTitle() {
+        await this._raceAgainstModalStates(async () => {
+            this._lastTitle = await callOnPageNoTrace(this.page, page => page.title());
+        });
+    }
+    lastTitle() {
+        return this._lastTitle;
+    }
+    isCurrentTab() {
+        return this === this.context.currentTab();
     }
     async waitForLoadState(state, options) {
         await callOnPageNoTrace(this.page, page => page.waitForLoadState(state, options).catch(logUnhandledError));
@@ -142,54 +147,46 @@ export class Tab extends EventEmitter {
     requests() {
         return this._requests;
     }
-    _takeRecentConsoleMarkdown() {
-        if (!this._recentConsoleMessages.length)
-            return [];
-        const result = this._recentConsoleMessages.map(message => {
-            return `- ${trim(message.toString(), 100)}`;
-        });
-        return [`### New console messages`, ...result, ''];
-    }
-    _listDownloadsMarkdown() {
-        if (!this._downloads.length)
-            return [];
-        const result = ['### Downloads'];
-        for (const entry of this._downloads) {
-            if (entry.finished)
-                result.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
-            else
-                result.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
-        }
-        result.push('');
-        return result;
-    }
     async captureSnapshot() {
-        const result = [];
-        if (this.modalStates().length) {
-            result.push(...this.modalStatesMarkdown());
-            return result.join('\n');
-        }
-        result.push(...this._takeRecentConsoleMarkdown());
-        result.push(...this._listDownloadsMarkdown());
-        await this._raceAgainstModalStates(async () => {
+        let tabSnapshot;
+        const modalStates = await this._raceAgainstModalStates(async () => {
             const snapshot = await this.page._snapshotForAI();
-            result.push(`### Page state`, `- Page URL: ${this.page.url()}`, `- Page Title: ${await this.page.title()}`, `- Page Snapshot:`, '```yaml', snapshot, '```');
+            tabSnapshot = {
+                url: this.page.url(),
+                title: await this.page.title(),
+                ariaSnapshot: snapshot,
+                modalStates: [],
+                consoleMessages: [],
+                downloads: this._downloads,
+            };
         });
-        return result.join('\n');
+        if (tabSnapshot) {
+            // Assign console message late so that we did not lose any to modal state.
+            tabSnapshot.consoleMessages = this._recentConsoleMessages;
+            this._recentConsoleMessages = [];
+        }
+        return tabSnapshot ?? {
+            url: this.page.url(),
+            title: '',
+            ariaSnapshot: '',
+            modalStates,
+            consoleMessages: [],
+            downloads: [],
+        };
     }
     _javaScriptBlocked() {
         return this._modalStates.some(state => state.type === 'dialog');
     }
     async _raceAgainstModalStates(action) {
         if (this.modalStates().length)
-            return this.modalStates()[0];
+            return this.modalStates();
         const promise = new ManualPromise();
-        const listener = (modalState) => promise.resolve(modalState);
+        const listener = (modalState) => promise.resolve([modalState]);
         this.once(TabEvents.modalState, listener);
         return await Promise.race([
             action().then(() => {
                 this.off(TabEvents.modalState, listener);
-                return undefined;
+                return [];
             }),
             promise,
         ]);
@@ -239,8 +236,14 @@ function pageErrorToConsoleMessage(errorOrValue) {
         toString: () => String(errorOrValue),
     };
 }
-function trim(text, maxLength) {
-    if (text.length <= maxLength)
-        return text;
-    return text.slice(0, maxLength) + '...';
+export function renderModalStates(context, modalStates) {
+    const result = ['### Modal state'];
+    if (modalStates.length === 0)
+        result.push('- There is no modal state present');
+    for (const state of modalStates) {
+        const tool = context.tools.filter(tool => 'clearsModalState' in tool).find(tool => tool.clearsModalState === state.type);
+        result.push(`- [${state.description}]: can be handled by the "${tool?.schema.name}" tool`);
+    }
+    return result;
 }
+const tabSymbol = Symbol('tabSymbol');

package/lib/tools/common.js

@@ -43,7 +43,6 @@ const resize = defineTabTool({
         type: 'readOnly',
     },
     handle: async (tab, params, response) => {
-        response.addCode(`// Resize browser window to ${params.width}x${params.height}`);
         response.addCode(`await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`);
         await tab.waitForCompletion(async () => {
             await tab.page.setViewportSize({ width: params.width, height: params.height });

package/lib/tools/evaluate.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 import { generateLocator } from './utils.js';
 const evaluateSchema = z.object({
     function: z.string().describe('() => { /* code */ } or (element) => { /* code */ } when element is provided'),

package/lib/tools/files.js

@@ -31,7 +31,6 @@ const uploadFile = defineTabTool({
         const modalState = tab.modalStates().find(state => state.type === 'fileChooser');
         if (!modalState)
             throw new Error('No file chooser visible');
-        response.addCode(`// Select files for upload`);
         response.addCode(`await fileChooser.setFiles(${JSON.stringify(params.paths)})`);
         tab.clearModalState(modalState);
         await tab.waitForCompletion(async () => {

package/lib/tools/keyboard.js

@@ -17,7 +17,7 @@ import { z } from 'zod';
 import { defineTabTool } from './tool.js';
 import { elementSchema } from './snapshot.js';
 import { generateLocator } from './utils.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 const pressKey = defineTabTool({
     capability: 'core',
     schema: {
@@ -57,12 +57,10 @@ const type = defineTabTool({
         await tab.waitForCompletion(async () => {
             if (params.slowly) {
                 response.setIncludeSnapshot();
-                response.addCode(`// Press "${params.text}" sequentially into "${params.element}"`);
                 response.addCode(`await page.${await generateLocator(locator)}.pressSequentially(${javascript.quote(params.text)});`);
                 await locator.pressSequentially(params.text);
             }
             else {
-                response.addCode(`// Fill "${params.text}" into "${params.element}"`);
                 response.addCode(`await page.${await generateLocator(locator)}.fill(${javascript.quote(params.text)});`);
                 await locator.fill(params.text);
             }

package/lib/tools/navigate.js

@@ -30,7 +30,6 @@ const navigate = defineTool({
         const tab = await context.ensureTab();
         await tab.navigate(params.url);
         response.setIncludeSnapshot();
-        response.addCode(`// Navigate to ${params.url}`);
         response.addCode(`await page.goto('${params.url}');`);
     },
 });
@@ -46,7 +45,6 @@ const goBack = defineTabTool({
     handle: async (tab, params, response) => {
         await tab.page.goBack();
         response.setIncludeSnapshot();
-        response.addCode(`// Navigate back`);
         response.addCode(`await page.goBack();`);
     },
 });
@@ -62,7 +60,6 @@ const goForward = defineTabTool({
     handle: async (tab, params, response) => {
         await tab.page.goForward();
         response.setIncludeSnapshot();
-        response.addCode(`// Navigate forward`);
         response.addCode(`await page.goForward();`);
     },
 });

package/lib/tools/pdf.js

@@ -15,8 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-import * as javascript from '../javascript.js';
-import { outputFile } from '../config.js';
+import * as javascript from '../utils/codegen.js';
 const pdfSchema = z.object({
     filename: z.string().optional().describe('File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified.'),
 });
@@ -30,8 +29,7 @@ const pdf = defineTabTool({
         type: 'readOnly',
     },
     handle: async (tab, params, response) => {
-        const fileName = await outputFile(tab.context.config, params.filename ?? `page-${new Date().toISOString()}.pdf`);
-        response.addCode(`// Save page as ${fileName}`);
+        const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.pdf`);
         response.addCode(`await page.pdf(${javascript.formatObject({ path: fileName })});`);
         response.addResult(`Saved page as ${fileName}`);
         await tab.page.pdf({ path: fileName });

package/lib/tools/screenshot.js

@@ -15,11 +15,10 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-import * as javascript from '../javascript.js';
-import { outputFile } from '../config.js';
+import * as javascript from '../utils/codegen.js';
 import { generateLocator } from './utils.js';
 const screenshotSchema = z.object({
-    raw: z.boolean().optional().describe('Whether to return without compression (in PNG format). Default is false, which returns a JPEG image.'),
+    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.'),
@@ -45,11 +44,11 @@ const screenshot = defineTabTool({
         type: 'readOnly',
     },
     handle: async (tab, params, response) => {
-        const fileType = params.raw ? 'png' : 'jpeg';
-        const fileName = await outputFile(tab.context.config, params.filename ?? `page-${new Date().toISOString()}.${fileType}`);
+        const fileType = params.type || 'png';
+        const fileName = await tab.context.outputFile(params.filename ?? `page-${new Date().toISOString()}.${fileType}`);
         const options = {
             type: fileType,
-            quality: fileType === 'png' ? undefined : 50,
+            quality: fileType === 'png' ? undefined : 90,
             scale: 'css',
             path: fileName,
             ...(params.fullPage !== undefined && { fullPage: params.fullPage })
@@ -65,10 +64,14 @@ const screenshot = defineTabTool({
             response.addCode(`await page.screenshot(${javascript.formatObject(options)});`);
         const buffer = locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
         response.addResult(`Took the ${screenshotTarget} screenshot and saved it as ${fileName}`);
-        response.addImage({
-            contentType: fileType === 'png' ? 'image/png' : 'image/jpeg',
-            data: buffer
-        });
+        // https://github.com/microsoft/playwright-mcp/issues/817
+        // Never return large images to LLM, saving them to the file system is enough.
+        if (!params.fullPage) {
+            response.addImage({
+                contentType: fileType === 'png' ? 'image/png' : 'image/jpeg',
+                data: buffer
+            });
+        }
     }
 });
 export default [

package/lib/tools/snapshot.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool, defineTool } from './tool.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 import { generateLocator } from './utils.js';
 const snapshot = defineTool({
     capability: 'core',
@@ -53,14 +53,10 @@ const click = defineTabTool({
         const locator = await tab.refLocator(params);
         const button = params.button;
         const buttonAttr = button ? `{ button: '${button}' }` : '';
-        if (params.doubleClick) {
-            response.addCode(`// Double click ${params.element}`);
+        if (params.doubleClick)
             response.addCode(`await page.${await generateLocator(locator)}.dblclick(${buttonAttr});`);
-        }
-        else {
-            response.addCode(`// Click ${params.element}`);
+        else
             response.addCode(`await page.${await generateLocator(locator)}.click(${buttonAttr});`);
-        }
         await tab.waitForCompletion(async () => {
             if (params.doubleClick)
                 await locator.dblclick({ button });
@@ -128,7 +124,6 @@ const selectOption = defineTabTool({
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
         const locator = await tab.refLocator(params);
-        response.addCode(`// Select options [${params.values.join(', ')}] in ${params.element}`);
         response.addCode(`await page.${await generateLocator(locator)}.selectOption(${javascript.formatObject(params.values)});`);
         await tab.waitForCompletion(async () => {
             await locator.selectOption(params.values);

package/lib/tools/tool.js

@@ -23,10 +23,11 @@ export function defineTabTool(tool) {
             const tab = context.currentTabOrDie();
             const modalStates = tab.modalStates().map(state => state.type);
             if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState))
-                throw new Error(`The tool "${tool.schema.name}" can only be used when there is related modal state present.\n` + tab.modalStatesMarkdown().join('\n'));
-            if (!tool.clearsModalState && modalStates.length)
-                throw new Error(`Tool "${tool.schema.name}" does not handle the modal state.\n` + tab.modalStatesMarkdown().join('\n'));
-            return tool.handle(tab, params, response);
+                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);
         },
     };
 }

package/lib/tools/utils.js

@@ -60,13 +60,6 @@ export async function waitForCompletion(tab, callback) {
         dispose();
     }
 }
-export function sanitizeForFilePath(s) {
-    const sanitize = (s) => s.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, '-');
-    const separator = s.lastIndexOf('.');
-    if (separator === -1)
-        return sanitize(s);
-    return sanitize(s.substring(0, separator)) + '.' + sanitize(s.substring(separator + 1));
-}
 export async function generateLocator(locator) {
     try {
         const { resolvedSelector } = await locator._resolveSelector();