@j0hanz/filesystem-mcp 1.16.2 → 1.16.3

package/dist/tools/roots.js

@@ -2,8 +2,9 @@ import { ErrorCode } from '../lib/errors.js';
 import { getAllowedDirectories } from '../lib/paths.js';
 import { joinLines } from '../config.js';
 import { ListAllowedDirectoriesInputSchema, ListAllowedDirectoriesOutputSchema, } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { DIRECTORY_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const LIST_ALLOWED_DIRECTORIES_TOOL = {
     name: 'roots',
     title: 'Workspace Roots',
@@ -11,6 +12,7 @@ export const LIST_ALLOWED_DIRECTORIES_TOOL = {
     inputSchema: ListAllowedDirectoriesInputSchema,
     outputSchema: ListAllowedDirectoriesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: DIRECTORY_ICONS,
     taskSupport: 'forbidden',
 };
 function buildTextRoots(dirs) {
@@ -31,15 +33,14 @@ function handleListAllowedDirectories() {
     return buildToolResponse(buildTextRoots(dirs), structured);
 }
 export function registerListAllowedDirectoriesTool(server, options = {}) {
-    const handler = (_args, extra) => executeToolWithDiagnostics({
+    const handler = (_args, ctx) => executeToolWithDiagnostics({
         toolName: 'roots',
-        extra,
+        ctx,
         outputSchema: ListAllowedDirectoriesOutputSchema,
         run: () => handleListAllowedDirectories(),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, LIST_ALLOWED_DIRECTORIES_TOOL, handler, options, {
         progressMessage: () => '≣ roots',
         completionMessage: (_args, result) => {
             if (result.isError)
@@ -49,8 +50,4 @@ export function registerListAllowedDirectoriesTool(server, options = {}) {
             return `≣ roots • ${count} ${count === 1 ? 'root' : 'roots'}`;
         },
     });
-    const validatedHandler = withValidatedArgs(ListAllowedDirectoriesInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'roots', LIST_ALLOWED_DIRECTORIES_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('roots', withDefaultIcons({ ...LIST_ALLOWED_DIRECTORIES_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools/search-content.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const SEARCH_CONTENT_TOOL: ToolContract;
 export declare function registerSearchContentTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/search-content.js

@@ -5,8 +5,9 @@ import { ErrorCode, formatUnknownErrorMessage, McpError, } from '../lib/errors.j
 import { searchContent, } from '../lib/file-operations/search.js';
 import { formatOperationSummary } from '../config.js';
 import { SearchContentInputSchema, SearchContentOutputSchema, } from '../schemas.js';
-import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { SEARCH_ICONS } from './icons.js';
+import { buildResourceLink, buildToolErrorResponse, buildToolResponse, createToolProgressSession, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, resolvePathOrRoot, truncateProgressPattern, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 /**
  * Configuration constants for the Search Content tool.
  */
@@ -70,6 +71,7 @@ export const SEARCH_CONTENT_TOOL = {
     inputSchema: SearchContentInputSchema,
     outputSchema: SearchContentOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: SEARCH_ICONS,
     nuances: [
         'Inline results capped at 50 matches; full results via `resourceUri`.',
     ],
@@ -259,15 +261,15 @@ async function handleSearchContent(args, signal, resourceStore, onProgress) {
     return buildToolResponse(text, fullStructured);
 }
 export function registerSearchContentTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'grep',
-        extra,
+        ctx,
         outputSchema: SearchContentOutputSchema,
         context: { path: args.path ?? '.' },
         run: async (signal) => {
             const { pattern, filePattern: scope } = args;
             const progressLabel = `🔎︎ grep: ${truncateProgressPattern(pattern)}`;
-            const progress = createToolProgressSession(extra, progressLabel);
+            const progress = createToolProgressSession(ctx, progressLabel);
             const progressWithMessage = ({ current, total, }) => {
                 progress.update({
                     current,
@@ -291,12 +293,5 @@ export function registerSearchContentTool(server, options = {}) {
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path ?? '.'),
     });
-    const { isInitialized } = options;
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(SearchContentInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'grep', SEARCH_CONTENT_TOOL, validatedHandler, options.iconInfo, isInitialized))
-        return;
-    server.registerTool('grep', withDefaultIcons({ ...SEARCH_CONTENT_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, SEARCH_CONTENT_TOOL, handler, options);
 }

package/dist/tools/search-files.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const SEARCH_FILES_TOOL: ToolContract;
 export declare function registerSearchFilesTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/search-files.js

@@ -4,8 +4,9 @@ import { ErrorCode } from '../lib/errors.js';
 import { searchFiles } from '../lib/file-operations/search.js';
 import { formatOperationSummary, joinLines } from '../config.js';
 import { SearchFilesInputSchema, SearchFilesOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, decodeOffsetCursor, encodeOffsetCursor, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, truncateProgressPattern, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { DIRECTORY_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, decodeOffsetCursor, encodeOffsetCursor, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, truncateProgressPattern, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const SEARCH_FILES_TOOL = {
     name: 'find',
     title: 'Find Files',
@@ -14,6 +15,7 @@ export const SEARCH_FILES_TOOL = {
     inputSchema: SearchFilesInputSchema,
     outputSchema: SearchFilesOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: DIRECTORY_ICONS,
     nuances: ['Respects `.gitignore` unless `includeIgnored=true`.'],
     taskSupport: 'optional',
 };
@@ -109,9 +111,9 @@ async function handleSearchFiles(args, signal, onProgress) {
     return buildToolResponse(text, structured);
 }
 export function registerSearchFilesTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'find',
-        extra,
+        ctx,
         outputSchema: SearchFilesOutputSchema,
         timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
         context: { path: args.path ?? '.' },
@@ -122,11 +124,11 @@ export function registerSearchFilesTool(server, options = {}) {
             const truncatedPattern = truncateProgressPattern(pattern);
             const context = `${truncatedPattern} in ${scopeLabel}`;
             let progressCursor = 0;
-            notifyProgress(extra, {
+            notifyProgress(ctx, {
                 current: 0,
                 message: `🔎︎ find: ${truncatedPattern}`,
             });
-            const baseReporter = createProgressReporter(extra);
+            const baseReporter = createProgressReporter(ctx);
             const progressWithMessage = ({ current, total, }) => {
                 if (current > progressCursor)
                     progressCursor = current;
@@ -157,7 +159,7 @@ export function registerSearchFilesTool(server, options = {}) {
                     }
                 }
                 const finalCurrent = Math.max((sc.filesScanned ?? 0) + 1, progressCursor + 1);
-                notifyProgress(extra, {
+                notifyProgress(ctx, {
                     current: finalCurrent,
                     total: finalCurrent,
                     message: `🔎︎ find: ${context} • ${suffix}`,
@@ -166,7 +168,7 @@ export function registerSearchFilesTool(server, options = {}) {
             }
             catch (error) {
                 const finalCurrent = Math.max(progressCursor + 1, 1);
-                notifyProgress(extra, {
+                notifyProgress(ctx, {
                     current: finalCurrent,
                     total: finalCurrent,
                     message: `🔎︎ find: ${context} • failed`,
@@ -176,12 +178,5 @@ export function registerSearchFilesTool(server, options = {}) {
         },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
-    const { isInitialized } = options;
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(SearchFilesInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'find', SEARCH_FILES_TOOL, validatedHandler, options.iconInfo, isInitialized))
-        return;
-    server.registerTool('find', withDefaultIcons({ ...SEARCH_FILES_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, SEARCH_FILES_TOOL, handler, options);
 }

package/dist/tools/shared.d.ts

@@ -1,4 +1,4 @@
-import type { ContentBlock, Icon, ProgressNotificationParams } from '@modelcontextprotocol/sdk/types.js';
+import type { ContentBlock, Icon, LoggingLevel, ProgressNotificationParams, ServerContext } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import { ErrorCode } from '../lib/errors.js';
 import type { ResourceStore } from '../lib/resource-store.js';
@@ -22,6 +22,8 @@ export declare const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS: {
     readonly destructiveHint: false;
     readonly openWorldHint: false;
 };
+export type TaskSupportLevel = 'optional' | 'required' | 'forbidden';
+export declare function resolveToolTaskSupportLevel(topLevelTaskSupport: unknown, executionTaskSupport: unknown): TaskSupportLevel | undefined;
 export declare function maybeStripStructuredContentFromResult<T extends object>(result: T): T;
 type ResourceEntry = ReturnType<ResourceStore['putText']>;
 export declare function maybeExternalizeTextContent(resourceStore: ResourceStore | undefined, content: string, params: {
@@ -54,23 +56,24 @@ export type ToolResponse<T> = ReturnType<typeof buildToolResponse<T>> & {
 interface ToolErrorResponse extends Record<string, unknown> {
     content: ContentBlock[];
     isError: true;
-    errorCode?: string;
+    errorCode?: ErrorCode;
 }
 export type ToolResult<T> = ToolResponse<T> | ToolErrorResponse;
-export declare function withValidatedArgs<Args, Result>(schema: z.ZodType<Args>, handler: (args: Args, extra: ToolExtra) => Promise<ToolResult<Result>>): (args: unknown, extra: ToolExtra) => Promise<ToolResult<Result>>;
+export declare function withValidatedArgs<Args, Result>(schema: z.ZodType<Args>, handler: (args: Args, ctx: ToolContext) => Promise<ToolResult<Result>>): (args: unknown, ctx: ToolContext | ServerContext) => Promise<ToolResult<Result>>;
 type ProgressToken = string | number;
-export interface ToolExtra {
+export interface ToolContext {
     signal?: AbortSignal;
     _meta?: {
         progressToken?: ProgressToken | undefined;
         traceparent?: string | undefined;
         tracestate?: string | undefined;
         baggage?: string | undefined;
-    };
+    } | undefined;
     sendNotification?: (notification: {
         method: 'notifications/progress';
         params: ProgressNotificationParams;
     }) => Promise<void>;
+    log?: (level: LoggingLevel, data: unknown, logger?: string) => Promise<void>;
 }
 export interface IconInfo {
     src: string;
@@ -102,7 +105,7 @@ interface FileInfoPayload {
 export declare function buildFileInfoPayload(info: FileInfo): FileInfoPayload;
 interface ToolExecutionOptions<T> {
     toolName: string;
-    extra: ToolExtra;
+    ctx: ToolContext;
     outputSchema?: z.ZodType<T>;
     run: (signal: AbortSignal | undefined) => ToolResponse<T> | Promise<ToolResponse<T>>;
     onError: (error: unknown) => ToolResult<T>;
@@ -113,12 +116,12 @@ interface ToolExecutionOptions<T> {
 }
 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: {
+export declare function createProgressReporter(ctx: ToolContext): (progress: {
     total?: number;
     current: number;
     message?: string;
 }) => void;
-export declare function notifyProgress(extra: ToolExtra, progress: {
+export declare function notifyProgress(ctx: ToolContext, progress: {
     current: number;
     total?: number;
     message?: string;
@@ -138,19 +141,19 @@ interface BatchProgressCallbacks {
     progress: ToolProgressSession;
     onItemComplete: () => void;
 }
-export declare function createToolProgressSession(extra: ToolExtra, startMessage: string, initialTotal?: number): ToolProgressSession;
-export declare function createBatchProgressCallbacks(extra: ToolExtra, params: {
+export declare function createToolProgressSession(ctx: ToolContext, startMessage: string, initialTotal?: number): ToolProgressSession;
+export declare function createBatchProgressCallbacks(ctx: ToolContext, params: {
     toolLabel: string;
     context: string;
     totalItems: number;
     itemVerb: string;
 }): BatchProgressCallbacks;
 export declare function resolveFinalProgressCurrent(progress: ToolProgressSession, ...candidates: number[]): number;
-export declare function wrapToolHandler<Args, Result>(handler: (args: Args, extra: ToolExtra) => Promise<ToolResult<Result>>, options: {
+export declare function wrapToolHandler<Args, Result>(handler: (args: Args, ctx: ToolContext) => Promise<ToolResult<Result>>, options: {
     guard?: (() => boolean) | undefined;
     progressMessage?: (args: Args) => string;
     completionMessage?: (args: Args, result: ToolResult<Result>) => string | undefined;
-}): (args: Args, extra?: ToolExtra) => Promise<ToolResult<Result>>;
+}): (args: Args, ctx?: ToolContext | ServerContext) => Promise<ToolResult<Result>>;
 /**
  * Returns `pathValue` if non-empty; otherwise resolves to the single allowed
  * directory from module-level state managed by `RootsManager`. Throws when the

package/dist/tools/shared.js

@@ -53,32 +53,43 @@ export const IDEMPOTENT_WRITE_TOOL_ANNOTATIONS = {
 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']
+function getExecutionConfig(candidate) {
+    const { execution } = candidate;
+    return execution && typeof execution === 'object'
+        ? execution
         : undefined;
-    const executionTaskSupport = existingExecution?.['taskSupport'];
-    let resolvedTaskSupport;
+}
+export function resolveToolTaskSupportLevel(topLevelTaskSupport, executionTaskSupport) {
     if (isTaskSupportLevel(topLevelTaskSupport)) {
-        resolvedTaskSupport = topLevelTaskSupport;
+        return topLevelTaskSupport;
+    }
+    if (isTaskSupportLevel(executionTaskSupport)) {
+        return executionTaskSupport;
     }
-    else if (isTaskSupportLevel(executionTaskSupport)) {
-        resolvedTaskSupport = executionTaskSupport;
+    return undefined;
+}
+function buildNormalizedExecution(existingExecution, taskSupport) {
+    if (taskSupport === undefined && existingExecution === undefined) {
+        return undefined;
     }
+    return {
+        ...(existingExecution ?? {}),
+        ...(taskSupport !== undefined ? { taskSupport } : {}),
+    };
+}
+function normalizeToolExecution(tool) {
+    const candidate = tool;
+    const topLevelTaskSupport = candidate['taskSupport'];
+    const existingExecution = getExecutionConfig(candidate);
+    const resolvedTaskSupport = resolveToolTaskSupportLevel(topLevelTaskSupport, existingExecution?.['taskSupport']);
     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 }
-                : {}),
-        };
+    const execution = buildNormalizedExecution(existingExecution, resolvedTaskSupport);
+    if (execution !== undefined) {
+        normalized['execution'] = execution;
     }
     return normalized;
 }
@@ -199,10 +210,10 @@ function parseToolArgs(schema, args) {
     throw new McpError(ErrorCode.INVALID_INPUT, `Invalid tool arguments:\n${z.prettifyError(parsed.error)}`);
 }
 export function withValidatedArgs(schema, handler) {
-    return async (args, extra) => {
+    return async (args, ctx) => {
         try {
             const normalizedArgs = parseToolArgs(schema, args);
-            return await handler(normalizedArgs, extra);
+            return await handler(normalizedArgs, toToolContext(ctx));
         }
         catch (error) {
             if (error instanceof McpError && error.code === ErrorCode.INVALID_INPUT) {
@@ -212,14 +223,31 @@ export function withValidatedArgs(schema, handler) {
         }
     };
 }
-function canSendProgress(extra) {
-    return (extra._meta?.progressToken !== undefined &&
-        extra.sendNotification !== undefined);
+function toToolContext(ctx) {
+    if (!ctx)
+        return {};
+    if ('mcpReq' in ctx) {
+        return {
+            signal: ctx.mcpReq.signal,
+            ...(ctx.mcpReq._meta
+                ? { _meta: ctx.mcpReq._meta }
+                : {}),
+            sendNotification: async (notification) => ctx.mcpReq.notify(notification),
+            log: async (level, data, logger) => ctx.mcpReq.notify({
+                method: 'notifications/message',
+                params: { level, data, ...(logger ? { logger } : {}) },
+            }),
+        };
+    }
+    return ctx;
+}
+function canSendProgress(ctx) {
+    return (ctx._meta?.progressToken !== undefined && ctx.sendNotification !== undefined);
 }
-function canReportProgress(extra) {
-    const taskExtra = extra;
+function canReportProgress(ctx) {
+    const taskExtra = ctx;
     const hasTask = taskExtra.taskId !== undefined && taskExtra.taskStore !== undefined;
-    return canSendProgress(extra) || hasTask;
+    return canSendProgress(ctx) || hasTask;
 }
 export function withDefaultIcons(tool, iconInfo) {
     const normalizedTool = normalizeToolExecution(tool);
@@ -278,9 +306,9 @@ function getToolSignal(extraSignal, timedSignal) {
     return { signal, cleanup };
 }
 export async function executeToolWithDiagnostics(options) {
-    const traceContext = extractTraceContext(options.extra._meta);
+    const traceContext = extractTraceContext(options.ctx._meta);
     return withToolDiagnostics(options.toolName, () => withToolErrorHandling(async () => {
-        const { signal, cleanup } = getToolSignal(options.extra.signal, options.timedSignal);
+        const { signal, cleanup } = getToolSignal(options.ctx.signal, options.timedSignal);
         try {
             return validateToolResponse(options.toolName, await options.run(signal), options.outputSchema);
         }
@@ -304,9 +332,9 @@ export function buildToolErrorResponse(error, defaultCode, path) {
 function buildNotInitializedResult() {
     return buildToolErrorResponse(NOT_INITIALIZED_ERROR, ErrorCode.INVALID_INPUT);
 }
-async function reportProgress(extra, progress) {
-    await updateTaskStoreProgress(extra, progress);
-    await sendMcpProgressNotification(extra, progress);
+async function reportProgress(ctx, progress) {
+    await updateTaskStoreProgress(ctx, progress);
+    await sendMcpProgressNotification(ctx, progress);
 }
 function formatTaskStatusMessage(progress) {
     if (progress.total !== undefined) {
@@ -320,8 +348,8 @@ function isBenignTaskStatusUpdateError(error) {
     return (error instanceof Error &&
         /Task .*not found|terminal status/iu.test(error.message));
 }
-async function updateTaskStoreProgress(extra, progress) {
-    const taskExtra = extra;
+async function updateTaskStoreProgress(ctx, progress) {
+    const taskExtra = ctx;
     if (typeof taskExtra.taskId === 'string' &&
         taskExtra.taskStore !== undefined &&
         taskExtra.taskStore !== null) {
@@ -338,13 +366,13 @@ async function updateTaskStoreProgress(extra, progress) {
         }
     }
 }
-async function sendMcpProgressNotification(extra, progress) {
-    if (canSendProgress(extra)) {
+async function sendMcpProgressNotification(ctx, progress) {
+    if (canSendProgress(ctx)) {
         try {
-            await extra.sendNotification({
+            await ctx.sendNotification({
                 method: 'notifications/progress',
                 params: {
-                    progressToken: extra._meta.progressToken,
+                    progressToken: ctx._meta.progressToken,
                     progress: progress.current,
                     ...(progress.total !== undefined ? { total: progress.total } : {}),
                     ...(progress.message !== undefined
@@ -358,8 +386,8 @@ async function sendMcpProgressNotification(extra, progress) {
         }
     }
 }
-export function createProgressReporter(extra) {
-    if (!canReportProgress(extra)) {
+export function createProgressReporter(ctx) {
+    if (!canReportProgress(ctx)) {
         return () => { };
     }
     // State for monotonic enforcement and rate-limiting.
@@ -379,26 +407,26 @@ export function createProgressReporter(extra) {
             return;
         lastProgress = current;
         lastSentMs = now;
-        void reportProgress(extra, {
+        void reportProgress(ctx, {
             current,
             ...(total !== undefined ? { total } : {}),
             ...(message !== undefined ? { message } : {}),
         });
     };
 }
-export function notifyProgress(extra, progress) {
-    if (!canReportProgress(extra))
+export function notifyProgress(ctx, progress) {
+    if (!canReportProgress(ctx))
         return;
-    void reportProgress(extra, progress);
+    void reportProgress(ctx, progress);
 }
-export function createToolProgressSession(extra, startMessage, initialTotal) {
-    notifyProgress(extra, {
+export function createToolProgressSession(ctx, startMessage, initialTotal) {
+    notifyProgress(ctx, {
         current: 0,
         ...(initialTotal !== undefined ? { total: initialTotal } : {}),
         message: startMessage,
     });
     let cursor = 0;
-    const baseReporter = createProgressReporter(extra);
+    const baseReporter = createProgressReporter(ctx);
     const setCursor = (value) => {
         if (value > cursor)
             cursor = value;
@@ -406,7 +434,7 @@ export function createToolProgressSession(extra, startMessage, initialTotal) {
     };
     const finishProgress = (message, minimumCurrent) => {
         const finalCurrent = Math.max(cursor + 1, minimumCurrent ?? 1, 1);
-        notifyProgress(extra, {
+        notifyProgress(ctx, {
             current: finalCurrent,
             total: finalCurrent,
             ...(message !== undefined ? { message } : {}),
@@ -434,8 +462,8 @@ export function createToolProgressSession(extra, startMessage, initialTotal) {
         getCurrent: () => cursor,
     };
 }
-export function createBatchProgressCallbacks(extra, params) {
-    const progress = createToolProgressSession(extra, `${params.toolLabel}: ${params.context}`, params.totalItems);
+export function createBatchProgressCallbacks(ctx, params) {
+    const progress = createToolProgressSession(ctx, `${params.toolLabel}: ${params.context}`, params.totalItems);
     let itemsDone = 0;
     const onItemComplete = () => {
         itemsDone++;
@@ -456,21 +484,21 @@ export function resolveFinalProgressCurrent(progress, ...candidates) {
     }
     return finalCurrent;
 }
-async function withProgress(message, extra, run, getCompletionMessage) {
-    if (!canReportProgress(extra)) {
+async function withProgress(message, ctx, run, getCompletionMessage) {
+    if (!canReportProgress(ctx)) {
         return run();
     }
     const total = 1;
     // Emit the start notification only when a progressToken is present; for
     // task-only mode the task status is already 'working' — a zero-progress
     // notification would add unnecessary overhead without client value.
-    if (canSendProgress(extra)) {
-        await reportProgress(extra, { current: 0, total, message });
+    if (canSendProgress(ctx)) {
+        await reportProgress(ctx, { current: 0, total, message });
     }
     try {
         const result = await run();
         const endMessage = getCompletionMessage?.(result) ?? message;
-        await reportProgress(extra, {
+        await reportProgress(ctx, {
             current: total,
             total,
             message: endMessage,
@@ -478,7 +506,7 @@ async function withProgress(message, extra, run, getCompletionMessage) {
         return result;
     }
     catch (error) {
-        void reportProgress(extra, {
+        void reportProgress(ctx, {
             current: total,
             total,
             message: `${message} • failed`,
@@ -487,8 +515,8 @@ async function withProgress(message, extra, run, getCompletionMessage) {
     }
 }
 export function wrapToolHandler(handler, options) {
-    return async (args, extra) => {
-        const resolvedExtra = extra ?? {};
+    return async (args, ctx) => {
+        const resolvedExtra = toToolContext(ctx);
         if (options.guard && !options.guard()) {
             return maybeStripStructuredContentFromResult(buildNotInitializedResult());
         }

package/dist/tools/stat-many.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const GET_MULTIPLE_FILE_INFO_TOOL: ToolContract;
 export declare function registerGetMultipleFileInfoTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/stat-many.js

@@ -3,8 +3,9 @@ import { ErrorCode } from '../lib/errors.js';
 import { getMultipleFileInfo } from '../lib/file-operations/metadata.js';
 import { formatBytes, joinLines } from '../config.js';
 import { GetMultipleFileInfoInputSchema, GetMultipleFileInfoOutputSchema, } from '../schemas.js';
-import { buildBatchCompletionSuffix, buildBatchPathContext, buildFileInfoPayload, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_READ_ICONS } from './icons.js';
+import { buildBatchCompletionSuffix, buildBatchPathContext, buildFileInfoPayload, buildStructuredError, buildToolErrorResponse, buildToolResponse, createBatchProgressCallbacks, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, resolveFinalProgressCurrent, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const GET_MULTIPLE_FILE_INFO_TOOL = {
     name: 'stat_many',
     title: 'Get Multiple File Info',
@@ -13,6 +14,7 @@ export const GET_MULTIPLE_FILE_INFO_TOOL = {
     inputSchema: GetMultipleFileInfoInputSchema,
     outputSchema: GetMultipleFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: FILE_READ_ICONS,
     taskSupport: 'optional',
 };
 function formatFileInfoDetail(info) {
@@ -64,17 +66,17 @@ async function handleGetMultipleFileInfo(args, signal, onProgress) {
     return buildToolResponse(text, structured);
 }
 export function registerGetMultipleFileInfoTool(server, options = {}) {
-    const handler = (args, extra) => {
+    const handler = (args, ctx) => {
         const primaryPath = args.paths[0] ?? '';
         return executeToolWithDiagnostics({
             toolName: 'stat_many',
-            extra,
+            ctx,
             outputSchema: GetMultipleFileInfoOutputSchema,
             timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
             context: { path: primaryPath },
             run: async (signal) => {
                 const context = buildBatchPathContext(args.paths);
-                const { progress, onItemComplete } = createBatchProgressCallbacks(extra, {
+                const { progress, onItemComplete } = createBatchProgressCallbacks(ctx, {
                     toolLabel: '🕮 stat_many',
                     context,
                     totalItems: args.paths.length,
@@ -97,11 +99,5 @@ export function registerGetMultipleFileInfoTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FOUND, primaryPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(GetMultipleFileInfoInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'stat_many', GET_MULTIPLE_FILE_INFO_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('stat_many', withDefaultIcons({ ...GET_MULTIPLE_FILE_INFO_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, GET_MULTIPLE_FILE_INFO_TOOL, handler, options);
 }

package/dist/tools/stat.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract, type ToolRegistrationOptions } from './shared.js';
 export declare const GET_FILE_INFO_TOOL: ToolContract;
 export declare function registerGetFileInfoTool(server: McpServer, options?: ToolRegistrationOptions): void;