fastbrowser_cli 1.0.30 → 1.0.33

package/src/fastbrowser_mcp/fastbrowser_mcp.ts

@@ -11,6 +11,7 @@ import { z } from "zod";
 import * as A11yParse from "a11y_parse";
 
 // local imports
+import { Logger } from "../shared/logger.js"
 import { McpMyClient } from "./libs/mcp_my_client.js";
 import { McpProxy } from "./libs/mcp_proxy.js";
 import { ResponseFormatter } from "./libs/response_formatter.js";
@@ -40,6 +41,10 @@ export {
 	type QuerySelectorsFirstInput,
 };
 
+const logger = Logger.fromMetaUrl(import.meta.url, {
+	allToStderr: true,
+});
+
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 //	
@@ -106,18 +111,32 @@ class MainHelper {
 		selector: string,
 		selectedNodes: A11yParse.AxNode[],
 		withAncestors: boolean,
+		withChildren: boolean,
 	): string {
-		let text: string = `## Node found for selector '${selector}' (${selectedNodes.length} node${selectedNodes.length > 1 ? 's' : ''}${withAncestors ? ', with ancestors' : ''}):\n`;
-		if (withAncestors) {
-			if (selectedNodes.length === 0) {
-				text += "No node found";
-			} else {
-				const ancestorTree = A11yParse.A11yTree.buildAncestorTree(selectedNodes);
-				text += A11yParse.A11yTree.stringify(ancestorTree);
+		const nodeCount = selectedNodes.length;
+		const pluralS = nodeCount > 1 ? 's' : '';
+		const ancestorsText = withAncestors ? ', with ancestors' : '';
+		const childrenText = withChildren ? ', with children' : '';
+		let text: string = `## Node${pluralS} found for selector '${selector}' (${nodeCount} node${pluralS}${ancestorsText}${childrenText}):`;
+		if (selectedNodes.length === 0) {
+			if (text.length > 0) text += '\n';
+			text += "No node found";
+		} else if (withAncestors === true) {
+			const subsetTree = A11yParse.A11yTree.buildSubsetTree(selectedNodes, {
+				withAncestors: true,
+				withChildren,
+			});
+			if (text.length > 0) text += '\n';
+			text += A11yParse.A11yDisplay.stringifyTree(subsetTree);
+		} else if (withChildren === true) {
+			for (const selectedNode of selectedNodes) {
+				if (text.length > 0) text += '\n';
+				text += A11yParse.A11yDisplay.stringifyTree(selectedNode);
 			}
 		} else {
 			for (const selectedNode of selectedNodes) {
-				text += A11yParse.A11yTree.stringify(selectedNode) + '\n';
+				if (text.length > 0) text += '\n';
+				text += A11yParse.A11yDisplay.stringifyNode(selectedNode);
 			}
 		}
 		text += '\n';
@@ -144,7 +163,7 @@ class MainHelper {
 				selectedNodes.splice(querySelector.limit);
 			}
 
-			responseTexts.push(this._formatSelectedNodes(querySelector.selector, selectedNodes, querySelector.withAncestors));
+			responseTexts.push(this._formatSelectedNodes(querySelector.selector, selectedNodes, querySelector.withAncestors, querySelector.withChildren));
 		}
 
 		// join the response texts for all selectors and return
@@ -167,7 +186,7 @@ class MainHelper {
 		for (const querySelector of querySelectors.selectors) {
 			const selectedNodes = A11yParse.A11yQuery.querySelectorAll(a11yTree, querySelector.selector);
 			const firstNode = selectedNodes.length > 0 ? [selectedNodes[0]] : [];
-			responseTexts.push(this._formatSelectedNodes(querySelector.selector, firstNode, querySelector.withAncestors));
+			responseTexts.push(this._formatSelectedNodes(querySelector.selector, firstNode, querySelector.withAncestors, querySelector.withChildren));
 		}
 
 		return responseTexts.join('\n');
@@ -195,10 +214,16 @@ class MainHelper {
 				inputSchema: z.object({}),
 			},
 			async () => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.listPages}: listing pages`);
+
 				const toolConfig = await McpTargetHelper.targetToolListPages(mcpTarget);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatListPages(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.listPages}: output:`)
+				logger.warn(`${outputStr}`);
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -228,11 +253,18 @@ class MainHelper {
 				// const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				// let outputStr = await ResponseFormatter.formatNewPage(mcpTarget, callToolResult, url);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.newPage}: url=${url}`);
+
+
 				// so working around this by calling the navigate_page tool instead of new_page when the target is playwright
 				const toolConfig = await McpTargetHelper.targetToolNavigatePage(mcpTarget, url);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatNavigatePage(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.newPage}: output:`)
+				logger.warn(`${outputStr}`);
 
 				return {
 					content: [{ type: "text", text: outputStr }],
@@ -255,10 +287,17 @@ class MainHelper {
 				}),
 			},
 			async ({ pageId }: { pageId: number }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.closePage}: pageId=${pageId}`);
+
 				const toolConfig = await McpTargetHelper.targetToolClosePage(mcpTarget, pageId);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatClosePage(mcpTarget, callToolResult, pageId);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.closePage}: output:`)
+				logger.warn(`${outputStr}`);
+
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -280,10 +319,17 @@ class MainHelper {
 				}),
 			},
 			async ({ url }: { url: string }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.navigatePage}: url=${url}`);
+
 				const toolConfig = await McpTargetHelper.targetToolNavigatePage(mcpTarget, url);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputStr = await ResponseFormatter.formatNavigatePage(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.navigatePage}: output:`)
+				logger.warn(`${outputStr}`);
+
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -303,9 +349,16 @@ class MainHelper {
 				inputSchema: z.object({}),
 			},
 			async () => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.takeSnapshot}: taking snapshot`);
+
 				const a11yText: string = await MainHelper._getA11yText(mcpClient);
 				let outputStr = a11yText
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.takeSnapshot}: output:`);
+				logger.warn(`${outputStr}`);
+
 				return {
 					content: [{ type: "text", text: outputStr }],
 				};
@@ -342,9 +395,16 @@ class MainHelper {
 				inputSchema: QuerySelectorsInputSchema,
 			},
 			async (querySelectorsInput: QuerySelectorsInput) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectorsAll}: querying selectors: ${JSON.stringify(querySelectorsInput)}`);
+
 				// query the accessibility tree with the provided selector
 				const outputText: string = await MainHelper.querySelectorsAll(mcpClient, querySelectorsInput);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectorsAll}: output:`);
+				logger.warn(`${outputText}`);
+
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -367,7 +427,15 @@ class MainHelper {
 				inputSchema: QuerySelectorsFirstInputSchema,
 			},
 			async (querySelectorsInput: QuerySelectorsFirstInput) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectors}: querying selectors: ${JSON.stringify(querySelectorsInput)}`);
+
 				const outputText: string = await MainHelper.querySelectors(mcpClient, querySelectorsInput);
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.querySelectors}: output:`);
+				logger.warn(`${outputText}`);
+
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -389,6 +457,9 @@ class MainHelper {
 				}),
 			},
 			async ({ keys }: { keys: string }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.pressKeys}: pressing keys: ${keys}`);
+
 				// Build the list of keys to send, splitting regular characters into individual key presses, but keeping special keys as-is
 				const keysToSend: string[] = [];
 				const keysSplit = keys.split(',').map((key) => key.trim());
@@ -419,6 +490,10 @@ class MainHelper {
 
 				let outputText = await ResponseFormatter.formatPressKeys(mcpTarget, keysToSend);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.pressKeys}: output:`);
+				logger.warn(`${outputText}`);
+
 				// return a response indicating which keys were pressed
 				return {
 					content: [{ type: "text", text: outputText }],
@@ -444,12 +519,17 @@ class MainHelper {
 				},
 			},
 			async ({ selector }: { selector: string }) => {
-				const uid = await MainHelper._resolveSelectorToUid(mcpClient, selector);
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.click}: clicking selector: ${selector}`);
 
+				const uid = await MainHelper._resolveSelectorToUid(mcpClient, selector);
 				const toolConfig = await McpTargetHelper.targetToolClick(mcpTarget, uid);
 				const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				let outputText = await ResponseFormatter.formatClick(mcpTarget, callToolResult);
 
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.click}: output:`);
+
 				return {
 					content: [{ type: "text", text: outputText }],
 				};
@@ -477,6 +557,9 @@ class MainHelper {
 				},
 			},
 			async ({ elements }: { elements: { selector: string; value: string }[] }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.fillForm}: filling form with elements: ${JSON.stringify(elements)}`);
+
 				const resolved = [];
 				for (const element of elements) {
 					const uid = await MainHelper._resolveSelectorToUid(mcpClient, element.selector);
@@ -485,32 +568,36 @@ class MainHelper {
 						value: element.value,
 					});
 				}
+				let callToolResult: CallToolResult;
 				if (mcpTarget === 'chrome_devtools') {
 					const toolConfig = await McpTargetHelper.targetToolFillForm(mcpTarget, resolved);
-					const callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
-					// const callToolResult = await mcpClient.callTool('fill_form', { elements: resolved });
-					return callToolResult
+					callToolResult = await mcpClient.callTool(toolConfig.toolName, toolConfig.toolArgs);
 				} else if (mcpTarget === 'playwright') {
 					type Field = {
 						name: string; // Human readable name for the field, e.g. "Email address"
 						// type can be textbox, checkbox, radio, combobox, or slider
 						type: 'textbox' | 'checkbox' | 'radio' | 'combobox' | 'slider';
 						// the uid of the field's corresponding node in the accessibility tree
-						ref: string;
+						target: string;
 						// the value to fill into the field - for checkboxes this can be "checked" or "unchecked", for radio buttons this can be "selected", for comboboxes this can be the option to select, and for sliders this can be the value to set the slider to
 						value: string
 					};
 					const fields: Field[] = resolved.map((element, index) => ({
 						name: `Field ${index + 1}`,
 						type: 'textbox', // for simplicity, we assume all fields are textboxes in this example
-						ref: element.uid,
+						target: element.uid,
 						value: element.value,
 					}));
-					const callToolResult = await mcpClient.callTool('browser_fill_form', { fields: fields });
-					return callToolResult
+					callToolResult = await mcpClient.callTool('browser_fill_form', { fields: fields });
 				} else {
 					throw new Error(`Unsupported MCP target: ${mcpTarget}`);
 				}
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.fillForm}: output:`);
+				logger.warn(`${JSON.stringify(callToolResult)}`);
+
+				return callToolResult
 			}
 		);
 
@@ -530,6 +617,10 @@ class MainHelper {
 				inputSchema: timezoneSchema,
 			},
 			async ({ timezone }) => {
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.getCurrentDateTime}: getting current date and time with timezone: ${timezone ?? 'local system timezone'}`);
+
+
 				const date = new Date();
 				const options: Intl.DateTimeFormatOptions = {
 					timeZone: timezone,
@@ -542,6 +633,10 @@ class MainHelper {
 					timeZoneName: "short",
 				};
 				const formatted = new Intl.DateTimeFormat("en-US", options).format(date);
+
+				// log the events
+				logger.warn(`${mcpTarget}:${McpTargetHelper.EXTERNAL_TOOL_NAME.getCurrentDateTime}: output: ${formatted}`);
+
 				return {
 					content: [{ type: "text", text: formatted }],
 				};
@@ -564,6 +659,11 @@ class MainHelper {
 		mcpTarget: FastBrowserMcpTarget,
 		verbose?: boolean
 	}): Promise<void> {
+		// Redirect process.stderr to a log file, so that the MCP communication is not polluted by logs.
+		const logFile = Path.resolve(import.meta.dirname, `../../outputs/fastbrowser_mcp_${new Date().toISOString()}.log`);
+		const logStream = Fs.createWriteStream(logFile, { flags: 'a' });
+		process.stderr.write = logStream.write.bind(logStream);
+
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
 		//	mcp client
@@ -616,11 +716,13 @@ class MainHelper {
 					{
 						selector: "link, button",
 						withAncestors: true,
+						withChildren: false,
 						limit: 0,
 					},
 					{
 						selector: 'heading[level="1"]',
 						withAncestors: false,
+						withChildren: false,
 						limit: 0,
 					},
 				],
@@ -646,19 +748,64 @@ class MainHelper {
 		for (const toolName of toolsToProxys) {
 			await mcpProxy.proxyToolCall(mcpClient, toolName)
 		}
+
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
 		//	.querySelectorsAll tool implementation
 		///////////////////////////////////////////////////////////////////////////////
 		///////////////////////////////////////////////////////////////////////////////
-		const mcpServer = await mcpProxy.getMcpServer();
 
+		const mcpServer = await mcpProxy.getMcpServer();
 		await MainHelper.initExternalTools(mcpServer, mcpClient);
 
-
 		// Connect the MCP proxy server to start accepting connections from MCP clients (e.g. LLM agents).
 		await mcpProxy.connect();
 	}
+
+	///////////////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////////////
+	//	.commandTargetTools: connect to the target MCP and print each tool's name, description, and input schema.
+	///////////////////////////////////////////////////////////////////////////////
+	///////////////////////////////////////////////////////////////////////////////
+
+	static async commandTargetTools({
+		mcpTarget,
+	}: {
+		mcpTarget: FastBrowserMcpTarget,
+	}): Promise<void> {
+		const { command: mcpCommand, args: mcpArgs } = McpTargetHelper.mcpArgs(mcpTarget);
+
+		const mcpClient = new McpMyClient({
+			name: 'fastbrowser_target_tools_client',
+			version: '1.0.0',
+			mcpTarget,
+			transport: {
+				type: 'stdio',
+				command: mcpCommand,
+				args: mcpArgs,
+			},
+		});
+
+		await mcpClient.connect();
+		try {
+			const tools = await mcpClient.listTools();
+			console.log(`# Tools available on MCP target '${mcpTarget}' (${tools.length})\n`);
+			for (const tool of tools) {
+				console.log(`## ${tool.name}`);
+				console.log('');
+				console.log(`### Description`)
+				console.log(`${tool.description ?? '(no description)'}`);
+				console.log('');
+				console.log(`### Input schema`);
+				console.log("```");
+				console.log(JSON.stringify(tool.inputSchema, null, 2));
+				console.log("```");
+				console.log('');
+			}
+		} finally {
+			await mcpClient.close();
+		}
+	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -668,12 +815,6 @@ class MainHelper {
 ///////////////////////////////////////////////////////////////////////////////
 
 async function main() {
-	// Redirect process.stderr to a log file, so that the MCP communication is not polluted by logs.
-	const logFile = Path.resolve(import.meta.dirname, `../../outputs/fastbrowser_mcp_${new Date().toISOString()}.log`);
-	const logStream = Fs.createWriteStream(logFile, { flags: 'a' });
-	process.stderr.write = logStream.write.bind(logStream);
-
-
 	// throw Error("This entry point is not meant to be run directly. Please run one of the npm scripts defined in package.json, e.g. 'npm run start:fastbrowser_mcp' or 'npm run inspect:fastbrowser_mcp:chrome_devtools'");
 
 	const program = new Command();
@@ -693,6 +834,20 @@ async function main() {
 			});
 		});
 
+	program
+		.command('target_tools')
+		.description('List the tools exposed by the target MCP (name, description, input schema)')
+		.addOption(
+			new Option('-b, --mcp_target <mcpTarget>', 'the MCP target to introspect')
+				.choices(['chrome_devtools', 'playwright'])
+				.default('playwright')
+		)
+		.action(async (options: { mcp_target: FastBrowserMcpTarget }) => {
+			await MainHelper.commandTargetTools({
+				mcpTarget: options.mcp_target,
+			});
+		});
+
 	// display help if no command is provided
 	if (process.argv.length < 3) {
 		program.help();

package/src/fastbrowser_mcp/libs/mcp_my_client.ts

@@ -1,4 +1,7 @@
+
+
 // node import
+import { Logger } from "../../shared/logger.js"
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -6,6 +9,12 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { CallToolResult, Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 import { FastBrowserMcpTarget } from "../fastbrowser_types.js";
 
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+//	
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
 export type StdioConfig = {
 	type: "stdio";
 	command: string;
@@ -34,6 +43,10 @@ export interface McpClientOptions {
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
+const logger = Logger.fromMetaUrl(import.meta.url, {
+	allToStderr: true,
+});
+
 // TODO remove this function - it seems to do vastly nothing - more confusing that helpful
 // - i use the McpServer directly, and i got a wrapper for the client... discrepancy is confusing
 export class McpMyClient {
@@ -57,9 +70,11 @@ export class McpMyClient {
 
 	async connect(): Promise<void> {
 		if (this.connected) return;
+		logger.warn(`McpMyClient:connect: Connecting to MCP with target ${this.mcpTarget}`);
 
 		this.transport = this.createTransport(this.options.transport);
 		await this.client.connect(this.transport);
+		logger.warn(`McpMyClient:connect: Connected to MCP with target ${this.mcpTarget}`);
 		this.connected = true;
 	}
 
@@ -72,6 +87,7 @@ export class McpMyClient {
 	async listTools(): Promise<Tool[]> {
 		this.assertConnected();
 		const { tools } = await this.client.listTools();
+		logger.warn(`McpMyClient:listTools: ${JSON.stringify(tools, null, 2)}`);
 		return tools;
 	}
 
@@ -80,6 +96,7 @@ export class McpMyClient {
 		args: Record<string, unknown> = {},
 	): Promise<CallToolResult> {
 		this.assertConnected();
+		logger.warn(`McpMyClient:callTool: name: ${name} args: ${JSON.stringify(args, null, 2)}`);
 		return this.client.callTool({ name, arguments: args }) as Promise<CallToolResult>;
 	}
 

package/src/fastbrowser_mcp/libs/mcp_target_helper.ts

@@ -182,9 +182,21 @@ export class McpTargetHelper {
 
 	static async targetToolClick(mcpTarget: FastBrowserMcpTarget, uid: string): Promise<TargetToolConfig> {
 		if (mcpTarget === 'chrome_devtools') {
-			return { toolName: 'click', toolArgs: { uid } };
+			const toolConfig: TargetToolConfig = {
+				toolName: 'click',
+				toolArgs: {
+					uid
+				}
+			};
+			return toolConfig;
 		} else if (mcpTarget === 'playwright') {
-			return { toolName: 'browser_click', toolArgs: { ref: uid } };
+			const toolConfig: TargetToolConfig = {
+				toolName: 'browser_click',
+				toolArgs: {
+					target: uid
+				}
+			};
+			return toolConfig;
 		} else {
 			throw new Error(`Unsupported MCP target: ${mcpTarget}`);
 		}
@@ -194,6 +206,7 @@ export class McpTargetHelper {
 		if (mcpTarget === 'chrome_devtools') {
 			return { toolName: 'fill_form', toolArgs: { elements } };
 		} else if (mcpTarget === 'playwright') {
+			// FIXME browser_fill_form tool exist in playwright MCP... implement it later
 			throw new Error(`Fill form tool is not supported for Playwright MCP target yet`);
 		} else {
 			throw new Error(`Unsupported MCP target: ${mcpTarget}`);

package/src/fastbrowser_mcp/libs/schemas.ts

@@ -18,6 +18,9 @@ export const QuerySelectorInputSchema = z.object({
 	withAncestors: z.boolean()
 		.describe("Whether to include ancestor nodes in the result")
 		.default(false),
+	withChildren: z.boolean()
+		.describe("Whether to include descendant nodes (subtree) of each matched node in the result")
+		.default(false),
 });
 
 export const QuerySelectorsInputSchema = z.object({
@@ -31,6 +34,9 @@ export const QuerySelectorFirstInputSchema = z.object({
 	withAncestors: z.boolean()
 		.describe("Whether to include ancestor nodes in the result")
 		.default(false),
+	withChildren: z.boolean()
+		.describe("Whether to include descendant nodes (subtree) of each matched node in the result")
+		.default(false),
 });
 
 export const QuerySelectorsFirstInputSchema = z.object({