@j0hanz/filesystem-mcp 1.1.2 → 1.2.1

package/dist/tools/search-files.js

@@ -3,23 +3,18 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_SEARCH_TIMEOUT_MS, } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { searchFiles } from '../lib/file-operations/search-files.js';
-import { createTimedAbortSignal } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
 import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, getExperimentalTaskRegistration, notifyProgress, resolvePathOrRoot, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
-import { createToolTaskHandler } from './task-support.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const SEARCH_FILES_TOOL = {
     title: 'Find Files',
     description: 'Find files by glob pattern (e.g., **/*.ts). ' +
         'Returns a list of matching files with metadata. ' +
-        'For text search inside files, use grep.',
+        'For text search inside files, use grep. ' +
+        'To bulk-edit the matched files, pass the same glob pattern to search_and_replace.',
     inputSchema: SearchFilesInputSchema,
     outputSchema: SearchFilesOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
 async function handleSearchFiles(args, signal, onProgress) {
     const basePath = resolvePathOrRoot(args.path);
@@ -30,27 +25,30 @@ async function handleSearchFiles(args, signal, onProgress) {
         sortBy: args.sortBy,
         respectGitignore: !args.includeIgnored,
         ...(args.maxDepth !== undefined ? { maxDepth: args.maxDepth } : {}),
-        ...(args.maxFilesScanned !== undefined
-            ? { maxFilesScanned: args.maxFilesScanned }
-            : {}),
         ...(onProgress ? { onProgress } : {}),
         ...(signal ? { signal } : {}),
     };
     const result = await searchFiles(basePath, args.pattern, excludePatterns, searchOptions);
-    const relativeResults = result.results.map((entry) => ({
-        path: path.relative(result.basePath, entry.path),
-        size: entry.size,
-        modified: entry.modified?.toISOString(),
-    }));
+    const relativeResults = [];
+    for (const entry of result.results) {
+        relativeResults.push({
+            path: path.relative(result.basePath, entry.path),
+            size: entry.size,
+            modified: entry.modified?.toISOString(),
+        });
+    }
     const structured = {
         ok: true,
         root: basePath,
         pattern: args.pattern,
         results: relativeResults,
         totalMatches: result.summary.matched,
-        truncated: result.summary.truncated,
-        filesScanned: result.summary.filesScanned,
-        skippedInaccessible: result.summary.skippedInaccessible,
+        ...(result.summary.truncated
+            ? { truncated: result.summary.truncated }
+            : {}),
+        ...(result.summary.skippedInaccessible
+            ? { skippedInaccessible: result.summary.skippedInaccessible }
+            : {}),
         ...(result.summary.stoppedReason
             ? { stoppedReason: result.summary.stoppedReason }
             : {}),
@@ -71,51 +69,47 @@ async function handleSearchFiles(args, signal, onProgress) {
         truncated: result.summary.truncated,
         ...(truncatedReason ? { truncatedReason } : {}),
     };
-    const textLines = relativeResults.length === 0
-        ? ['No matches']
-        : [
-            `Found ${relativeResults.length}:`,
-            ...relativeResults.map((entry) => `  ${entry.path}`),
-        ];
+    const textLines = [];
+    if (relativeResults.length === 0) {
+        textLines.push('No matches');
+    }
+    else {
+        textLines.push(`Found ${relativeResults.length}:`);
+        for (const entry of relativeResults) {
+            textLines.push(`  ${entry.path}`);
+        }
+    }
     const text = joinLines(textLines) + formatOperationSummary(summaryOptions);
     return buildToolResponse(text, structured);
 }
 export function registerSearchFilesTool(server, options = {}) {
-    const handler = (args, extra) => withToolDiagnostics('find', () => withToolErrorHandling(async () => {
-        notifyProgress(extra, {
-            current: 0,
-            message: `🔎︎ find: ${args.pattern}`,
-        });
-        const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
-        try {
+    const handler = (args, extra) => executeToolWithDiagnostics({
+        toolName: 'find',
+        extra,
+        timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
+        context: { path: args.path ?? '.' },
+        run: async (signal) => {
+            notifyProgress(extra, {
+                current: 0,
+                message: `🔎︎ find: ${args.pattern}`,
+            });
             const result = await handleSearchFiles(args, signal, createProgressReporter(extra));
             const sc = result.structuredContent;
-            const suffix = sc.ok && sc.totalMatches
-                ? String(sc.totalMatches)
-                : 'No matches';
+            const suffix = sc.ok && sc.totalMatches ? String(sc.totalMatches) : 'No matches';
             const finalCurrent = (sc.filesScanned ?? 0) + 1;
             notifyProgress(extra, {
                 current: finalCurrent,
                 message: `🔎︎ find: ${args.pattern} ➟ ${suffix}`,
             });
             return result;
-        }
-        finally {
-            cleanup();
-        }
-    }, (error) => buildToolErrorResponse(error, ErrorCode.E_INVALID_PATTERN, args.path)), { path: args.path ?? '.' });
+        },
+        onError: (error) => buildToolErrorResponse(error, ErrorCode.E_INVALID_PATTERN, args.path),
+    });
     const { isInitialized } = options;
     const wrappedHandler = wrapToolHandler(handler, {
         guard: isInitialized,
     });
-    const taskOptions = isInitialized ? { guard: isInitialized } : undefined;
-    const tasks = getExperimentalTaskRegistration(server);
-    if (tasks?.registerToolTask) {
-        tasks.registerToolTask('find', withDefaultIcons({
-            ...SEARCH_FILES_TOOL,
-            execution: { taskSupport: 'optional' },
-        }, options.iconInfo), createToolTaskHandler(wrappedHandler, taskOptions));
+    if (registerToolTaskIfAvailable(server, 'find', SEARCH_FILES_TOOL, wrappedHandler, options.iconInfo, isInitialized))
         return;
-    }
     server.registerTool('find', withDefaultIcons({ ...SEARCH_FILES_TOOL }, options.iconInfo), wrappedHandler);
 }

package/dist/tools/shared.d.ts

@@ -1,9 +1,24 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ContentBlock, Icon, ProgressNotificationParams } from '@modelcontextprotocol/sdk/types.js';
 import type { z } from 'zod';
+import type { FileInfo } from '../config.js';
 import { ErrorCode } from '../lib/errors.js';
 import type { ResourceStore } from '../lib/resource-store.js';
 import type { ToolErrorResponseSchema } from '../schemas.js';
+export declare const READ_ONLY_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: true;
+    readonly idempotentHint: true;
+    readonly openWorldHint: false;
+};
+export declare const DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: false;
+    readonly destructiveHint: true;
+    readonly openWorldHint: false;
+};
+export declare const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS: {
+    readonly readOnlyHint: false;
+    readonly idempotentHint: true;
+    readonly openWorldHint: false;
+};
 type ResourceEntry = ReturnType<ResourceStore['putText']>;
 export declare function maybeExternalizeTextContent(resourceStore: ResourceStore | undefined, content: string, params: {
     name: string;
@@ -18,7 +33,7 @@ export declare function buildResourceLink(params: {
     mimeType?: string;
     description?: string;
 }): ContentBlock;
-export declare function buildToolResponse<T>(text: string, structuredContent: T, extraContent?: ContentBlock[], resourceStore?: ResourceStore): {
+export declare function buildToolResponse<T>(text: string, structuredContent: T, extraContent?: ContentBlock[]): {
     content: ContentBlock[];
     structuredContent: T;
 };
@@ -54,14 +69,37 @@ export interface ToolRegistrationOptions {
     serverIcon?: string;
     iconInfo?: IconInfo;
 }
-export declare function getExperimentalTaskRegistration(server: McpServer): {
-    registerToolTask?: (...args: unknown[]) => unknown;
-} | undefined;
-export declare function withToolErrorHandling<T>(run: () => Promise<ToolResponse<T>>, onError: (error: unknown) => ToolResult<T>): Promise<ToolResult<T>>;
+interface FileInfoPayload {
+    name: string;
+    path: string;
+    type: FileInfo['type'];
+    size: number;
+    tokenEstimate?: number;
+    created: string;
+    modified: string;
+    accessed: string;
+    permissions: string;
+    isHidden: boolean;
+    mimeType?: string;
+    symlinkTarget?: string;
+}
+export declare function buildFileInfoPayload(info: FileInfo): FileInfoPayload;
+interface ToolExecutionOptions<T> {
+    toolName: string;
+    extra: ToolExtra;
+    run: (signal: AbortSignal | undefined) => ToolResponse<T> | Promise<ToolResponse<T>>;
+    onError: (error: unknown) => ToolResult<T>;
+    context?: Record<string, unknown>;
+    timedSignal?: {
+        timeoutMs?: number;
+    };
+}
+export declare function executeToolWithDiagnostics<T>(options: ToolExecutionOptions<T>): Promise<ToolResult<T>>;
 export declare function buildToolErrorResponse(error: unknown, defaultCode: ErrorCode, path?: string): ToolErrorResponse;
 export declare function createProgressReporter(extra: ToolExtra): (progress: {
     total?: number;
     current: number;
+    message?: string;
 }) => void;
 export declare function notifyProgress(extra: ToolExtra, progress: {
     current: number;

package/dist/tools/shared.js

@@ -1,8 +1,25 @@
-import { inspect } from 'node:util';
 import { createDetailedError, ErrorCode, formatDetailedError, getSuggestion, McpError, } from '../lib/errors.js';
+import { createTimedAbortSignal } from '../lib/fs-helpers.js';
+import { withToolDiagnostics } from '../lib/observability.js';
 import { getAllowedDirectories } from '../lib/path-validation.js';
 const MAX_INLINE_CONTENT_CHARS = 20_000;
 const MAX_INLINE_PREVIEW_CHARS = 4_000;
+const PROGRESS_RATE_LIMIT_MS = 50;
+export const READ_ONLY_TOOL_ANNOTATIONS = {
+    readOnlyHint: true,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+export const DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: false,
+};
+export const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS = {
+    readOnlyHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
 function buildTextPreview(text) {
     if (text.length <= MAX_INLINE_PREVIEW_CHARS)
         return text;
@@ -32,42 +49,9 @@ export function buildResourceLink(params) {
         ...(params.mimeType ? { mimeType: params.mimeType } : {}),
     };
 }
-function buildContentBlock(text, structuredContent, extraContent = [], resourceStore) {
-    let json;
-    try {
-        json = JSON.stringify(structuredContent);
-    }
-    catch (error) {
-        const preview = inspect(structuredContent, {
-            depth: 4,
-            colors: false,
-            compact: 3,
-            breakLength: 80,
-        });
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        json = JSON.stringify({
-            ok: false,
-            error: `Failed to serialize structuredContent: ${errorMessage}`,
-            preview,
-        });
-    }
-    const externalized = maybeExternalizeTextContent(resourceStore, json, {
-        name: 'tool:structuredContent',
-        mimeType: 'application/json',
-    });
-    const jsonContent = externalized
-        ? [
-            { type: 'text', text: externalized.preview },
-            buildResourceLink({
-                uri: externalized.entry.uri,
-                name: externalized.entry.name,
-                mimeType: externalized.entry.mimeType,
-                description: 'Full structuredContent JSON',
-            }),
-        ]
-        : [{ type: 'text', text: json }];
+function buildContentBlock(text, structuredContent, extraContent = []) {
     return {
-        content: [{ type: 'text', text }, ...extraContent, ...jsonContent],
+        content: [{ type: 'text', text }, ...extraContent],
         structuredContent,
     };
 }
@@ -79,8 +63,8 @@ function resolveDetailedError(error, defaultCode, path) {
     }
     return detailed;
 }
-export function buildToolResponse(text, structuredContent, extraContent = [], resourceStore) {
-    return buildContentBlock(text, structuredContent, extraContent, resourceStore);
+export function buildToolResponse(text, structuredContent, extraContent = []) {
+    return buildContentBlock(text, structuredContent, extraContent);
 }
 function canSendProgress(extra) {
     return (extra._meta?.progressToken !== undefined &&
@@ -103,25 +87,28 @@ export function withDefaultIcons(tool, iconInfo) {
         ],
     };
 }
-function isExperimentalTaskRegistration(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const { registerToolTask } = value;
-    return (registerToolTask === undefined || typeof registerToolTask === 'function');
-}
-export function getExperimentalTaskRegistration(server) {
-    const serverWithExperimental = server;
-    const { experimental } = serverWithExperimental;
-    if (!experimental || typeof experimental !== 'object')
-        return undefined;
-    const experimentalObject = experimental;
-    const { tasks } = experimentalObject;
-    if (!isExperimentalTaskRegistration(tasks))
-        return undefined;
-    return tasks;
+export function buildFileInfoPayload(info) {
+    return {
+        name: info.name,
+        path: info.path,
+        type: info.type,
+        size: info.size,
+        ...(info.tokenEstimate !== undefined
+            ? { tokenEstimate: info.tokenEstimate }
+            : {}),
+        created: info.created.toISOString(),
+        modified: info.modified.toISOString(),
+        accessed: info.accessed.toISOString(),
+        permissions: info.permissions,
+        isHidden: info.isHidden,
+        ...(info.mimeType !== undefined ? { mimeType: info.mimeType } : {}),
+        ...(info.symlinkTarget !== undefined
+            ? { symlinkTarget: info.symlinkTarget }
+            : {}),
+    };
 }
 const NOT_INITIALIZED_ERROR = new McpError(ErrorCode.E_INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
-export async function withToolErrorHandling(run, onError) {
+async function withToolErrorHandling(run, onError) {
     try {
         return await run();
     }
@@ -129,6 +116,24 @@ export async function withToolErrorHandling(run, onError) {
         return onError(error);
     }
 }
+function getToolSignal(extraSignal, timedSignal) {
+    if (!timedSignal) {
+        return { signal: extraSignal, cleanup: () => { } };
+    }
+    const { signal, cleanup } = createTimedAbortSignal(extraSignal, timedSignal.timeoutMs);
+    return { signal, cleanup };
+}
+export async function executeToolWithDiagnostics(options) {
+    return withToolDiagnostics(options.toolName, () => withToolErrorHandling(async () => {
+        const { signal, cleanup } = getToolSignal(options.extra.signal, options.timedSignal);
+        try {
+            return await options.run(signal);
+        }
+        finally {
+            cleanup();
+        }
+    }, options.onError), options.context);
+}
 export function buildToolErrorResponse(error, defaultCode, path) {
     const detailed = resolveDetailedError(error, defaultCode, path);
     const text = formatDetailedError(detailed);
@@ -163,8 +168,9 @@ async function sendProgressNotification(extra, params) {
             params,
         });
     }
-    catch {
+    catch (error) {
         // Ignore progress notification failures to avoid breaking tool execution.
+        console.error('Failed to send progress notification:', error);
     }
 }
 export function createProgressReporter(extra) {
@@ -172,12 +178,25 @@ export function createProgressReporter(extra) {
         return () => { };
     }
     const token = extra._meta.progressToken;
+    // State for monotonic enforcement and rate-limiting.
+    let lastProgress = -1;
+    let lastSentMs = 0;
     return (progress) => {
-        const { current, total } = progress;
+        const { current, total, message } = progress;
+        // Enforce monotonic progress to prevent client confusion. Client behavior on
+        if (current <= lastProgress)
+            return;
+        // Enforce rate-limiting to prevent client flooding. Progress updates that are
+        const now = Date.now();
+        if (now - lastSentMs < PROGRESS_RATE_LIMIT_MS)
+            return;
+        lastProgress = current;
+        lastSentMs = now;
         void sendProgressNotification(extra, {
             progressToken: token,
-            total,
             progress: current,
+            ...(total !== undefined ? { total } : {}),
+            ...(message !== undefined ? { message } : {}),
         });
     };
 }
@@ -194,7 +213,7 @@ export function notifyProgress(extra, progress) {
 }
 async function withProgress(message, extra, run, getCompletionMessage) {
     if (!canSendProgress(extra)) {
-        return await run();
+        return run();
     }
     const token = extra._meta.progressToken;
     const total = 1;
@@ -216,11 +235,10 @@ async function withProgress(message, extra, run, getCompletionMessage) {
         return result;
     }
     catch (error) {
-        await sendProgressNotification(extra, {
+        void sendProgressNotification(extra, {
             progressToken: token,
             progress: total,
             total,
-            message,
         });
         throw error;
     }
@@ -237,9 +255,9 @@ export function wrapToolHandler(handler, options) {
             const completionFn = completionMessage
                 ? (result) => completionMessage(args, result)
                 : undefined;
-            return await withProgress(message, resolvedExtra, () => handler(args, resolvedExtra), completionFn);
+            return withProgress(message, resolvedExtra, () => handler(args, resolvedExtra), completionFn);
         }
-        return await handler(args, resolvedExtra);
+        return handler(args, resolvedExtra);
     };
 }
 export function resolvePathOrRoot(pathValue) {
@@ -252,5 +270,9 @@ export function resolvePathOrRoot(pathValue) {
     if (roots.length > 1) {
         throw new McpError(ErrorCode.E_INVALID_INPUT, 'Multiple workspace roots configured. Provide an explicit path to disambiguate.');
     }
-    return roots[0] ?? '';
+    const root = roots[0];
+    if (!root) {
+        throw new McpError(ErrorCode.E_ACCESS_DENIED, 'Workspace root is unexpectedly undefined');
+    }
+    return root;
 }

package/dist/tools/stat-many.js

@@ -1,104 +1,82 @@
-import { formatBytes } from '../config.js';
+import { formatBytes, joinLines } from '../config.js';
 import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { getMultipleFileInfo } from '../lib/file-operations/file-info.js';
-import { createTimedAbortSignal } from '../lib/fs-helpers.js';
-import { withToolDiagnostics } from '../lib/observability.js';
 import { GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, getExperimentalTaskRegistration, withDefaultIcons, withToolErrorHandling, wrapToolHandler, } from './shared.js';
-import { createToolTaskHandler } from './task-support.js';
+import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, wrapToolHandler, } from './shared.js';
+import { registerToolTaskIfAvailable } from './task-support.js';
 const GET_MULTIPLE_FILE_INFO_TOOL = {
     title: 'Get Multiple File Info',
     description: 'Get metadata for multiple files or directories in one request.',
     inputSchema: GetMultipleFileInfoInputSchema,
     outputSchema: GetMultipleFileInfoOutputSchema,
-    annotations: {
-        readOnlyHint: true,
-        idempotentHint: true,
-        openWorldHint: false,
-    },
+    annotations: READ_ONLY_TOOL_ANNOTATIONS,
 };
-function buildFileInfoPayload(info) {
-    return {
-        name: info.name,
-        path: info.path,
-        type: info.type,
-        size: info.size,
-        ...(info.tokenEstimate !== undefined
-            ? { tokenEstimate: info.tokenEstimate }
-            : {}),
-        created: info.created.toISOString(),
-        modified: info.modified.toISOString(),
-        accessed: info.accessed.toISOString(),
-        permissions: info.permissions,
-        isHidden: info.isHidden,
-        ...(info.mimeType !== undefined ? { mimeType: info.mimeType } : {}),
-        ...(info.symlinkTarget !== undefined
-            ? { symlinkTarget: info.symlinkTarget }
-            : {}),
-    };
-}
-function formatFileInfoSummary(pathValue, info) {
-    return `${pathValue} (${info.type}, ${formatBytes(info.size)})`;
+function formatFileInfoDetail(info) {
+    const lines = [
+        `${info.name} (${info.type})`,
+        `  Path: ${info.path}`,
+        `  Size: ${formatBytes(info.size)}`,
+        `  Modified: ${info.modified.toISOString()}`,
+    ];
+    if (info.mimeType)
+        lines.push(`  Type: ${info.mimeType}`);
+    if (info.symlinkTarget)
+        lines.push(`  Target: ${info.symlinkTarget}`);
+    return joinLines(lines);
 }
 async function handleGetMultipleFileInfo(args, signal) {
     const result = await getMultipleFileInfo(args.paths, {
         includeMimeType: true,
         ...(signal ? { signal } : {}),
     });
-    const structured = {
-        ok: true,
-        results: result.results.map((entry) => ({
+    const structuredResults = [];
+    const textBlocks = [];
+    for (const entry of result.results) {
+        structuredResults.push({
             path: entry.path,
             info: entry.info ? buildFileInfoPayload(entry.info) : undefined,
             error: entry.error,
-        })),
+        });
+        if (entry.error) {
+            textBlocks.push(`${entry.path}: ${entry.error}`);
+        }
+        else if (entry.info) {
+            textBlocks.push(formatFileInfoDetail(entry.info));
+        }
+        else {
+            textBlocks.push(entry.path);
+        }
+    }
+    const structured = {
+        ok: true,
+        results: structuredResults,
         summary: {
             total: result.summary.total,
             succeeded: result.summary.succeeded,
             failed: result.summary.failed,
         },
     };
-    const text = result.results
-        .map((entry) => {
-        if (entry.error) {
-            return `${entry.path}: ${entry.error}`;
-        }
-        if (entry.info) {
-            return formatFileInfoSummary(entry.path, entry.info);
-        }
-        return entry.path;
-    })
-        .join('\n');
+    const text = textBlocks.join('\n\n');
     return buildToolResponse(text, structured);
 }
 export function registerGetMultipleFileInfoTool(server, options = {}) {
     const handler = (args, extra) => {
         const primaryPath = args.paths[0] ?? '';
-        return withToolDiagnostics('stat_many', () => withToolErrorHandling(async () => {
-            const { signal, cleanup } = createTimedAbortSignal(extra.signal, DEFAULT_SEARCH_TIMEOUT_MS);
-            try {
-                return await handleGetMultipleFileInfo(args, signal);
-            }
-            finally {
-                cleanup();
-            }
-        }, (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, primaryPath)), { path: primaryPath });
+        return executeToolWithDiagnostics({
+            toolName: 'stat_many',
+            extra,
+            timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
+            context: { path: primaryPath },
+            run: (signal) => handleGetMultipleFileInfo(args, signal),
+            onError: (error) => buildToolErrorResponse(error, ErrorCode.E_NOT_FOUND, primaryPath),
+        });
     };
     const wrappedHandler = wrapToolHandler(handler, {
         guard: options.isInitialized,
         progressMessage: (args) => `🕮 stat_many: ${args.paths.length} paths`,
     });
-    const taskOptions = options.isInitialized
-        ? { guard: options.isInitialized }
-        : undefined;
-    const tasks = getExperimentalTaskRegistration(server);
-    if (tasks?.registerToolTask) {
-        tasks.registerToolTask('stat_many', withDefaultIcons({
-            ...GET_MULTIPLE_FILE_INFO_TOOL,
-            execution: { taskSupport: 'optional' },
-        }, options.iconInfo), createToolTaskHandler(wrappedHandler, taskOptions));
+    if (registerToolTaskIfAvailable(server, 'stat_many', GET_MULTIPLE_FILE_INFO_TOOL, wrappedHandler, options.iconInfo, options.isInitialized))
         return;
-    }
     server.registerTool('stat_many', withDefaultIcons({ ...GET_MULTIPLE_FILE_INFO_TOOL }, options.iconInfo), wrappedHandler);
 }