@j0hanz/filesystem-mcp 1.16.2 → 1.16.3

package/dist/tools/stat.js

@@ -4,8 +4,9 @@ import { ErrorCode } from '../lib/errors.js';
 import { getFileInfo } from '../lib/file-operations/metadata.js';
 import { formatBytes, joinLines } from '../config.js';
 import { GetFileInfoInputSchema, GetFileInfoOutputSchema } from '../schemas.js';
-import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_READ_ICONS } from './icons.js';
+import { buildFileInfoPayload, buildToolErrorResponse, buildToolResponse, executeToolWithDiagnostics, READ_ONLY_TOOL_ANNOTATIONS, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const GET_FILE_INFO_TOOL = {
     name: 'stat',
     title: 'Get File Info',
@@ -14,6 +15,7 @@ export const GET_FILE_INFO_TOOL = {
     inputSchema: GetFileInfoInputSchema,
     outputSchema: GetFileInfoOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: FILE_READ_ICONS,
     taskSupport: 'forbidden',
 };
 function formatFileInfoDetails(info) {
@@ -41,17 +43,16 @@ async function handleGetFileInfo(args, signal) {
     return buildToolResponse(formatFileInfoDetails(info), structured);
 }
 export function registerGetFileInfoTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'stat',
-        extra,
+        ctx,
         outputSchema: GetFileInfoOutputSchema,
         timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
         context: { path: args.path },
         run: (signal) => handleGetFileInfo(args, signal),
         onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FOUND, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, GET_FILE_INFO_TOOL, handler, options, {
         progressMessage: (args) => `🕮 stat: ${basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = basename(args.path);
@@ -63,8 +64,4 @@ export function registerGetFileInfoTool(server, options = {}) {
             return `🕮 stat: ${sc.info.name} • ${sc.info.type}, ${formatBytes(sc.info.size)}`;
         },
     });
-    const validatedHandler = withValidatedArgs(GetFileInfoInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'stat', GET_FILE_INFO_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('stat', withDefaultIcons({ ...GET_FILE_INFO_TOOL }, options.iconInfo), validatedHandler);
 }

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

@@ -1,22 +1,24 @@
-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, type ToolExtra, type ToolResult } from './shared.js';
-type TaskToolExtra = ToolExtra & {
+import { type McpServer, type RequestTaskStore, type StandardSchemaWithJSON, type ToolTaskHandler } from '@modelcontextprotocol/server';
+import { type IconInfo, type ToolContext, type ToolContract, type ToolRegistrationOptions, type ToolResult } from './shared.js';
+type TaskToolContext = ToolContext & {
     taskId?: string;
     taskStore?: RequestTaskStore;
-    taskRequestedTtl?: number | null;
+    taskRequestedTtl?: number;
 };
-export type ToolSchema = ZodRawShapeCompat | AnySchema | undefined;
-type ToolArgs<Args extends ToolSchema> = Args extends ZodRawShapeCompat ? ShapeOutput<Args> : Args extends AnySchema ? SchemaOutput<Args> : undefined;
-export declare function registerToolTaskIfAvailable<Args extends ToolSchema, Result>(server: McpServer, toolName: string, toolDef: object, run: (args: ToolArgs<Args>, extra: TaskToolExtra) => Promise<ToolResult<Result>>, iconInfo: IconInfo | undefined, guard?: () => boolean): boolean;
+type ToolSchema = StandardSchemaWithJSON | undefined;
+type ToolArgs<Args extends ToolSchema> = Args extends StandardSchemaWithJSON ? StandardSchemaWithJSON.InferOutput<Args> : undefined;
+export declare function registerToolTaskIfAvailable<Args extends ToolSchema, Result>(server: McpServer, toolName: string, toolDef: object, run: (args: ToolArgs<Args>, ctx: TaskToolContext) => Promise<ToolResult<Result>>, iconInfo: IconInfo | undefined, guard?: () => boolean): boolean;
+export declare function registerStandardTool<Args, Result extends Record<string, unknown>>(server: McpServer, toolDef: ToolContract, handler: (args: Args, ctx: ToolContext) => Promise<ToolResult<Result>>, options?: ToolRegistrationOptions, wrapOptions?: {
+    guard?: (() => boolean) | undefined;
+    progressMessage?: (args: Args) => string;
+    completionMessage?: (args: Args, result: ToolResult<Result>) => string | undefined;
+}): void;
 interface TaskHandlerOptions {
     guard?: () => boolean;
     toolName?: string;
     cancelPollMs?: number;
     pollIntervalMs?: number;
 }
-export declare function createToolTaskHandler<Result>(run: (args: undefined, extra: TaskToolExtra) => Promise<ToolResult<Result>>, options?: TaskHandlerOptions): ToolTaskHandler;
-export declare function createToolTaskHandler<Args extends ZodRawShapeCompat | AnySchema, Result>(run: (args: ToolArgs<Args>, extra: TaskToolExtra) => Promise<ToolResult<Result>>, options?: TaskHandlerOptions): ToolTaskHandler<Args>;
+export declare function createToolTaskHandler<Result>(run: (args: undefined, ctx: TaskToolContext) => Promise<ToolResult<Result>>, options?: TaskHandlerOptions): ToolTaskHandler;
+export declare function createToolTaskHandler<Args extends StandardSchemaWithJSON, Result>(run: (args: ToolArgs<Args>, ctx: TaskToolContext) => Promise<ToolResult<Result>>, options?: TaskHandlerOptions): ToolTaskHandler<Args>;
 export {};

package/dist/tools/task-support.js

@@ -1,4 +1,4 @@
-import { CallToolResultSchema, } from '@modelcontextprotocol/sdk/types.js';
+import {} from '@modelcontextprotocol/server';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { channel } from 'node:diagnostics_channel';
 import { performance } from 'node:perf_hooks';
@@ -7,7 +7,7 @@ import { DEFAULT_TASK_TTL_MS, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, TASK_CANCEL
 import { ErrorCode, McpError } from '../lib/errors.js';
 import { Logger } from '../lib/logger.js';
 import { isRecord } from '../lib/utils.js';
-import { buildToolErrorResponse, maybeStripStructuredContentFromResult, withDefaultIcons, } from './shared.js';
+import { buildToolErrorResponse, maybeStripStructuredContentFromResult, resolveToolTaskSupportLevel, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
 const taskContext = new AsyncLocalStorage();
 const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
 function publishTaskDiagnostics(event) {
@@ -15,40 +15,10 @@ function publishTaskDiagnostics(event) {
         TASK_DIAGNOSTICS_CHANNEL.publish(event);
     }
 }
-function getDynamicProperty(target, key) {
-    return Reflect.get(target, key);
-}
 // --- Type Guards & Helpers ---
-function isExperimentalTaskRegistration(value) {
-    if (!isRecord(value))
-        return false;
-    const { registerToolTask } = value;
-    return (registerToolTask === undefined || typeof registerToolTask === 'function');
-}
-function getExperimentalTaskRegistration(server) {
-    const experimental = getDynamicProperty(server, 'experimental');
-    if (!isRecord(experimental))
-        return undefined;
-    const { tasks } = experimental;
-    if (!isExperimentalTaskRegistration(tasks))
-        return undefined;
-    return tasks;
-}
 function hasTaskToolCapability(server) {
-    const serverRuntime = getDynamicProperty(server, 'server');
-    if (!isRecord(serverRuntime))
-        return true; // Assume capability if runtime structure is opaque
-    const getCapabilities = getDynamicProperty(serverRuntime, 'getCapabilities');
-    if (typeof getCapabilities !== 'function')
-        return true;
-    const capabilities = getCapabilities.call(serverRuntime);
-    if (!isRecord(capabilities))
-        return false;
-    const { tasks } = capabilities;
-    return (isRecord(tasks) &&
-        isRecord(tasks.requests) &&
-        isRecord(tasks.requests.tools) &&
-        isRecord(tasks.requests.tools.call));
+    const capabilities = server.server.getCapabilities();
+    return capabilities.tasks?.requests?.tools?.call !== undefined;
 }
 const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
 const TASK_CREATED_NOTIFICATION_METHOD = 'notifications/tasks/created';
@@ -59,36 +29,51 @@ function isRequestTaskStore(value) {
         typeof value.storeTaskResult === 'function' &&
         typeof value.getTaskResult === 'function');
 }
-function isCreateTaskExtra(value) {
-    return isRecord(value) && isRequestTaskStore(value.taskStore);
-}
-function isTaskExtra(value) {
-    return (isCreateTaskExtra(value) &&
-        typeof value.taskId === 'string' &&
-        value.taskId.length > 0);
+function hasTaskStoreContext(value) {
+    return isRecord(value.task) && isRequestTaskStore(value.task.store);
 }
-function asCreateTaskExtra(value) {
-    if (!isCreateTaskExtra(value)) {
+function asCreateTaskContext(value) {
+    if (!hasTaskStoreContext(value)) {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
     }
     return value;
 }
-function asTaskRequestExtra(value) {
-    if (!isTaskExtra(value)) {
+function asTaskRequestContext(value) {
+    if (!hasTaskStoreContext(value) ||
+        !isRecord(value.task) ||
+        typeof value.task.id !== 'string' ||
+        value.task.id.length === 0) {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task id or store missing.');
     }
     return value;
 }
+function toTaskToolContext(ctx) {
+    return {
+        signal: ctx.mcpReq.signal,
+        ...(ctx.mcpReq._meta
+            ? { _meta: ctx.mcpReq._meta }
+            : {}),
+        sendNotification: async (notification) => ctx.mcpReq.notify(notification),
+        ...(hasTaskStoreContext(ctx) ? { taskStore: ctx.task.store } : {}),
+        ...(typeof ctx.task.id === 'string' && ctx.task.id.length > 0
+            ? { taskId: ctx.task.id }
+            : {}),
+        ...(ctx.task.requestedTtl !== undefined
+            ? { taskRequestedTtl: ctx.task.requestedTtl }
+            : {}),
+    };
+}
 const TASK_STATUSES = new Set([
+    'submitted',
     'working',
     'input_required',
     'completed',
     'failed',
     'cancelled',
+    'unknown',
 ]);
 function isTaskStatus(value) {
-    return (typeof value === 'string' &&
-        TASK_STATUSES.has(value));
+    return typeof value === 'string' && TASK_STATUSES.has(value);
 }
 function normalizeGetTaskResult(value) {
     if (!isRecord(value) || typeof value.taskId !== 'string') {
@@ -122,9 +107,11 @@ function normalizeGetTaskResult(value) {
     return normalized;
 }
 function normalizeCallToolResult(value) {
-    const parsed = CallToolResultSchema.safeParse(value);
-    if (parsed.success)
-        return parsed.data;
+    if (isRecord(value) &&
+        Array.isArray(value.content) &&
+        value.content.every((entry) => isRecord(entry) && typeof entry.type === 'string')) {
+        return value;
+    }
     throw new McpError(ErrorCode.INVALID_INPUT, 'Invalid stored task result.');
 }
 function getToolResultErrorCode(result) {
@@ -194,8 +181,8 @@ function buildTaskStatusNotificationParams(task) {
         params.statusMessage = task.statusMessage;
     return params;
 }
-async function notifyTaskCreatedIfPossible(extra, taskId, toolName) {
-    const { sendNotification } = extra;
+async function notifyTaskCreatedIfPossible(ctx, taskId, toolName) {
+    const { sendNotification } = ctx;
     if (typeof sendNotification !== 'function')
         return;
     const notify = sendNotification;
@@ -204,7 +191,7 @@ async function notifyTaskCreatedIfPossible(extra, taskId, toolName) {
             method: TASK_CREATED_NOTIFICATION_METHOD,
             params: {
                 _meta: {
-                    'modelcontextprotocol.io/related-task': {
+                    'io.modelcontextprotocol/related-task': {
                         taskId,
                     },
                 },
@@ -219,8 +206,8 @@ async function notifyTaskCreatedIfPossible(extra, taskId, toolName) {
         });
     }
 }
-async function notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName) {
-    const { sendNotification } = extra;
+async function notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName) {
+    const { sendNotification } = ctx;
     if (typeof sendNotification !== 'function')
         return;
     const notify = sendNotification;
@@ -247,17 +234,17 @@ async function notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName) {
         // Never fail task execution because status notifications are optional.
     }
 }
-function getTaskStore(extra) {
-    if (!extra.taskStore) {
+function getTaskStore(ctx) {
+    if (!ctx.taskStore) {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
     }
-    return extra.taskStore;
+    return ctx.taskStore;
 }
-function getTaskId(extra) {
-    if (!extra.taskId) {
+function getTaskId(ctx) {
+    if (!ctx.taskId) {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task id missing.');
     }
-    return extra.taskId;
+    return ctx.taskId;
 }
 function isErrorResult(result) {
     return 'isError' in result && result.isError;
@@ -274,6 +261,7 @@ const TERMINAL_TASK_STATUSES = new Set([
     'completed',
     'failed',
     'cancelled',
+    'unknown',
 ]);
 async function isTaskAlreadyTerminal(taskStore, taskId) {
     try {
@@ -300,16 +288,14 @@ async function countActiveTasks(taskStore) {
     for (const task of tasks) {
         if (!isRecord(task) || typeof task.status !== 'string')
             continue;
-        if (task.status !== 'completed' &&
-            task.status !== 'failed' &&
-            task.status !== 'cancelled') {
+        if (!TERMINAL_TASK_STATUSES.has(task.status)) {
             active += 1;
         }
     }
     return active;
 }
 function resolveRequestedTaskTtl(requestedTtl) {
-    if (requestedTtl == null)
+    if (requestedTtl === undefined)
         return DEFAULT_TASK_TTL_MS;
     if (!Number.isFinite(requestedTtl)) {
         throw new McpError(ErrorCode.INVALID_INPUT, 'Task TTL must be finite.');
@@ -342,11 +328,11 @@ async function isTaskCancelled(taskStore, taskId) {
         return false;
     }
 }
-async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName, cancelPollMs) {
+async function runTaskInBackground(run, args, ctx, taskStore, taskId, toolName, cancelPollMs) {
     // Create a dedicated AbortController for background execution.
     // The original request signal is stale once createTask returns.
     const taskAbort = new AbortController();
-    const taskExtra = { ...extra, signal: taskAbort.signal };
+    const taskExtra = { ...ctx, signal: taskAbort.signal };
     // Poll the task store for client-initiated cancellation.
     const cancelPoller = setInterval(() => {
         void isTaskCancelled(taskStore, taskId).then((cancelled) => {
@@ -381,7 +367,7 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName
             toolName,
             durationMs,
         });
-        await notifyTaskStatusIfPossible(extra, taskStore, taskId, toolName);
+        await notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName);
     }
     catch (innerError) {
         Logger.error(format('Failed to store task result for task %s:', taskId), innerError);
@@ -393,7 +379,7 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName
             lastUpdatedAt: new Date().toISOString(),
             statusMessage: 'Internal system error while storing result',
         };
-        const { sendNotification } = extra;
+        const { sendNotification } = ctx;
         if (typeof sendNotification === 'function') {
             try {
                 await sendNotification({
@@ -416,17 +402,12 @@ async function runTaskInBackground(run, args, extra, taskStore, taskId, toolName
 function tryRegisterToolTask(server, toolName, toolDef, taskHandler, iconInfo) {
     if (!hasTaskToolCapability(server))
         return false;
-    const tasks = getExperimentalTaskRegistration(server);
-    if (!tasks?.registerToolTask)
-        return false;
     const def = toolDef;
     const existingExecution = def.execution ?? {};
-    const taskSupport = def.taskSupport ??
-        existingExecution.taskSupport ??
-        'forbidden';
-    if (taskSupport === 'forbidden')
+    const taskSupport = resolveToolTaskSupportLevel(def.taskSupport, existingExecution.taskSupport);
+    if (!taskSupport || taskSupport === 'forbidden')
         return false;
-    tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { ...existingExecution, taskSupport } }, iconInfo), taskHandler);
+    server.experimental.tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { ...existingExecution, taskSupport } }, iconInfo), taskHandler);
     return true;
 }
 export function registerToolTaskIfAvailable(server, toolName, toolDef, run, iconInfo, guard) {
@@ -436,19 +417,37 @@ export function registerToolTaskIfAvailable(server, toolName, toolDef, run, icon
     };
     return tryRegisterToolTask(server, toolName, toolDef, createToolTaskHandler(run, taskOptions), iconInfo);
 }
+export function registerStandardTool(server, toolDef, handler, options = {}, wrapOptions = {}) {
+    const wrappedHandler = wrapToolHandler(handler, {
+        guard: options.isInitialized,
+        ...wrapOptions,
+    });
+    const validatedHandler = withValidatedArgs(toolDef.inputSchema, wrappedHandler);
+    if (registerToolTaskIfAvailable(server, toolDef.name, toolDef, validatedHandler, options.iconInfo, options.isInitialized)) {
+        return;
+    }
+    server.registerTool(toolDef.name, withDefaultIcons({ ...toolDef }, options.iconInfo), validatedHandler);
+}
 export function createToolTaskHandler(run, options) {
-    const createTask = (async (argsOrExtra, maybeExtra) => {
-        const extra = asCreateTaskExtra(maybeExtra ?? argsOrExtra);
-        const args = (maybeExtra ? argsOrExtra : undefined);
+    const createTask = (async (...params) => {
+        let args;
+        let serverCtx;
+        if (params.length === 1) {
+            serverCtx = params[0];
+        }
+        else {
+            [args, serverCtx] = params;
+        }
+        const ctx = toTaskToolContext(asCreateTaskContext(serverCtx));
         if (options?.guard && !options.guard()) {
             throw new McpError(ErrorCode.INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
         }
-        const taskStore = getTaskStore(extra);
+        const taskStore = getTaskStore(ctx);
         if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
             throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
         }
         const task = await taskStore.createTask({
-            ttl: resolveRequestedTaskTtl(extra.taskRequestedTtl),
+            ttl: resolveRequestedTaskTtl(ctx.taskRequestedTtl),
             pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
         });
         const toolLabel = options?.toolName ?? 'tool';
@@ -465,26 +464,33 @@ export function createToolTaskHandler(run, options) {
             ...(options?.toolName ? { toolName: options.toolName } : {}),
         });
         const taskExtra = {
-            ...extra,
+            ...ctx,
             taskStore,
             taskId: task.taskId,
         };
         void notifyTaskCreatedIfPossible(taskExtra, task.taskId, options?.toolName);
         void notifyTaskStatusIfPossible(taskExtra, taskStore, task.taskId, options?.toolName);
         void runTaskInBackground(run, args, taskExtra, taskStore, task.taskId, options?.toolName, options?.cancelPollMs);
-        return { task };
+        return {
+            task,
+            _meta: {
+                'io.modelcontextprotocol/model-immediate-response': `${toolLabel} task created — poll tasks/get for progress.`,
+            },
+        };
     });
-    const getTask = (async (argsOrExtra, maybeExtra) => {
-        const extra = asTaskRequestExtra(maybeExtra ?? argsOrExtra);
-        const taskStore = getTaskStore(extra);
-        const taskId = getTaskId(extra);
+    const getTask = (async (...params) => {
+        const serverCtx = params.length === 1 ? params[0] : params[1];
+        const ctx = toTaskToolContext(asTaskRequestContext(serverCtx));
+        const taskStore = getTaskStore(ctx);
+        const taskId = getTaskId(ctx);
         const task = await taskStore.getTask(taskId);
         return projectCancelledTaskStatus(taskStore, normalizeGetTaskResult(task));
     });
-    const getTaskResult = (async (argsOrExtra, maybeExtra) => {
-        const extra = asTaskRequestExtra(maybeExtra ?? argsOrExtra);
-        const taskStore = getTaskStore(extra);
-        const taskId = getTaskId(extra);
+    const getTaskResult = (async (...params) => {
+        const serverCtx = params.length === 1 ? params[0] : params[1];
+        const ctx = toTaskToolContext(asTaskRequestContext(serverCtx));
+        const taskStore = getTaskStore(ctx);
+        const taskId = getTaskId(ctx);
         const result = await taskStore.getTaskResult(taskId);
         return attachRelatedTaskMeta(normalizeCallToolResult(result), taskId);
     });

package/dist/tools/tree.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 TREE_TOOL: ToolContract;
 export declare function registerTreeTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/tree.js

@@ -3,8 +3,9 @@ import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
 import { ErrorCode } from '../lib/errors.js';
 import { formatTreeAscii, treeDirectory, } from '../lib/file-operations/metadata.js';
 import { TreeInputSchema, TreeOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { DIRECTORY_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, createProgressReporter, executeToolWithDiagnostics, notifyProgress, READ_ONLY_TOOL_ANNOTATIONS, resolvePathOrRoot, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const TREE_TOOL = {
     name: 'tree',
     title: 'Tree',
@@ -13,6 +14,7 @@ export const TREE_TOOL = {
     inputSchema: TreeInputSchema,
     outputSchema: TreeOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    icons: DIRECTORY_ICONS,
     taskSupport: 'optional',
 };
 async function handleTree(args, signal, onProgress) {
@@ -39,11 +41,11 @@ async function handleTree(args, signal, onProgress) {
     return buildToolResponse(text, structured);
 }
 export function registerTreeTool(server, options = {}) {
-    const handler = (args, extra) => {
+    const handler = (args, ctx) => {
         const targetPath = args.path ?? '.';
         return executeToolWithDiagnostics({
             toolName: 'tree',
-            extra,
+            ctx,
             outputSchema: TreeOutputSchema,
             timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
             context: { path: targetPath },
@@ -51,12 +53,12 @@ export function registerTreeTool(server, options = {}) {
                 const context = args.path ? basename(args.path) : '.';
                 let progressCursor = 0;
                 const knownTotal = args.maxEntries;
-                notifyProgress(extra, {
+                notifyProgress(ctx, {
                     current: 0,
                     total: knownTotal,
                     message: `≣ tree: ${context}`,
                 });
-                const baseReporter = createProgressReporter(extra);
+                const baseReporter = createProgressReporter(ctx);
                 const onProgress = (progress) => {
                     const { current } = progress;
                     if (current > progressCursor)
@@ -76,7 +78,7 @@ export function registerTreeTool(server, options = {}) {
                     if (truncated)
                         suffix += ' [truncated]';
                     const finalCurrent = Math.max(count, progressCursor + 1);
-                    notifyProgress(extra, {
+                    notifyProgress(ctx, {
                         current: finalCurrent,
                         total: finalCurrent,
                         message: `≣ tree: ${context} • ${suffix}`,
@@ -85,7 +87,7 @@ export function registerTreeTool(server, options = {}) {
                 }
                 catch (error) {
                     const finalCurrent = Math.max(progressCursor + 1, 1);
-                    notifyProgress(extra, {
+                    notifyProgress(ctx, {
                         current: finalCurrent,
                         total: finalCurrent,
                         message: `≣ tree: ${context} • failed`,
@@ -96,11 +98,5 @@ export function registerTreeTool(server, options = {}) {
             onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_DIRECTORY, targetPath),
         });
     };
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
-    });
-    const validatedHandler = withValidatedArgs(TreeInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'tree', TREE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('tree', withDefaultIcons({ ...TREE_TOOL }, options.iconInfo), validatedHandler);
+    registerStandardTool(server, TREE_TOOL, handler, options);
 }

package/dist/tools/write-file.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 WRITE_FILE_TOOL: ToolContract;
 export declare function registerWriteFileTool(server: McpServer, options?: ToolRegistrationOptions): void;

package/dist/tools/write-file.js

@@ -7,8 +7,9 @@ import { Logger } from '../lib/logger.js';
 import { validatePathForWrite } from '../lib/paths.js';
 import { formatBytes } from '../config.js';
 import { WriteFileInputSchema, WriteFileOutputSchema } from '../schemas.js';
-import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-import { registerToolTaskIfAvailable } from './task-support.js';
+import { FILE_EDIT_ICONS } from './icons.js';
+import { buildToolErrorResponse, buildToolResponse, DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS, executeToolWithDiagnostics, } from './shared.js';
+import { registerStandardTool } from './task-support.js';
 export const WRITE_FILE_TOOL = {
     name: 'write',
     title: 'Write File',
@@ -16,6 +17,7 @@ export const WRITE_FILE_TOOL = {
     inputSchema: WriteFileInputSchema,
     outputSchema: WriteFileOutputSchema,
     annotations: DESTRUCTIVE_WRITE_TOOL_ANNOTATIONS,
+    icons: FILE_EDIT_ICONS,
     taskSupport: 'forbidden',
 };
 async function handleWriteFile(args, signal) {
@@ -32,17 +34,20 @@ async function handleWriteFile(args, signal) {
     });
 }
 export function registerWriteFileTool(server, options = {}) {
-    const handler = (args, extra) => executeToolWithDiagnostics({
+    const handler = (args, ctx) => executeToolWithDiagnostics({
         toolName: 'write',
-        extra,
+        ctx,
         outputSchema: WriteFileOutputSchema,
         timedSignal: {},
         context: { path: args.path },
-        run: (signal) => handleWriteFile(args, signal),
+        run: async (signal) => {
+            const result = await handleWriteFile(args, signal);
+            void ctx.log?.('info', `write: ${args.path} (${String(result.structuredContent.bytesWritten ?? 0)} bytes)`);
+            return result;
+        },
         onError: (error) => buildToolErrorResponse(error, ErrorCode.UNKNOWN, args.path),
     });
-    const wrappedHandler = wrapToolHandler(handler, {
-        guard: options.isInitialized,
+    registerStandardTool(server, WRITE_FILE_TOOL, handler, options, {
         progressMessage: (args) => `🛠 write: ${basename(args.path)}`,
         completionMessage: (args, result) => {
             const name = basename(args.path);
@@ -52,8 +57,4 @@ export function registerWriteFileTool(server, options = {}) {
             return `🛠 write: ${name} • ${formatBytes(sc.bytesWritten ?? 0)}`;
         },
     });
-    const validatedHandler = withValidatedArgs(WriteFileInputSchema, wrappedHandler);
-    if (registerToolTaskIfAvailable(server, 'write', WRITE_FILE_TOOL, validatedHandler, options.iconInfo, options.isInitialized))
-        return;
-    server.registerTool('write', withDefaultIcons({ ...WRITE_FILE_TOOL }, options.iconInfo), validatedHandler);
 }

package/dist/tools.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { type ToolContract } from './tools/contract.js';
 import type { ToolRegistrationOptions } from './tools/shared.js';
 export declare const ALL_TOOLS: ToolContract[];

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.16.2",
+  "version": "1.16.3",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
-  "description": "A local filesystem MCP server that lets LLMs and AI agents read, write, search, diff, patch, and manage files safely and efficiently. Built for reliable, structured, and controlled filesystem interaction.",
+  "description": "Secure filesystem MCP server for reading, writing, searching, diffing, and patching files.",
   "author": "j0hanz",
   "license": "MIT",
   "repository": {
@@ -68,14 +68,16 @@
     "security",
     "server",
     "stdio",
-    "sse",
     "typescript",
     "nodejs",
     "llm",
     "cli"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@cfworker/json-schema": "^4.1.1",
+    "@modelcontextprotocol/client": "^2.0.0-alpha.2",
+    "@modelcontextprotocol/node": "^2.0.0-alpha.2",
+    "@modelcontextprotocol/server": "^2.0.0-alpha.2",
     "commander": "^14.0.3",
     "diff": "^8.0.4",
     "ignore": "^7.0.5",