chrome-devtools-mcp 0.17.3 → 0.18.0

package/build/src/daemon/daemon.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import { createServer } from 'node:net';
+import process from 'node:process';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { logger } from '../logger.js';
+import { PipeTransport } from '../third_party/index.js';
+import { VERSION } from '../version.js';
+import { getSocketPath, handlePidFile, INDEX_SCRIPT_PATH, IS_WINDOWS, } from './utils.js';
+const pidFile = handlePidFile();
+const socketPath = getSocketPath();
+let mcpClient = null;
+let mcpTransport = null;
+let server = null;
+async function setupMCPClient() {
+    console.log('Setting up MCP client connection...');
+    const args = process.argv.slice(2);
+    // Create stdio transport for chrome-devtools-mcp
+    mcpTransport = new StdioClientTransport({
+        command: process.execPath,
+        args: [INDEX_SCRIPT_PATH, ...args],
+        env: process.env,
+    });
+    mcpClient = new Client({
+        name: 'chrome-devtools-cli-daemon',
+        version: VERSION,
+    }, {
+        capabilities: {},
+    });
+    await mcpClient.connect(mcpTransport);
+    console.log('MCP client connected');
+}
+async function handleRequest(msg) {
+    try {
+        if (msg.method === 'invoke_tool') {
+            if (!mcpClient) {
+                throw new Error('MCP client not initialized');
+            }
+            const { tool, args } = msg;
+            const result = (await mcpClient.callTool({
+                name: tool,
+                arguments: args || {},
+            }));
+            return {
+                success: true,
+                result: JSON.stringify(result),
+            };
+        }
+        else if (msg.method === 'stop') {
+            // Trigger cleanup asynchronously
+            setImmediate(() => {
+                void cleanup();
+            });
+            return {
+                success: true,
+                message: 'stopping',
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: `Unknown method: ${JSON.stringify(msg, null, 2)}`,
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+async function startSocketServer() {
+    // Remove existing socket file if it exists (only on non-Windows)
+    if (!IS_WINDOWS) {
+        try {
+            await fs.unlink(socketPath);
+        }
+        catch {
+            // ignore errors.
+        }
+    }
+    return await new Promise((resolve, reject) => {
+        server = createServer(socket => {
+            const transport = new PipeTransport(socket, socket);
+            transport.onmessage = async (message) => {
+                logger('onmessage', message);
+                const response = await handleRequest(JSON.parse(message));
+                transport.send(JSON.stringify(response));
+                socket.end();
+            };
+            socket.on('error', error => {
+                logger('Socket error:', error);
+            });
+        });
+        server.listen({
+            path: socketPath,
+            readableAll: false,
+            writableAll: false,
+        }, async () => {
+            console.log(`Daemon server listening on ${socketPath}`);
+            try {
+                // Setup MCP client
+                await setupMCPClient();
+                resolve();
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        server.on('error', error => {
+            logger('Server error:', error);
+            reject(error);
+        });
+    });
+}
+async function cleanup() {
+    console.log('Cleaning up daemon...');
+    try {
+        await mcpClient?.close();
+    }
+    catch (error) {
+        logger('Error closing MCP client:', error);
+    }
+    try {
+        await mcpTransport?.close();
+    }
+    catch (error) {
+        logger('Error closing MCP transport:', error);
+    }
+    server?.close(() => {
+        if (!IS_WINDOWS) {
+            void fs.unlink(socketPath).catch(() => undefined);
+        }
+    });
+    await fs.unlink(pidFile).catch(() => undefined);
+    process.exit(0);
+}
+// Handle shutdown signals
+process.on('SIGTERM', () => {
+    void cleanup();
+});
+process.on('SIGINT', () => {
+    void cleanup();
+});
+process.on('SIGHUP', () => {
+    void cleanup();
+});
+// Handle uncaught errors
+process.on('uncaughtException', error => {
+    logger('Uncaught exception:', error);
+});
+process.on('unhandledRejection', error => {
+    logger('Unhandled rejection:', error);
+});
+// Start the server
+startSocketServer().catch(error => {
+    logger('Failed to start daemon server:', error);
+    process.exit(1);
+});

package/build/src/daemon/utils.js

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+export const DAEMON_SCRIPT_PATH = path.join(import.meta.dirname, 'daemon.js');
+export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'index.js');
+const APP_NAME = 'chrome-devtools-mcp';
+// Using these paths due to strict limits on the POSIX socket path length.
+export function getSocketPath() {
+    const uid = os.userInfo().uid;
+    if (IS_WINDOWS) {
+        // Windows uses Named Pipes, not file paths.
+        // This format is required for server.listen()
+        return path.join('\\\\.\\pipe', APP_NAME, 'server.sock');
+    }
+    // 1. Try XDG_RUNTIME_DIR (Linux standard, sometimes macOS)
+    if (process.env.XDG_RUNTIME_DIR) {
+        return path.join(process.env.XDG_RUNTIME_DIR, APP_NAME, 'server.sock');
+    }
+    // 2. macOS/Unix Fallback: Use /tmp/
+    // We use /tmp/ because it is much shorter than ~/Library/Application Support/
+    // and keeps us well under the 104-character limit.
+    return path.join('/tmp', `${APP_NAME}-${uid}.sock`);
+}
+export function getRuntimeHome() {
+    const platform = os.platform();
+    const uid = os.userInfo().uid;
+    // 1. Check for the modern Unix standard
+    if (process.env.XDG_RUNTIME_DIR) {
+        return path.join(process.env.XDG_RUNTIME_DIR, APP_NAME);
+    }
+    // 2. Fallback for macOS and older Linux
+    if (platform === 'darwin' || platform === 'linux') {
+        // /tmp is cleared on boot, making it perfect for PIDs
+        return path.join('/tmp', `${APP_NAME}-${uid}`);
+    }
+    // 3. Windows Fallback
+    return path.join(os.tmpdir(), APP_NAME);
+}
+export const IS_WINDOWS = os.platform() === 'win32';
+export function handlePidFile() {
+    const runtimeDir = getRuntimeHome();
+    const pidPath = path.join(runtimeDir, 'daemon.pid');
+    if (fs.existsSync(pidPath)) {
+        const oldPid = parseInt(fs.readFileSync(pidPath, 'utf8'), 10);
+        try {
+            // Sending signal 0 checks if the process is still alive without killing it
+            process.kill(oldPid, 0);
+            console.error('Daemon is already running!');
+            process.exit(1);
+        }
+        catch {
+            // Process is dead, we can safely overwrite the PID file
+            fs.unlinkSync(pidPath);
+        }
+    }
+    fs.mkdirSync(path.dirname(pidPath), {
+        recursive: true,
+    });
+    fs.writeFileSync(pidPath, process.pid.toString());
+    return pidPath;
+}

package/build/src/formatters/ConsoleFormatter.js

@@ -3,12 +3,10 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-var _a;
 import { createStackTraceForConsoleMessage, SymbolizedError, } from '../DevtoolsUtils.js';
 import { UncaughtError } from '../PageCollector.js';
 import * as DevTools from '../third_party/index.js';
 export class ConsoleFormatter {
-    static #STACK_TRACE_MAX_LINES = 50;
     #id;
     #type;
     #text;
@@ -16,7 +14,7 @@ export class ConsoleFormatter {
     #resolvedArgs;
     #stack;
     #cause;
-    #isIgnored;
+    isIgnored;
     constructor(params) {
         this.#id = params.id;
         this.#type = params.type;
@@ -25,7 +23,7 @@ export class ConsoleFormatter {
         this.#resolvedArgs = params.resolvedArgs ?? [];
         this.#stack = params.stack;
         this.#cause = params.cause;
-        this.#isIgnored = params.isIgnored;
+        this.isIgnored = params.isIgnored;
     }
     static async from(msg, options) {
         const ignoreListManager = options?.devTools?.universe.context.get(DevTools.DevTools.IgnoreListManager);
@@ -51,7 +49,7 @@ export class ConsoleFormatter {
                 resolvedStackTraceForTesting: options?.resolvedStackTraceForTesting,
                 resolvedCauseForTesting: options?.resolvedCauseForTesting,
             });
-            return new _a({
+            return new ConsoleFormatter({
                 id: options.id,
                 type: 'error',
                 text: error.message,
@@ -96,7 +94,7 @@ export class ConsoleFormatter {
                 // ignore
             }
         }
-        return new _a({
+        return new ConsoleFormatter({
             id: options.id,
             type: msg.type(),
             text: msg.text(),
@@ -108,19 +106,11 @@ export class ConsoleFormatter {
     }
     // The short format for a console message.
     toString() {
-        return `msgid=${this.#id} [${this.#type}] ${this.#text} (${this.#argCount} args)`;
+        return convertConsoleMessageConciseToString(this.toJSON());
     }
     // The verbose format for a console message, including all details.
     toStringDetailed() {
-        const result = [
-            `ID: ${this.#id}`,
-            `Message: ${this.#type}> ${this.#text}`,
-            this.#formatArgs(),
-            this.#formatStackTrace(this.#stack, this.#cause, {
-                includeHeading: true,
-            }),
-        ].filter(line => !!line);
-        return result.join('\n');
+        return convertConsoleMessageConciseDetailedToString(this.toJSONDetailed());
     }
     #getArgs() {
         if (this.#resolvedArgs.length > 0) {
@@ -133,92 +123,6 @@ export class ConsoleFormatter {
         }
         return [];
     }
-    #formatArg(arg) {
-        if (arg instanceof SymbolizedError) {
-            return [
-                arg.message,
-                this.#formatStackTrace(arg.stackTrace, arg.cause, {
-                    includeHeading: false,
-                }),
-            ]
-                .filter(line => !!line)
-                .join('\n');
-        }
-        return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
-    }
-    #formatArgs() {
-        const args = this.#getArgs();
-        if (!args.length) {
-            return '';
-        }
-        const result = ['### Arguments'];
-        for (const [key, arg] of args.entries()) {
-            result.push(`Arg #${key}: ${this.#formatArg(arg)}`);
-        }
-        return result.join('\n');
-    }
-    #formatStackTrace(stackTrace, cause, opts) {
-        if (!stackTrace) {
-            return '';
-        }
-        const lines = this.#formatStackTraceInner(stackTrace, cause);
-        const includedLines = lines.slice(0, _a.#STACK_TRACE_MAX_LINES);
-        const reminderCount = lines.length - includedLines.length;
-        return [
-            opts.includeHeading ? '### Stack trace' : '',
-            ...includedLines,
-            reminderCount > 0 ? `... and ${reminderCount} more frames` : '',
-            'Note: line and column numbers use 1-based indexing',
-        ]
-            .filter(line => !!line)
-            .join('\n');
-    }
-    #formatStackTraceInner(stackTrace, cause) {
-        if (!stackTrace) {
-            return [];
-        }
-        return [
-            ...this.#formatFragment(stackTrace.syncFragment),
-            ...stackTrace.asyncFragments
-                .map(this.#formatAsyncFragment.bind(this))
-                .flat(),
-            ...this.#formatCause(cause),
-        ];
-    }
-    #formatFragment(fragment) {
-        const frames = fragment.frames.filter(frame => !this.#isIgnored(frame));
-        return frames.map(this.#formatFrame.bind(this));
-    }
-    #formatAsyncFragment(fragment) {
-        const formattedFrames = this.#formatFragment(fragment);
-        if (formattedFrames.length === 0) {
-            return [];
-        }
-        const separatorLineLength = 40;
-        const prefix = `--- ${fragment.description || 'async'} `;
-        const separator = prefix + '-'.repeat(separatorLineLength - prefix.length);
-        return [separator, ...formattedFrames];
-    }
-    #formatFrame(frame) {
-        let result = `at ${frame.name ?? '<anonymous>'}`;
-        if (frame.uiSourceCode) {
-            const location = frame.uiSourceCode.uiLocation(frame.line, frame.column);
-            result += ` (${location.linkText(/* skipTrim */ false, /* showColumnNumber */ true)})`;
-        }
-        else if (frame.url) {
-            result += ` (${frame.url}:${frame.line}:${frame.column})`;
-        }
-        return result;
-    }
-    #formatCause(cause) {
-        if (!cause) {
-            return [];
-        }
-        return [
-            `Caused by: ${cause.message}`,
-            ...this.#formatStackTraceInner(cause.stackTrace, cause.cause),
-        ];
-    }
     toJSON() {
         return {
             type: this.#type,
@@ -232,9 +136,106 @@ export class ConsoleFormatter {
             id: this.#id,
             type: this.#type,
             text: this.#text,
-            args: this.#getArgs().map(arg => typeof arg === 'object' ? arg : String(arg)),
-            stackTrace: this.#stack,
+            argsCount: this.#argCount,
+            args: this.#getArgs().map(arg => formatArg(arg, this)),
+            stackTrace: this.#stack
+                ? formatStackTrace(this.#stack, this.#cause, this)
+                : undefined,
         };
     }
 }
-_a = ConsoleFormatter;
+function convertConsoleMessageConciseToString(msg) {
+    return `msgid=${msg.id} [${msg.type}] ${msg.text} (${msg.argsCount} args)`;
+}
+function convertConsoleMessageConciseDetailedToString(msg) {
+    const result = [
+        `ID: ${msg.id}`,
+        `Message: ${msg.type}> ${msg.text}`,
+        formatArgs(msg),
+        ...(msg.stackTrace ? ['### Stack trace', msg.stackTrace] : []),
+    ].filter(line => !!line);
+    return result.join('\n');
+}
+function formatArgs(msg) {
+    const args = msg.args;
+    if (!args.length) {
+        return '';
+    }
+    const result = ['### Arguments'];
+    for (const [key, arg] of args.entries()) {
+        result.push(`Arg #${key}: ${arg}`);
+    }
+    return result.join('\n');
+}
+function formatArg(arg, formatter) {
+    if (arg instanceof SymbolizedError) {
+        return [
+            arg.message,
+            arg.stackTrace
+                ? formatStackTrace(arg.stackTrace, arg.cause, formatter)
+                : undefined,
+        ]
+            .filter(line => !!line)
+            .join('\n');
+    }
+    return typeof arg === 'object' ? JSON.stringify(arg) : String(arg);
+}
+const STACK_TRACE_MAX_LINES = 50;
+function formatStackTrace(stackTrace, cause, formatter) {
+    const lines = formatStackTraceInner(stackTrace, cause, formatter);
+    const includedLines = lines.slice(0, STACK_TRACE_MAX_LINES);
+    const reminderCount = lines.length - includedLines.length;
+    return [
+        ...includedLines,
+        reminderCount > 0 ? `... and ${reminderCount} more frames` : '',
+        'Note: line and column numbers use 1-based indexing',
+    ]
+        .filter(line => !!line)
+        .join('\n');
+}
+function formatStackTraceInner(stackTrace, cause, formatter) {
+    if (!stackTrace) {
+        return [];
+    }
+    return [
+        ...formatFragment(stackTrace.syncFragment, formatter),
+        ...stackTrace.asyncFragments
+            .map(item => formatAsyncFragment(item, formatter))
+            .flat(),
+        ...formatCause(cause, formatter),
+    ];
+}
+function formatFragment(fragment, formatter) {
+    const frames = fragment.frames.filter(frame => !formatter.isIgnored(frame));
+    return frames.map(formatFrame);
+}
+function formatAsyncFragment(fragment, formatter) {
+    const formattedFrames = formatFragment(fragment, formatter);
+    if (formattedFrames.length === 0) {
+        return [];
+    }
+    const separatorLineLength = 40;
+    const prefix = `--- ${fragment.description || 'async'} `;
+    const separator = prefix + '-'.repeat(separatorLineLength - prefix.length);
+    return [separator, ...formattedFrames];
+}
+function formatFrame(frame) {
+    let result = `at ${frame.name ?? '<anonymous>'}`;
+    if (frame.uiSourceCode) {
+        const location = frame.uiSourceCode.uiLocation(frame.line, frame.column);
+        result += ` (${location.linkText(/* skipTrim */ false, /* showColumnNumber */ true)})`;
+    }
+    else if (frame.url) {
+        result += ` (${frame.url}:${frame.line}:${frame.column})`;
+    }
+    return result;
+}
+function formatCause(cause, formatter) {
+    if (!cause) {
+        return [];
+    }
+    return [
+        `Caused by: ${cause.message}`,
+        ...formatStackTraceInner(cause.stackTrace, cause.cause, formatter),
+    ];
+}

package/build/src/formatters/IssueFormatter.js

@@ -14,56 +14,10 @@ export class IssueFormatter {
         this.#options = options;
     }
     toString() {
-        const title = this.#getTitle();
-        const count = this.#issue.getAggregatedIssuesCount();
-        const idPart = this.#options.id !== undefined ? `msgid=${this.#options.id} ` : '';
-        return `${idPart}[issue] ${title} (count: ${count})`;
+        return convertIssueConciseToString(this.toJSON());
     }
     toStringDetailed() {
-        const result = [];
-        if (this.#options.id !== undefined) {
-            result.push(`ID: ${this.#options.id}`);
-        }
-        const bodyParts = [];
-        const description = this.#getDescription();
-        let processedMarkdown = description?.trim();
-        // Remove heading in order not to conflict with the whole console message response markdown
-        if (processedMarkdown?.startsWith('# ')) {
-            processedMarkdown = processedMarkdown.substring(2).trimStart();
-        }
-        if (processedMarkdown) {
-            bodyParts.push(processedMarkdown);
-        }
-        else {
-            bodyParts.push(this.#getTitle() ?? 'Unknown Issue');
-        }
-        const links = this.#issue.getDescription()?.links;
-        if (links && links.length > 0) {
-            bodyParts.push('Learn more:');
-            for (const link of links) {
-                bodyParts.push(`[${link.linkTitle}](${link.link})`);
-            }
-        }
-        const affectedResources = this.#getAffectedResources();
-        if (affectedResources.length) {
-            bodyParts.push('### Affected resources');
-            bodyParts.push(...affectedResources.map(item => {
-                const details = [];
-                if (item.uid) {
-                    details.push(`uid=${item.uid}`);
-                }
-                if (item.request) {
-                    details.push((typeof item.request === 'number' ? `reqid=` : 'url=') +
-                        item.request);
-                }
-                if (item.data) {
-                    details.push(`data=${JSON.stringify(item.data)}`);
-                }
-                return details.join(' ');
-            }));
-        }
-        result.push(`Message: issue> ${bodyParts.join('\n')}`);
-        return result.join('\n');
+        return convertIssueDetailedToString(this.toJSONDetailed());
     }
     toJSON() {
         return {
@@ -77,6 +31,7 @@ export class IssueFormatter {
         return {
             id: this.#options.id,
             type: 'issue',
+            count: this.#issue.getAggregatedIssuesCount(),
             title: this.#getTitle(),
             description: this.#getDescription(),
             links: this.#issue.getDescription()?.links,
@@ -188,3 +143,50 @@ export class IssueFormatter {
         }
     }
 }
+function convertIssueConciseToString(issue) {
+    return `msgid=${issue.id} [issue] ${issue.title} (count: ${issue.count})`;
+}
+function convertIssueDetailedToString(issue) {
+    const result = [];
+    result.push(`ID: ${issue.id}`);
+    const bodyParts = [];
+    const description = issue.description;
+    let processedMarkdown = description?.trim();
+    // Remove heading in order not to conflict with the whole console message response markdown
+    if (processedMarkdown?.startsWith('# ')) {
+        processedMarkdown = processedMarkdown.substring(2).trimStart();
+    }
+    if (processedMarkdown) {
+        bodyParts.push(processedMarkdown);
+    }
+    else {
+        bodyParts.push(issue.title ?? 'Unknown Issue');
+    }
+    const links = issue.links;
+    if (links && links.length > 0) {
+        bodyParts.push('Learn more:');
+        for (const link of links) {
+            bodyParts.push(`[${link.linkTitle}](${link.link})`);
+        }
+    }
+    const affectedResources = issue.affectedResources;
+    if (affectedResources.length) {
+        bodyParts.push('### Affected resources');
+        bodyParts.push(...affectedResources.map(item => {
+            const details = [];
+            if (item.uid) {
+                details.push(`uid=${item.uid}`);
+            }
+            if (item.request) {
+                details.push((typeof item.request === 'number' ? `reqid=` : 'url=') +
+                    item.request);
+            }
+            if (item.data) {
+                details.push(`data=${JSON.stringify(item.data)}`);
+            }
+            return details.join(' ');
+        }));
+    }
+    result.push(`Message: issue> ${bodyParts.join('\n')}`);
+    return result.join('\n');
+}

package/build/src/main.js

@@ -12,16 +12,14 @@ import { logger, saveLogsToFile } from './logger.js';
 import { McpContext } from './McpContext.js';
 import { McpResponse } from './McpResponse.js';
 import { Mutex } from './Mutex.js';
+import { SlimMcpResponse } from './SlimMcpResponse.js';
 import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
 import { computeFlagUsage } from './telemetry/flagUtils.js';
 import { bucketizeLatency } from './telemetry/metricUtils.js';
 import { McpServer, StdioServerTransport, SetLevelRequestSchema, } from './third_party/index.js';
 import { ToolCategory } from './tools/categories.js';
-import { tools } from './tools/tools.js';
-// If moved update release-please config
-// x-release-please-start-version
-const VERSION = '0.17.3';
-// x-release-please-end
+import { createTools } from './tools/tools.js';
+import { VERSION } from './version.js';
 export const args = parseArguments(VERSION);
 const logFile = args.logFile ? saveLogsToFile(args.logFile) : undefined;
 if (process.env['CI'] ||
@@ -39,9 +37,11 @@ if (args.usageStatistics) {
         clearcutIncludePidHeader: args.clearcutIncludePidHeader,
     });
 }
-process.on('unhandledRejection', (reason, promise) => {
-    logger('Unhandled promise rejection', promise, reason);
-});
+if (process.env['CHROME_DEVTOOLS_MCP_CRASH_ON_UNCAUGHT'] !== 'true') {
+    process.on('unhandledRejection', (reason, promise) => {
+        logger('Unhandled promise rejection', promise, reason);
+    });
+}
 logger(`Starting Chrome DevTools MCP Server v${VERSION}`);
 const server = new McpServer({
     name: 'chrome_devtools',
@@ -96,10 +96,10 @@ const logDisclaimers = () => {
     console.error(`chrome-devtools-mcp exposes content of the browser instance to the MCP clients allowing them to inspect,
 debug, and modify any data in the browser or DevTools.
 Avoid sharing sensitive or personal information that you do not want to share with MCP clients.`);
-    if (args.performanceCrux) {
+    if (!args.slim && args.performanceCrux) {
         console.error(`Performance tools may send trace URLs to the Google CrUX API to fetch real-user experience data. To disable, run with --no-performance-crux.`);
     }
-    if (args.usageStatistics) {
+    if (!args.slim && args.usageStatistics) {
         console.error(`
 Google collects usage statistics to improve Chrome DevTools MCP. To opt-out, run with --no-usage-statistics.
 For more details, visit: https://github.com/ChromeDevTools/chrome-devtools-mcp#usage-statistics`);
@@ -131,6 +131,10 @@ function registerTool(tool) {
         !args.experimentalInteropTools) {
         return;
     }
+    if (tool.annotations.conditions?.includes('screencast') &&
+        !args.experimentalScreencast) {
+        return;
+    }
     server.registerTool(tool.name, {
         description: tool.description,
         inputSchema: tool.schema,
@@ -144,7 +148,7 @@ function registerTool(tool) {
             const context = await getContext();
             logger(`${tool.name} context: resolved`);
             await context.detectOpenDevToolsWindows();
-            const response = new McpResponse();
+            const response = args.slim ? new SlimMcpResponse() : new McpResponse();
             await tool.handler({
                 params,
             }, response, context);
@@ -184,6 +188,7 @@ function registerTool(tool) {
         }
     });
 }
+const tools = createTools(args);
 for (const tool of tools) {
     registerTool(tool);
 }