@j0hanz/filesystem-mcp 1.11.0 → 1.12.0

package/dist/tools/search-content.js

@@ -7,7 +7,66 @@ import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
 import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 import { registerToolTaskIfAvailable } from './task-support.js';
-const MAX_INLINE_MATCHES = parseInt(process.env['FS_CONTEXT_MAX_INLINE_MATCHES'] ?? '', 10) || 50;
+/**
+ * Configuration constants for the Search Content tool.
+ */
+const CONFIG = {
+    MAX_INLINE_MATCHES: parseInt(process.env['FS_CONTEXT_MAX_INLINE_MATCHES'] ?? '', 10) || 50,
+    COMPLETION_LABELS: {
+        timeout: 'timeout',
+        maxResults: 'max results',
+        maxFiles: 'max files',
+    },
+};
+const TRUTHY_SUMMARY_FIELDS = [
+    'filesMatched',
+    'skippedTooLarge',
+    'skippedBinary',
+    'skippedInaccessible',
+    'linesSkippedDueToRegexTimeout',
+];
+function buildStructuredSummaryFields(summary) {
+    const truthyFields = Object.fromEntries(TRUTHY_SUMMARY_FIELDS.flatMap((key) => {
+        const value = summary[key];
+        return value ? [[key, value]] : [];
+    }));
+    return {
+        ...truthyFields,
+        ...(summary.truncated ? { truncated: true } : {}),
+        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
+    };
+}
+function buildCompletionSuffix(count, filesMatched, scope, stoppedReason) {
+    if (count === 0)
+        return `No matches in ${scope}`;
+    const matchWord = count === 1 ? 'match' : 'matches';
+    const fileWord = filesMatched === 1 ? 'file' : 'files';
+    const reasonSuffix = stoppedReason !== undefined
+        ? ` [${CONFIG.COMPLETION_LABELS[stoppedReason]}]`
+        : '';
+    return `${count} ${matchWord} in ${filesMatched} ${fileWord}${reasonSuffix}`;
+}
+function compareNormalizedMatches(left, right) {
+    const fileCompare = left.relativeFile.localeCompare(right.relativeFile);
+    if (fileCompare !== 0)
+        return fileCompare;
+    if (left.line !== right.line)
+        return left.line - right.line;
+    return left.index - right.index;
+}
+function buildSearchPreviewState(matches, payloads) {
+    const needsExternalize = matches.length > CONFIG.MAX_INLINE_MATCHES;
+    const visibleCount = needsExternalize
+        ? CONFIG.MAX_INLINE_MATCHES
+        : matches.length;
+    const visibleMatches = matches.slice(0, visibleCount);
+    return {
+        needsExternalize,
+        visibleMatches,
+        visiblePayloads: payloads.slice(0, visibleCount),
+        heading: SearchResponseBuilder.buildHeading(matches.length, visibleMatches.length),
+    };
+}
 export const SEARCH_CONTENT_TOOL = {
     name: 'grep',
     title: 'Search Content',
@@ -26,203 +85,196 @@ export const SEARCH_CONTENT_TOOL = {
     ],
     taskSupport: 'optional',
 };
-function assertValidRegexPattern(pattern) {
-    try {
-        new RE2(pattern);
-    }
-    catch (error) {
-        throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
-    }
-}
-function findColumnOffset(content, pattern, isRegex, caseSensitive) {
-    try {
-        if (isRegex) {
-            const flags = caseSensitive ? '' : 'i';
-            const regex = new RE2(pattern, flags);
-            const match = regex.exec(content);
-            return match ? match.index : undefined;
+/**
+ * Handles formatting and building the search response.
+ */
+const SearchResponseBuilder = {
+    buildHeading(totalMatches, visibleMatches) {
+        if (visibleMatches >= totalMatches) {
+            return `Found ${totalMatches}:`;
         }
-        if (caseSensitive) {
-            const idx = content.indexOf(pattern);
-            return idx >= 0 ? idx : undefined;
-        }
-        const lowerContent = content.toLowerCase();
-        const lowerPattern = pattern.toLowerCase();
-        const idx = lowerContent.indexOf(lowerPattern);
-        return idx >= 0 ? idx : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function buildSearchTextResult(result, normalizedMatches) {
-    const { summary } = result;
-    if (normalizedMatches.length === 0)
-        return 'No matches';
-    let truncatedReason;
-    if (summary.truncated) {
-        truncatedReason = resolveTruncatedReason(summary);
-    }
-    const summaryOptions = {
-        truncated: summary.truncated,
-        ...(truncatedReason ? { truncatedReason } : {}),
-    };
-    return (buildMatchListText(`Found ${normalizedMatches.length}:`, normalizedMatches) + formatOperationSummary(summaryOptions));
-}
-function resolveTruncatedReason(summary) {
-    if (summary.stoppedReason === 'timeout')
-        return 'timeout';
-    if (summary.stoppedReason === 'maxFiles') {
-        return `max files (${summary.filesScanned})`;
-    }
-    return `max results (${summary.matches})`;
-}
-function buildMatchListText(heading, matches) {
-    const lines = [heading];
-    for (const match of matches) {
-        lines.push(formatSearchMatchLine(match));
-    }
-    return joinLines(lines);
-}
-function buildSearchMatchPayload(match, context) {
-    const column = findColumnOffset(match.content, context.pattern, context.isRegex, context.caseSensitive);
-    return {
-        file: match.relativeFile,
-        line: match.line,
-        ...(column !== undefined ? { column } : {}),
-        content: match.content,
-        matchCount: match.matchCount,
-        ...(match.contextBefore ? { contextBefore: [...match.contextBefore] } : {}),
-        ...(match.contextAfter ? { contextAfter: [...match.contextAfter] } : {}),
-    };
-}
-function formatSearchMatchLine(match) {
-    const lineNum = String(match.line).padStart(4);
-    return `  ${match.relativeFile}:${lineNum}: ${match.content}`;
-}
-function buildStructuredSearchResult(result, normalizedMatches, options, context) {
-    const { summary } = result;
-    const matches = normalizedMatches.map((match) => buildSearchMatchPayload(match, context));
-    return {
-        ok: true,
-        patternType: options.patternType,
-        caseSensitive: options.caseSensitive,
-        matches,
-        totalMatches: summary.matches,
-        filesScanned: summary.filesScanned,
-        ...(summary.truncated ? { truncated: summary.truncated } : {}),
-        ...(summary.filesMatched ? { filesMatched: summary.filesMatched } : {}),
-        ...(summary.skippedTooLarge
-            ? { skippedTooLarge: summary.skippedTooLarge }
-            : {}),
-        ...(summary.skippedBinary ? { skippedBinary: summary.skippedBinary } : {}),
-        ...(summary.skippedInaccessible
-            ? { skippedInaccessible: summary.skippedInaccessible }
-            : {}),
-        ...(summary.linesSkippedDueToRegexTimeout
-            ? { linesSkippedDueToRegexTimeout: summary.linesSkippedDueToRegexTimeout }
-            : {}),
-        ...(summary.stoppedReason ? { stoppedReason: summary.stoppedReason } : {}),
-    };
-}
-function normalizeSearchMatches(result) {
-    const relativeByFile = new Map();
-    const normalized = [];
-    let index = 0;
-    for (const match of result.matches) {
-        const cached = relativeByFile.get(match.file);
-        const relative = cached ?? path.relative(result.basePath, match.file);
-        if (!cached)
-            relativeByFile.set(match.file, relative);
-        normalized.push({
+        return `Found ${totalMatches} (showing first ${visibleMatches}):`;
+    },
+    buildText(heading, matches, summary) {
+        if (matches.length === 0)
+            return 'No matches';
+        const text = this.buildMatchList(heading, matches);
+        if (!summary)
+            return text;
+        const summaryOpts = {
+            truncated: summary.truncated,
+            ...(summary.truncated
+                ? { truncatedReason: this.resolveTruncatedReason(summary) }
+                : {}),
+        };
+        return text + formatOperationSummary(summaryOpts);
+    },
+    buildStructured(summary, matches, options) {
+        return {
+            ok: true,
+            patternType: options.patternType,
+            caseSensitive: options.caseSensitive,
+            matches,
+            totalMatches: summary.matches,
+            filesScanned: summary.filesScanned,
+            ...buildStructuredSummaryFields(summary),
+        };
+    },
+    normalizeMatches(result) {
+        const relativeByFile = new Map();
+        const getRelativeFile = (file) => {
+            const cached = relativeByFile.get(file);
+            if (cached !== undefined)
+                return cached;
+            const relative = path.relative(result.basePath, file);
+            relativeByFile.set(file, relative);
+            return relative;
+        };
+        return result.matches
+            .map((match, index) => ({
             ...match,
-            relativeFile: relative,
+            relativeFile: getRelativeFile(match.file),
             index,
+        }))
+            .sort(compareNormalizedMatches);
+    },
+    buildMatchPayloads(matches, context) {
+        return matches.map((match) => {
+            const column = this.findColumnOffset(match.content, context);
+            return {
+                file: match.relativeFile,
+                line: match.line,
+                ...(column !== undefined ? { column } : {}),
+                content: match.content,
+                matchCount: match.matchCount,
+                ...(match.contextBefore
+                    ? { contextBefore: [...match.contextBefore] }
+                    : {}),
+                ...(match.contextAfter
+                    ? { contextAfter: [...match.contextAfter] }
+                    : {}),
+            };
         });
-        index += 1;
-    }
-    normalized.sort((a, b) => {
-        const fileCompare = a.relativeFile.localeCompare(b.relativeFile);
-        if (fileCompare !== 0)
-            return fileCompare;
-        if (a.line !== b.line)
-            return a.line - b.line;
-        return a.index - b.index;
-    });
-    return normalized;
-}
+    },
+    buildMatchList(heading, matches) {
+        const lines = [heading];
+        for (const match of matches) {
+            const lineNum = String(match.line).padStart(4);
+            lines.push(`  ${match.relativeFile}:${lineNum}: ${match.content}`);
+        }
+        return joinLines(lines);
+    },
+    resolveTruncatedReason(summary) {
+        if (summary.stoppedReason === 'timeout')
+            return 'timeout';
+        if (summary.stoppedReason === 'maxFiles') {
+            return `max files (${summary.filesScanned})`;
+        }
+        return `max results (${summary.matches})`;
+    },
+    findColumnOffset(content, context) {
+        try {
+            if (context.matcher) {
+                context.matcher.lastIndex = 0;
+                const match = context.matcher.exec(content);
+                return match ? match.index : undefined;
+            }
+            if (context.caseSensitive) {
+                const idx = content.indexOf(context.pattern);
+                return idx >= 0 ? idx : undefined;
+            }
+            // Case-insensitive literal search
+            const idx = content.toLowerCase().indexOf(context.foldedPattern ?? '');
+            return idx >= 0 ? idx : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};
+const SearchExecutor = {
+    async run(args, basePath, signal, onProgress) {
+        const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
+        const options = {
+            includeHidden: args.includeHidden,
+            excludePatterns,
+            filePattern: args.filePattern,
+            caseSensitive: args.caseSensitive,
+            wholeWord: args.wholeWord,
+            contextLines: args.contextLines,
+            maxResults: args.maxResults,
+            isLiteral: !args.isRegex,
+            multiline: args.multiline,
+            ...(signal ? { signal } : {}),
+            ...(onProgress ? { onProgress } : {}),
+        };
+        try {
+            return await searchContent(basePath, args.pattern, options);
+        }
+        catch (error) {
+            if (error instanceof Error && /regular expression/i.test(error.message)) {
+                throw new McpError(ErrorCode.E_INVALID_PATTERN, error.message);
+            }
+            throw error;
+        }
+    },
+    createMatcher(args) {
+        if (!args.isRegex)
+            return undefined;
+        try {
+            const flags = (args.caseSensitive ? '' : 'i') + (args.multiline ? 'm' : '');
+            return new RE2(args.pattern, flags);
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regex pattern: ${formatUnknownErrorMessage(error)}`);
+        }
+    },
+    createSearchContext(args, matcher) {
+        return {
+            pattern: args.pattern,
+            caseSensitive: args.caseSensitive,
+            ...(matcher ? { matcher } : {}),
+            ...(!args.isRegex && !args.caseSensitive
+                ? { foldedPattern: args.pattern.toLowerCase() }
+                : {}),
+        };
+    },
+};
 async function handleSearchContent(args, signal, resourceStore, onProgress) {
     const basePath = resolvePathOrRoot(args.path);
-    const excludePatterns = args.includeIgnored ? [] : DEFAULT_EXCLUDE_PATTERNS;
     const patternType = args.isRegex ? 'regex' : 'literal';
-    if (args.isRegex) {
-        assertValidRegexPattern(args.pattern);
-    }
-    const options = {
-        includeHidden: args.includeHidden,
-        excludePatterns,
-        filePattern: args.filePattern,
-        caseSensitive: args.caseSensitive,
-        wholeWord: args.wholeWord,
-        contextLines: args.contextLines,
-        maxResults: args.maxResults,
-        isLiteral: !args.isRegex,
-        multiline: args.multiline,
-    };
-    if (signal) {
-        options.signal = signal;
-    }
-    if (onProgress) {
-        options.onProgress = onProgress;
-    }
-    let result;
-    try {
-        result = await searchContent(basePath, args.pattern, options);
-    }
-    catch (error) {
-        if (error instanceof Error && /regular expression/i.test(error.message)) {
-            throw new McpError(ErrorCode.E_INVALID_PATTERN, error.message);
-        }
-        throw error;
-    }
-    const normalizedMatches = normalizeSearchMatches(result);
-    const searchContext = {
-        pattern: args.pattern,
-        isRegex: args.isRegex,
-        caseSensitive: args.caseSensitive,
-    };
-    const structuredFull = buildStructuredSearchResult(result, normalizedMatches, {
-        patternType,
-        caseSensitive: args.caseSensitive,
-    }, searchContext);
-    const needsExternalize = normalizedMatches.length > MAX_INLINE_MATCHES;
-    if (!resourceStore || !needsExternalize) {
-        return buildToolResponse(buildSearchTextResult(result, normalizedMatches), structuredFull);
+    const regexMatcher = SearchExecutor.createMatcher(args);
+    const result = await SearchExecutor.run(args, basePath, signal, onProgress);
+    const normalizedMatches = SearchResponseBuilder.normalizeMatches(result);
+    const searchContext = SearchExecutor.createSearchContext(args, regexMatcher);
+    const matchPayloads = SearchResponseBuilder.buildMatchPayloads(normalizedMatches, searchContext);
+    const fullStructured = SearchResponseBuilder.buildStructured(result.summary, matchPayloads, { patternType, caseSensitive: args.caseSensitive });
+    const preview = buildSearchPreviewState(normalizedMatches, matchPayloads);
+    if (resourceStore && preview.needsExternalize) {
+        const previewStructured = {
+            ...fullStructured,
+            matches: preview.visiblePayloads,
+            truncated: true,
+        };
+        const entry = resourceStore.putText({
+            name: 'grep:matches',
+            mimeType: 'application/json',
+            text: JSON.stringify(fullStructured),
+        });
+        previewStructured.resourceUri = entry.uri;
+        const text = SearchResponseBuilder.buildText(preview.heading, preview.visibleMatches);
+        return buildToolResponse(text, previewStructured, [
+            buildResourceLink({
+                uri: entry.uri,
+                name: entry.name,
+                mimeType: entry.mimeType,
+                description: 'Full grep results as JSON (structuredContent)',
+                expiresAt: entry.expiresAt,
+            }),
+        ]);
     }
-    const previewMatches = normalizedMatches.slice(0, MAX_INLINE_MATCHES);
-    const previewPayload = previewMatches.map((match) => buildSearchMatchPayload(match, searchContext));
-    const previewStructured = {
-        ...structuredFull,
-        matches: previewPayload,
-        truncated: true,
-        resourceUri: undefined,
-    };
-    const entry = resourceStore.putText({
-        name: 'grep:matches',
-        mimeType: 'application/json',
-        text: JSON.stringify(structuredFull),
-    });
-    previewStructured.resourceUri = entry.uri;
-    const text = buildMatchListText(`Found ${normalizedMatches.length} (showing first ${MAX_INLINE_MATCHES}):`, previewMatches);
-    return buildToolResponse(text, previewStructured, [
-        buildResourceLink({
-            uri: entry.uri,
-            name: entry.name,
-            mimeType: entry.mimeType,
-            description: 'Full grep results as JSON (structuredContent)',
-            expiresAt: entry.expiresAt,
-        }),
-    ]);
+    const text = SearchResponseBuilder.buildText(preview.heading, preview.visibleMatches, result.summary);
+    return buildToolResponse(text, fullStructured);
 }
 export function registerSearchContentTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({
@@ -230,14 +282,14 @@ export function registerSearchContentTool(server, options = {}) {
         extra,
         context: { path: args.path ?? '.' },
         run: async (signal) => {
-            const scope = args.filePattern;
-            const { pattern } = args;
-            const progress = createToolProgressSession(extra, `🔎︎ grep: ${pattern}`);
+            const { pattern, filePattern: scope } = args;
+            const progressLabel = `🔎︎ grep: ${pattern}`;
+            const progress = createToolProgressSession(extra, progressLabel);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
                     ...(total !== undefined ? { total } : {}),
-                    message: `🔎︎ grep: ${pattern} [${current} files]`,
+                    message: `${progressLabel} [${current} files]`,
                 });
             };
             try {
@@ -246,39 +298,18 @@ export function registerSearchContentTool(server, options = {}) {
                 const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;
                 const filesMatched = sc.ok ? (sc.filesMatched ?? 0) : 0;
                 const stoppedReason = sc.ok ? sc.stoppedReason : undefined;
-                const suffix = buildCompletionSuffix({
-                    count,
-                    filesMatched,
-                    scope,
-                    stoppedReason,
-                });
+                const suffix = buildCompletionSuffix(count, filesMatched, scope, stoppedReason);
                 const finalCurrent = resolveFinalProgressCurrent(progress, (sc.filesScanned ?? 0) + 1);
-                progress.complete(`🔎︎ grep: ${pattern} • ${suffix}`, finalCurrent);
+                progress.complete(`${progressLabel} • ${suffix}`, finalCurrent);
                 return result;
             }
             catch (error) {
-                progress.fail(`🔎︎ grep: ${pattern} • failed`);
+                progress.fail(`${progressLabel} • failed`);
                 throw error;
             }
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.E_UNKNOWN, args.path ?? '.'),
     });
-    function buildCompletionSuffix(params) {
-        if (params.count === 0) {
-            return `No matches in ${params.scope}`;
-        }
-        const matchWord = params.count === 1 ? 'match' : 'matches';
-        const fileWord = params.filesMatched === 1 ? 'file' : 'files';
-        const reasonLabels = {
-            timeout: 'timeout',
-            maxResults: 'max results',
-            maxFiles: 'max files',
-        };
-        const reasonSuffix = params.stoppedReason !== undefined
-            ? ` [${reasonLabels[params.stoppedReason]}]`
-            : '';
-        return `${params.count} ${matchWord} in ${params.filesMatched} ${fileWord}${reasonSuffix}`;
-    }
     const { isInitialized } = options;
     const wrappedHandler = wrapToolHandler(handler, {
         guard: isInitialized,

package/dist/tools/shared.js

@@ -34,6 +34,36 @@ export const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS = {
     destructiveHint: false,
     openWorldHint: false,
 };
+function isTaskSupportLevel(value) {
+    return value === 'optional' || value === 'required' || value === 'forbidden';
+}
+function normalizeToolExecution(tool) {
+    const candidate = tool;
+    const topLevelTaskSupport = candidate['taskSupport'];
+    const existingExecution = candidate['execution'] && typeof candidate['execution'] === 'object'
+        ? candidate['execution']
+        : undefined;
+    const executionTaskSupport = existingExecution?.['taskSupport'];
+    const resolvedTaskSupport = isTaskSupportLevel(topLevelTaskSupport)
+        ? topLevelTaskSupport
+        : isTaskSupportLevel(executionTaskSupport)
+            ? executionTaskSupport
+            : undefined;
+    if (resolvedTaskSupport === undefined && topLevelTaskSupport === undefined) {
+        return tool;
+    }
+    const normalized = { ...candidate };
+    delete normalized['taskSupport'];
+    if (resolvedTaskSupport !== undefined || existingExecution !== undefined) {
+        normalized['execution'] = {
+            ...(existingExecution ?? {}),
+            ...(resolvedTaskSupport !== undefined
+                ? { taskSupport: resolvedTaskSupport }
+                : {}),
+        };
+    }
+    return normalized;
+}
 export function shouldStripStructuredOutput() {
     return parseTrueEnvFlag(process.env['FS_CONTEXT_STRIP_STRUCTURED']);
 }
@@ -133,15 +163,16 @@ function canReportProgress(extra) {
     return canSendProgress(extra) || hasTask;
 }
 export function withDefaultIcons(tool, iconInfo) {
+    const normalizedTool = normalizeToolExecution(tool);
     if (!iconInfo) {
-        return maybeStripOutputSchema(tool);
+        return maybeStripOutputSchema(normalizedTool);
     }
-    const existingIcons = tool.icons;
+    const existingIcons = normalizedTool.icons;
     if (existingIcons && existingIcons.length > 0) {
-        return maybeStripOutputSchema(tool);
+        return maybeStripOutputSchema(normalizedTool);
     }
     const withIcons = {
-        ...tool,
+        ...normalizedTool,
         icons: [
             {
                 src: iconInfo.src,
@@ -440,13 +471,14 @@ export function decodeOffsetCursor(cursor) {
             parsed !== null &&
             typeof parsed.offset === 'number') {
             const { offset } = parsed;
-            return Number.isInteger(offset) && offset >= 0 ? offset : 0;
+            if (Number.isInteger(offset) && offset >= 0)
+                return offset;
         }
     }
     catch {
-        // ignore malformed cursor
+        // fall through to throw
     }
-    return 0;
+    throw new McpError(ErrorCode.E_INVALID_INPUT, `Invalid cursor: the cursor value is malformed or corrupted. Request the first page without a cursor.`);
 }
 export function buildBatchPathContext(paths, unitLabel = 'paths') {
     const normalizedLabel = paths.length === 1 ? unitLabel.replace(/s$/i, '') : unitLabel;

package/dist/tools/stat-many.js

@@ -35,24 +35,18 @@ async function handleGetMultipleFileInfo(args, signal, onProgress) {
         ...(signal ? { signal } : {}),
         ...(onProgress ? { onProgress } : {}),
     });
-    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 structuredResults = result.results.map((entry) => ({
+        path: entry.path,
+        info: entry.info ? buildFileInfoPayload(entry.info) : undefined,
+        error: entry.error,
+    }));
+    const text = result.results
+        .map((entry) => entry.error
+        ? `${entry.path}: ${entry.error}`
+        : entry.info
+            ? formatFileInfoDetail(entry.info)
+            : entry.path)
+        .join('\n\n');
     const structured = {
         ok: true,
         results: structuredResults,
@@ -62,7 +56,6 @@ async function handleGetMultipleFileInfo(args, signal, onProgress) {
             failed: result.summary.failed,
         },
     };
-    const text = textBlocks.join('\n\n');
     return buildToolResponse(text, structured);
 }
 export function registerGetMultipleFileInfoTool(server, options = {}) {

package/dist/tools/stat.js

@@ -14,7 +14,7 @@ export const GET_FILE_INFO_TOOL = {
     inputSchema: GetFileInfoInputSchema,
     outputSchema: GetFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    taskSupport: 'optional',
+    taskSupport: 'forbidden',
     nuances: ['Use before read/search when file size/type uncertainty exists.'],
 };
 function formatFileInfoDetails(info) {

package/dist/tools/task-support.d.ts

@@ -1,8 +1,15 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import type { ToolTaskHandler } from '@modelcontextprotocol/sdk/experimental/tasks/interfaces.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AnySchema, SchemaOutput, ShapeOutput, ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
 import type { RequestTaskStore } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { IconInfo, ToolExtra, ToolResult } from './shared.js';
+export interface TaskContext {
+    taskId: string;
+    toolName?: string | undefined;
+    startTime: number;
+}
+export declare const taskContext: AsyncLocalStorage<TaskContext>;
 type TaskToolExtra = ToolExtra & {
     taskId?: string;
     taskStore?: RequestTaskStore;