@j0hanz/filesystem-mcp 1.14.0 → 1.14.1

package/dist/schemas.js

@@ -20,6 +20,13 @@ const PathSchemaBase = z
     .max(MAX_PATH_LENGTH, `Path too long (max ${MAX_PATH_LENGTH} chars)`);
 const OptionalPathSchema = PathSchemaBase.optional();
 const RequiredPathSchema = PathSchemaBase.min(1, 'Path required');
+const SafeGlobPatternSchema = z
+    .string()
+    .min(1, 'Pattern required')
+    .max(1000, 'Max 1000 chars')
+    .refine((val) => isSafeGlobPattern(val), {
+    error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
+});
 const FileTypeSchema = z.enum(['file', 'directory', 'symlink', 'other']);
 const ListDirectorySortSchema = z.enum(['name', 'size', 'modified', 'type']);
 const SearchFilesSortSchema = z.enum(['name', 'size', 'modified', 'path']);
@@ -37,7 +44,7 @@ const TreeEntrySchema = z.lazy(() => z.strictObject({
     children: z.array(TreeEntrySchema).optional().describe('Children'),
 }));
 const ErrorSchema = z.strictObject({
-    code: z.enum(ErrorCode).describe('Error code (e.g. E_NOT_FOUND)'),
+    code: z.enum(ErrorCode).describe('Error code (e.g. NOT_FOUND)'),
     message: z.string().describe('Human-readable message'),
     path: z.string().optional().describe('Relevant path'),
     suggestion: z.string().optional().describe('Fix suggestion'),
@@ -126,15 +133,7 @@ export const ListDirectoryInputSchema = z.strictObject({
     sortBy: ListDirectorySortSchema.optional()
         .default('name')
         .describe('Sort field (name, size, modified, type)'),
-    pattern: z
-        .string()
-        .min(1, 'Pattern required')
-        .max(1000, 'Max 1000 chars')
-        .refine((val) => isSafeGlobPattern(val), {
-        error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
-    })
-        .optional()
-        .describe('Optional glob pattern filter (e.g. "**/*.ts")'),
+    pattern: SafeGlobPatternSchema.optional().describe('Optional glob pattern filter (e.g. "**/*.ts")'),
     includeSymlinkTargets: defaultFalseBoolean('Resolve and include symlink targets in results'),
     cursor: z
         .string()
@@ -146,14 +145,7 @@ export const ListAllowedDirectoriesInputSchema = z
     .describe('No input parameters.');
 export const SearchFilesInputSchema = z.strictObject({
     path: OptionalPathSchema.describe(DESC_PATH_ROOT),
-    pattern: z
-        .string()
-        .min(1, 'Pattern required')
-        .max(1000, 'Max 1000 chars')
-        .refine((val) => isSafeGlobPattern(val), {
-        error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
-    })
-        .describe('Glob pattern (e.g. "**/*.ts", "src/*.js")'),
+    pattern: SafeGlobPatternSchema.describe('Glob pattern (e.g. "**/*.ts", "src/*.js")'),
     maxResults: z
         .int({ error: 'Must be integer' })
         .min(1, 'Min: 1')
@@ -221,11 +213,7 @@ export const SearchContentInputSchema = z.strictObject({
         .optional()
         .default(DEFAULT_SEARCH_CONTENT_RESULTS)
         .describe(`Maximum match rows to return. Default: ${DEFAULT_SEARCH_CONTENT_RESULTS}`),
-    filePattern: z
-        .string()
-        .min(1, 'Pattern required')
-        .max(1000, 'Max 1000 chars')
-        .optional()
+    filePattern: SafeGlobPatternSchema.optional()
         .default('**/*')
         .describe('Glob for candidate files (e.g. "**/*.ts")'),
     includeHidden: defaultFalseBoolean('Include hidden items (starting with .)'),
@@ -449,6 +437,8 @@ export const EditFileInputSchema = z.strictObject({
         .array(z.strictObject({
         oldText: z
             .string()
+            .min(1, 'oldText required')
+            .max(102400, 'Max 100KB')
             .describe('Exact literal string to replace (character-for-character). Include 3–5 lines of context for unique targeting.'),
         newText: z
             .string()
@@ -621,15 +611,8 @@ export const ApplyPatchOutputSchema = z.strictObject({
 });
 export const SearchAndReplaceInputSchema = z.strictObject({
     path: OptionalPathSchema.describe(DESC_PATH_ROOT),
-    filePattern: z
-        .string()
-        .min(1, 'Pattern required')
-        .max(1000, 'Max 1000 chars')
-        .optional()
+    filePattern: SafeGlobPatternSchema.optional()
         .default('**/*')
-        .refine((val) => isSafeGlobPattern(val), {
-        error: 'Invalid glob or unsafe path (absolute/.. forbidden)',
-    })
         .describe('Glob to filter files. Default: **/*'),
     searchPattern: z
         .string()
@@ -644,18 +627,9 @@ export const SearchAndReplaceInputSchema = z.strictObject({
         .default(true)
         .describe('Case-sensitive matching. Default: true.'),
     dryRun: defaultFalseBoolean('Preview matches without writing. Check changedFiles and matches in the response before committing.'),
-    includeHidden: z
-        .boolean()
-        .optional()
-        .describe('Include hidden files/directories (starting with .). Default: false.'),
-    includeIgnored: z
-        .boolean()
-        .optional()
-        .describe('Include .gitignore-ignored files (node_modules, dist). Default: false.'),
-    returnDiff: z
-        .boolean()
-        .optional()
-        .describe('Return unified diff of changes even if dryRun is false. Default: false.'),
+    includeHidden: defaultFalseBoolean('Include hidden files/directories (starting with .). Default: false.'),
+    includeIgnored: defaultFalseBoolean('Include .gitignore-ignored files (node_modules, dist). Default: false.'),
+    returnDiff: defaultFalseBoolean('Return unified diff of changes even if dryRun is false. Default: false.'),
     maxFiles: z
         .int({ error: 'Must be integer' })
         .min(1, 'Min: 1')
@@ -687,7 +661,10 @@ export const SearchAndReplaceOutputSchema = z.strictObject({
         .boolean()
         .optional()
         .describe('Changed file list truncated'),
-    diff: z.string().optional().describe('Unified diff of changes (dryRun only)'),
+    diff: z
+        .string()
+        .optional()
+        .describe('Unified diff of changes when `dryRun` or `returnDiff` is enabled'),
     diffTruncated: z
         .boolean()
         .optional()

package/dist/server/bootstrap.d.ts

@@ -1,14 +1,15 @@
-import * as http from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
-export interface ServerOptions {
-    allowCwd?: boolean;
-    cliAllowedDirs?: string[];
-}
-export interface LoggingState {
-    minimumLevel: LoggingLevel;
-}
-export declare function logToMcp(server: McpServer | undefined, level: LoggingLevel, data: string, minLevel?: LoggingLevel): void;
+import { type Server } from 'node:http';
+import { type LoggingState } from '../lib/logger.js';
+import { type ServerOptions } from './roots-manager.js';
+export declare const activeServers: Map<string, {
+    server: McpServer;
+    loggingState: LoggingState;
+}>;
+export declare let stdioServer: {
+    server: McpServer;
+    loggingState: LoggingState;
+} | undefined;
 export declare function createServer(options?: ServerOptions): Promise<McpServer>;
 export declare function startServer(server: McpServer): Promise<void>;
-export declare function startHttpServer(port: number, options: ServerOptions): Promise<http.Server>;
+export declare function startHttpServer(port: number, options: ServerOptions): Promise<Server>;

package/dist/server/bootstrap.js

@@ -1,16 +1,17 @@
-import * as fs from 'node:fs/promises';
-import * as http from 'node:http';
-import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
-import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import { InMemoryTaskMessageQueue } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest, LATEST_PROTOCOL_VERSION, SetLevelRequestSchema, SUPPORTED_PROTOCOL_VERSIONS, } from '@modelcontextprotocol/sdk/types.js';
+import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
+import { channel } from 'node:diagnostics_channel';
+import { readFile } from 'node:fs/promises';
+import { createServer as createHttpServer, } from 'node:http';
 import { DEFAULT_LOG_LEVEL, parseEnvInt } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
+import { createLoggingState, Logger, logToMcp, SessionContext, } from '../lib/logger.js';
 import { withAllowedDirectoriesState } from '../lib/paths.js';
 import { createInMemoryResourceStore } from '../lib/resource-store.js';
-import { isRecord } from '../lib/utils.js';
 import { registerCompletions } from '../completions.js';
 import { pkgInfo } from '../pkg-info.js';
 import { registerAnalyzePathPrompt, registerCompareFilesPrompt, registerGetHelpPrompt, registerGetToolHelpPrompt, } from '../prompts.js';
@@ -19,6 +20,7 @@ import { buildServerInstructions } from '../resources/generated-instructions.js'
 import { registerAllTools } from '../tools.js';
 import { withDefaultIcons } from '../tools/shared.js';
 import { RootsManager } from './roots-manager.js';
+import { createTaskStore } from './task-store.js';
 let cachedTaskToolSupport;
 function detectTaskToolSupport() {
     if (cachedTaskToolSupport !== undefined) {
@@ -48,6 +50,7 @@ function buildServerCapabilities(options = {}) {
         tools: {},
         prompts: options.enablePromptListChanged ? { listChanged: true } : {},
         completions: {},
+        extensions: {},
     };
     if (options.enableTaskToolRequests) {
         // NOTE: enabling task tool requests requires the caller to configure
@@ -64,45 +67,30 @@ function buildServerCapabilities(options = {}) {
 function supportsTaskToolRequests() {
     return detectTaskToolSupport();
 }
-const MCP_LOGGER_NAME = 'filesystem-mcp';
-const LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    notice: 2,
-    warning: 3,
-    error: 4,
-    critical: 5,
-    alert: 6,
-    emergency: 7,
-};
-function createLoggingState(minimumLevel = 'debug') {
-    return { minimumLevel };
-}
-function canSendMcpLogs(server) {
-    const capabilities = server.server.getClientCapabilities();
-    if (!isRecord(capabilities))
-        return false;
-    if (!('logging' in capabilities))
-        return false;
-    return !!capabilities['logging'];
+// Global map of all active servers by sessionId for routing logs
+export const activeServers = new Map();
+// For stdio (single session without a specific ID)
+export let stdioServer;
+function stringifyData(data) {
+    if (!data)
+        return '';
+    return ` ${typeof data === 'string' ? data : JSON.stringify(data)}`;
 }
-export function logToMcp(server, level, data, minLevel = 'debug') {
-    if (LOG_LEVEL_ORDER[level] < LOG_LEVEL_ORDER[minLevel]) {
-        return;
+channel('filesystem-mcp:log').subscribe((message) => {
+    const event = message;
+    const target = event.sessionId
+        ? activeServers.get(event.sessionId)
+        : stdioServer;
+    const dataStr = stringifyData(event.data);
+    if (target) {
+        logToMcp(target.server, event.level, `${event.message}${dataStr}`, target.loggingState.minimumLevel);
     }
-    if (!server || !canSendMcpLogs(server)) {
-        console.error(data);
-        return;
+    else {
+        // Fallback if no server
+        const fullMsg = `${event.message}${dataStr}`;
+        console.error(`[${event.level.toUpperCase()}] ${fullMsg}`);
     }
-    const params = {
-        level,
-        logger: MCP_LOGGER_NAME,
-        data,
-    };
-    void server.sendLoggingMessage(params).catch((error) => {
-        console.error(`Failed to send MCP log: ${level} | ${data}`, formatUnknownErrorMessage(error));
-    });
-}
+});
 const { version: SERVER_VERSION, description: SERVER_DESCRIPTION, homepage: SERVER_HOMEPAGE, } = pkgInfo;
 const rootsManagers = new WeakMap();
 function getRootsManager(server) {
@@ -119,7 +107,7 @@ async function getLocalIconInfo() {
     for (const candidate of candidates) {
         try {
             const iconPath = new URL(candidate, import.meta.url);
-            const buffer = await fs.readFile(iconPath);
+            const buffer = await readFile(iconPath);
             return {
                 src: `data:${mime};base64,${buffer.toString('base64')}`,
                 mimeType: mime,
@@ -144,7 +132,7 @@ export async function createServer(options = {}) {
     };
     if (taskToolSupport) {
         // Enabling task tool support requires configuring a task store and message queue on the server config. We use in-memory implementations from the SDK which auto-evict tasks after their TTL expires (via setTimeout). Suitable for both stdio and HTTP sessions.
-        serverConfig.taskStore = new InMemoryTaskStore();
+        serverConfig.taskStore = createTaskStore();
         serverConfig.taskMessageQueue = new InMemoryTaskMessageQueue();
     }
     if (serverInstructions) {
@@ -163,10 +151,15 @@ export async function createServer(options = {}) {
     const loggingState = createLoggingState(DEFAULT_LOG_LEVEL);
     const rootsManager = new RootsManager(options, loggingState);
     rootsManagers.set(server, rootsManager);
+    // Subscribe to Logger channel if not already done, but we need to route based on session or fallback to this server if it's stdio.
+    // Wait, in stdio there's only one server. In HTTP there are multiple.
     server.server.setRequestHandler(SetLevelRequestSchema, (req) => {
         loggingState.minimumLevel = req.params.level;
+        Logger.notice(`Log level set to ${req.params.level}`);
         return {};
     });
+    // Track stdio server by default, or it will be overwritten per HTTP session later
+    stdioServer ??= { server, loggingState };
     registerInstructionResource(server, serverInstructions, localIcon);
     registerToolCatalogResource(server, localIcon);
     registerWorkflowGuideResource(server, localIcon);
@@ -257,6 +250,10 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
                 transport,
                 negotiatedProtocolVersion,
             });
+            activeServers.set(sessionId, {
+                server: mcpServer,
+                loggingState: rootsManager['loggingState'],
+            });
             rootsManager.logMissingDirectoriesIfNeeded(mcpServer);
         },
     });
@@ -264,10 +261,11 @@ async function createHttpSession(options, sessions, negotiatedProtocolVersion) {
         const { sessionId } = transport;
         if (sessionId) {
             sessions.delete(sessionId);
+            activeServers.delete(sessionId);
         }
         rootsManager.destroy();
         mcpServer.close().catch((err) => {
-            console.error('[HTTP] Error closing MCP server:', formatUnknownErrorMessage(err));
+            Logger.error('[HTTP] Error closing MCP server:', formatUnknownErrorMessage(err));
         });
     };
     await mcpServer.connect(transport);
@@ -368,7 +366,12 @@ function discardRequestBody(req) {
     req.resume();
 }
 async function handleSessionTransportRequest(session, req, res, body) {
-    await withAllowedDirectoriesState(session.rootsManager.getAllowedDirectoriesState(), () => session.transport.handleRequest(req, res, body));
+    const store = session.transport.sessionId
+        ? { sessionId: session.transport.sessionId }
+        : {};
+    await SessionContext.run(store, async () => {
+        await withAllowedDirectoriesState(session.rootsManager.getAllowedDirectoriesState(), () => session.transport.handleRequest(req, res, body));
+    });
 }
 function getSessionOrRespondNotFound(sessions, sessionId, res) {
     const session = sessions.get(sessionId);
@@ -396,6 +399,47 @@ export async function startHttpServer(port, options) {
     const sessions = new Map();
     const httpHost = process.env['FILESYSTEM_MCP_HTTP_HOST'] ?? '127.0.0.1';
     assertHttpBindingSecurity(httpHost);
+    async function handlePostRequest(req, res, sessionId) {
+        if (sessionId) {
+            const session = getSessionOrRespondNotFound(sessions, sessionId, res);
+            if (!session) {
+                discardRequestBody(req);
+                return;
+            }
+            if (!ensureSessionProtocolVersion(req, res, session)) {
+                discardRequestBody(req);
+                return;
+            }
+            const body = await readRequestBody(req);
+            await handleSessionTransportRequest(session, req, res, body);
+            return;
+        }
+        const body = await readRequestBody(req);
+        if (isInitializeRequest(body)) {
+            const maxSessions = parseEnvInt('FILESYSTEM_MCP_MAX_HTTP_SESSIONS', 100, 1, 10_000);
+            if (sessions.size >= maxSessions) {
+                sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
+                return;
+            }
+            const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
+            await handleSessionTransportRequest(session, req, res, body);
+            return;
+        }
+        sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: No valid session ID provided');
+        discardRequestBody(req);
+    }
+    async function handleGetDeleteRequest(req, res, sessionId) {
+        if (!sessionId) {
+            sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: Missing session ID');
+            return;
+        }
+        const session = getSessionOrRespondNotFound(sessions, sessionId, res);
+        if (!session)
+            return;
+        if (!ensureSessionProtocolVersion(req, res, session))
+            return;
+        await handleSessionTransportRequest(session, req, res);
+    }
     async function handleMcpRequest(req, res) {
         const { method } = req;
         const sessionId = getSessionId(req);
@@ -408,45 +452,10 @@ export async function startHttpServer(port, options) {
             return;
         try {
             if (method === 'POST') {
-                if (sessionId) {
-                    const session = getSessionOrRespondNotFound(sessions, sessionId, res);
-                    if (!session) {
-                        discardRequestBody(req);
-                        return;
-                    }
-                    if (!ensureSessionProtocolVersion(req, res, session)) {
-                        discardRequestBody(req);
-                        return;
-                    }
-                    const body = await readRequestBody(req);
-                    await handleSessionTransportRequest(session, req, res, body);
-                    return;
-                }
-                const body = await readRequestBody(req);
-                if (isInitializeRequest(body)) {
-                    const maxSessions = parseEnvInt('FILESYSTEM_MCP_MAX_HTTP_SESSIONS', 100, 1, 10_000);
-                    if (sessions.size >= maxSessions) {
-                        sendJsonRpcError(res, 503, JSON_RPC_SERVER_ERROR, 'Too many sessions');
-                        return;
-                    }
-                    const session = await createHttpSession(options, sessions, resolveNegotiatedProtocolVersion(body.params.protocolVersion));
-                    await handleSessionTransportRequest(session, req, res, body);
-                    return;
-                }
-                sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: No valid session ID provided');
-                discardRequestBody(req);
+                await handlePostRequest(req, res, sessionId);
             }
             else if (method === 'GET' || method === 'DELETE') {
-                if (!sessionId) {
-                    sendJsonRpcError(res, 400, JSON_RPC_SERVER_ERROR, 'Bad Request: Missing session ID');
-                    return;
-                }
-                const session = getSessionOrRespondNotFound(sessions, sessionId, res);
-                if (!session)
-                    return;
-                if (!ensureSessionProtocolVersion(req, res, session))
-                    return;
-                await handleSessionTransportRequest(session, req, res);
+                await handleGetDeleteRequest(req, res, sessionId);
             }
             else {
                 res.writeHead(405, {
@@ -472,17 +481,17 @@ export async function startHttpServer(port, options) {
                 sendJsonRpcError(res, error.statusCode, rpcCode, error.message);
                 return;
             }
-            console.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
+            Logger.error('[HTTP] Error handling request:', formatUnknownErrorMessage(error));
             if (!res.headersSent) {
                 sendJsonRpcError(res, 500, JSON_RPC_INTERNAL_ERROR, 'Internal Server Error');
             }
         }
     }
-    const httpServer = http.createServer((req, res) => {
+    const httpServer = createHttpServer((req, res) => {
         const urlPath = (req.url ?? '/').split('?')[0];
         if (urlPath === '/mcp') {
             handleMcpRequest(req, res).catch((err) => {
-                console.error('[HTTP] Unhandled error in request handler:', formatUnknownErrorMessage(err));
+                Logger.error('[HTTP] Unhandled error in request handler:', formatUnknownErrorMessage(err));
             });
         }
         else {
@@ -493,7 +502,7 @@ export async function startHttpServer(port, options) {
     return new Promise((resolve, reject) => {
         httpServer.once('error', reject);
         httpServer.listen(port, httpHost, () => {
-            console.error(`MCP HTTP server listening on ${httpHost}:${port}`);
+            Logger.info(`MCP HTTP server listening on ${httpHost}:${port}`);
             resolve(httpServer);
         });
     });

package/dist/server/roots-manager.d.ts

@@ -1,7 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type LoggingState } from '../lib/logger.js';
 import { type AllowedDirectoriesState } from '../lib/paths.js';
-import { type LoggingState } from './bootstrap.js';
-import type { ServerOptions } from './bootstrap.js';
+export interface ServerOptions {
+    allowCwd?: boolean;
+    cliAllowedDirs?: string[];
+}
 export declare class RootsManager {
     private _debouncedUpdate;
     private rootDirectories;

package/dist/server/roots-manager.js

@@ -1,11 +1,11 @@
-import * as fs from 'node:fs/promises';
 import { InitializedNotificationSchema, RootsListChangedNotificationSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { realpath } from 'node:fs/promises';
 import { z } from 'zod';
+import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/abort.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
-import { assertNotAborted, createTimedAbortSignal, withAbort, } from '../lib/fs-helpers.js';
+import { Logger, logToMcp } from '../lib/logger.js';
 import { getValidRootDirectories, isPathWithinDirectories, normalizePath, resolveAllowedDirectoriesState, setAllowedDirectoriesStateResolved, } from '../lib/paths.js';
 import { debounce, isRecord } from '../lib/utils.js';
-import { logToMcp } from './bootstrap.js';
 const ROOTS_TIMEOUT_MS = 5000;
 const ROOTS_DEBOUNCE_MS = 100;
 function normalizeCLIDirectories(dirs) {
@@ -61,7 +61,7 @@ async function isRootWithinBaseline(normalizedRoot, baseline, signal) {
     }
     try {
         assertNotAborted(signal);
-        const realPath = await withAbort(fs.realpath(normalizedRoot), signal);
+        const realPath = await withAbort(realpath(normalizedRoot), signal);
         const normalizedReal = normalizePath(realPath);
         return isPathWithinDirectories(normalizedReal, baseline);
     }
@@ -88,9 +88,10 @@ export class RootsManager {
         expanded: [],
     };
     clientInitialized = false;
-    // Set to true when an update is in progress, to prevent concurrent executions. If a change arrives while true, we queue a single retry after completion to ensure the last-known state is applied. This
+    // Guard concurrent root refreshes; if one is already running we queue one
+    // replay so the last-known state still gets applied after completion.
     updatingRoots = false;
-    // If an update is in progress and a change arrives, we set this flag to ensure we run another update after completion to apply the latest state
+    // Tracks whether a roots change arrived while the previous refresh ran.
     pendingRootsUpdate = false;
     options;
     loggingState;
@@ -187,6 +188,7 @@ export class RootsManager {
         }
         finally {
             await this.recomputeAllowedDirectories();
+            Logger.info(`Roots updated: ${this.rootDirectories.length} root(s), ${this.allowedDirectoriesState.expanded.length} allowed dir(s)`);
             this.updatingRoots = false;
             // If a change arrived while we were running, apply it now.
             if (this.pendingRootsUpdate) {

package/dist/server/task-store.d.ts

@@ -0,0 +1,10 @@
+import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import type { Result } from '@modelcontextprotocol/sdk/types.js';
+export declare class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
+    private readonly cancelledResults;
+    getTaskResult(taskId: string, sessionId?: string): Promise<Result>;
+    storeTaskResult(taskId: string, status: 'completed' | 'failed', result: Result, sessionId?: string): Promise<void>;
+    updateTaskStatus(taskId: string, status: 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled', statusMessage?: string, sessionId?: string): Promise<void>;
+    cleanup(): void;
+}
+export declare function createTaskStore(): ResultAwareInMemoryTaskStore;

package/dist/server/task-store.js

@@ -0,0 +1,73 @@
+import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js';
+import { ErrorCode } from '../lib/errors.js';
+const DEFAULT_CANCELLED_STATUS_MESSAGE = 'Client cancelled task execution.';
+function getTaskKey(taskId, sessionId) {
+    return `${sessionId ?? ''}:${taskId}`;
+}
+function buildCancelledTaskResult(statusMessage) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Error [${ErrorCode.CANCELLED}]: ${statusMessage ?? DEFAULT_CANCELLED_STATUS_MESSAGE}`,
+            },
+        ],
+        isError: true,
+        errorCode: ErrorCode.CANCELLED,
+    };
+}
+export class ResultAwareInMemoryTaskStore extends InMemoryTaskStore {
+    cancelledResults = new Map();
+    async getTaskResult(taskId, sessionId) {
+        try {
+            return await super.getTaskResult(taskId, sessionId);
+        }
+        catch (error) {
+            const task = await super.getTask(taskId, sessionId);
+            if (task?.status !== 'cancelled') {
+                throw error;
+            }
+            const key = getTaskKey(taskId, sessionId);
+            const existing = this.cancelledResults.get(key);
+            if (existing)
+                return existing;
+            const result = buildCancelledTaskResult(task.statusMessage);
+            this.cancelledResults.set(key, result);
+            return result;
+        }
+    }
+    async storeTaskResult(taskId, status, result, sessionId) {
+        try {
+            await super.storeTaskResult(taskId, status, result, sessionId);
+            if (status !== 'failed') {
+                this.cancelledResults.delete(getTaskKey(taskId, sessionId));
+            }
+        }
+        catch (error) {
+            const task = await super.getTask(taskId, sessionId);
+            if (task?.status !== 'cancelled') {
+                throw error;
+            }
+            this.cancelledResults.set(getTaskKey(taskId, sessionId), this.cancelledResults.get(getTaskKey(taskId, sessionId)) ?? result);
+        }
+    }
+    async updateTaskStatus(taskId, status, statusMessage, sessionId) {
+        await super.updateTaskStatus(taskId, status, statusMessage, sessionId);
+        const key = getTaskKey(taskId, sessionId);
+        if (status === 'cancelled') {
+            this.cancelledResults.set(key, this.cancelledResults.get(key) ??
+                buildCancelledTaskResult(statusMessage));
+            return;
+        }
+        if (status === 'completed' || status === 'failed') {
+            this.cancelledResults.delete(key);
+        }
+    }
+    cleanup() {
+        this.cancelledResults.clear();
+        super.cleanup();
+    }
+}
+export function createTaskStore() {
+    return new ResultAwareInMemoryTaskStore();
+}