@j0hanz/filesystem-mcp 1.6.0 → 1.6.1

package/README.md

@@ -565,6 +565,7 @@ Set `FS_CONTEXT_STRIP_STRUCTURED=1` to strip `structuredContent` from tool resul
 - **Input limits**: Paths are bounded to 4,096 characters; patterns to 1,000 characters.
 - **Atomic writes**: File writes use an atomic write-then-rename strategy to prevent partial writes.
 - **Docker**: The container runs as a non-root user (`mcp`).
+- **HTTP host binding**: The HTTP transport binds to `127.0.0.1` by default. Setting `FILESYSTEM_MCP_HTTP_HOST=0.0.0.0` binds to all network interfaces and exposes the server externally — only do this behind a trusted reverse proxy with `FILESYSTEM_MCP_AUTH_TOKEN` configured.
 
 > [!IMPORTANT]
 > All diagnostic output goes to `stderr`. Tool handlers must never write to `stdout`, as doing so would corrupt the stdio transport.
@@ -623,6 +624,21 @@ The [Glama](https://glama.ai/mcp/servers/j0hanz/filesystem-mcp) listing requires
 docker build -t filesystem-mcp .
 ```
 
+## HTTP Conformance Notes
+
+For Streamable HTTP clients, this server enforces the following behavior:
+
+- Session-bound requests must include `MCP-Protocol-Version: 2025-11-25`; missing or unsupported values return `400`.
+- Requests with invalid or expired `mcp-session-id` return `404`.
+- Initialize requests continue to be accepted without a session ID.
+
+## Backlog Hardening (Planned)
+
+The following hardening items are intentionally tracked as follow-up work:
+
+- Add a TTL-evicting task store for long-lived HTTP deployments to bound memory usage.
+- Add an optional per-session roots isolation mode for multi-tenant HTTP deployments.
+
 ## Troubleshooting
 
 **No directories configured**

package/dist/completions.js

@@ -6,8 +6,18 @@ import { getAllowedDirectories, isPathWithinDirectories, normalizePath, } from '
 import { isRecord } from './lib/type-guards.js';
 const MAX_COMPLETION_ITEMS = 100;
 const COMPLETION_RATE_LIMIT_MS = 100;
-const completionLastCallMs = new Map();
-const completionLastResult = new Map();
+// WeakMap keyed by McpServer instance so that each HTTP session gets isolated
+// rate-limit state. In stdio mode there is a single server; in HTTP mode every
+// session creates its own McpServer, so cross-session cache pollution is avoided.
+const completionState = new WeakMap();
+function getCompletionState(server) {
+    let state = completionState.get(server);
+    if (state === undefined) {
+        state = { lastCallMs: new Map(), lastResult: new Map() };
+        completionState.set(server, state);
+    }
+    return state;
+}
 function extractTopicCompletions(instructions) {
     const headers = [];
     for (const line of instructions.split('\n')) {
@@ -393,9 +403,10 @@ export function registerCompletions(server, instructions = '') {
             return { completion: { values: [], total: 0, hasMore: false } };
         }
         const now = Date.now();
-        const lastCallMs = completionLastCallMs.get(argName) ?? 0;
+        const sessionState = getCompletionState(server);
+        const lastCallMs = sessionState.lastCallMs.get(argName) ?? 0;
         if (now - lastCallMs < COMPLETION_RATE_LIMIT_MS) {
-            const lastResult = completionLastResult.get(argName);
+            const lastResult = sessionState.lastResult.get(argName);
             if (lastResult) {
                 return {
                     completion: {
@@ -407,14 +418,14 @@ export function registerCompletions(server, instructions = '') {
             }
             return { completion: { values: [], total: 0, hasMore: false } };
         }
-        completionLastCallMs.set(argName, now);
+        sessionState.lastCallMs.set(argName, now);
         const contextArguments = extractContextArguments(params.context);
         const { value } = argument;
         const completions = await getPathCompletions(value, {
             argumentName: argName,
             ...(contextArguments ? { contextArguments } : {}),
         });
-        completionLastResult.set(argName, completions);
+        sessionState.lastResult.set(argName, completions);
         return {
             completion: {
                 values: completions.values,

package/dist/lib/constants.d.ts

@@ -1,5 +1,6 @@
 export declare function parseTrueEnvFlag(value: string | undefined): boolean;
 export declare const DEFAULT_LOG_LEVEL: "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+export declare const REQUIRED_MCP_PROTOCOL_VERSION = "2025-11-25";
 export declare const PARALLEL_CONCURRENCY: number;
 export declare const MAX_SEARCHABLE_FILE_SIZE: number;
 export declare const MAX_TEXT_FILE_SIZE: number;

package/dist/lib/constants.js

@@ -69,7 +69,8 @@ function parseEnvLogLevel(envVar, defaultValue) {
     console.error(`[WARNING] Invalid ${envVar} value: ${value} (must be ${VALID_LOG_LEVELS.join('|')}). Using default: ${defaultValue}`);
     return defaultValue;
 }
-export const DEFAULT_LOG_LEVEL = parseEnvLogLevel('FILESYSTEM_MCP_LOG_LEVEL', 'debug');
+export const DEFAULT_LOG_LEVEL = parseEnvLogLevel('FILESYSTEM_MCP_LOG_LEVEL', 'info');
+export const REQUIRED_MCP_PROTOCOL_VERSION = '2025-11-25';
 // Auto-tuned parallelism based on CPU cores (no env override)
 const BYTES_PER_PARALLEL_TASK = 64 * MIB;
 const BYTES_PER_SEARCH_WORKER = 128 * MIB;

package/dist/lib/path-validation.js

@@ -108,7 +108,13 @@ function normalizeAllowedDirectories(dirs) {
     // Preserve first-seen order while deduping.
     return dedupePreserveOrder(normalized);
 }
-// Cached module state (configured roots).
+// Process-global singleton state for allowed directory roots.
+//
+// These are set once at startup (via setAllowedDirectoriesResolved) and
+// mutated only through setAllowedDirectoriesState. In stdio mode there is a
+// single MCP session per process, so this is safe. In HTTP mode all HTTP
+// sessions within the same process share one policy — multi-tenant isolation
+// (different roots per session) requires separate server processes.
 let allowedDirectoriesExpanded = [];
 let allowedDirectoriesPrimary = [];
 function setAllowedDirectoriesState(primary, expanded) {

package/dist/resources/tool-info.d.ts

@@ -2,3 +2,4 @@ import type { ToolContract } from '../tools/contract.js';
 export declare function getToolContracts(): ToolContract[];
 export declare function buildCoreContextPack(): string;
 export declare function getSharedConstraints(): string[];
+export declare function buildToolInfo(name: string): string | undefined;

package/dist/resources/tool-info.js

@@ -43,3 +43,25 @@ export function getSharedConstraints() {
         'If a response includes `resourceUri`, call `resources/read` immediately — results expire on process restart.',
     ];
 }
+export function buildToolInfo(name) {
+    const entry = ENTRIES[name];
+    if (!entry)
+        return undefined;
+    const lines = [`## ${entry.name}`, '', entry.description];
+    if (entry.annotations && entry.annotations.length > 0) {
+        lines.push('', `**Annotations:** ${entry.annotations.join(', ')}`);
+    }
+    if (entry.nuances && entry.nuances.length > 0) {
+        lines.push('', '**Nuances:**');
+        for (const nuance of entry.nuances) {
+            lines.push(`- ${nuance}`);
+        }
+    }
+    if (entry.gotchas && entry.gotchas.length > 0) {
+        lines.push('', '**Gotchas:**');
+        for (const gotcha of entry.gotchas) {
+            lines.push(`- ${gotcha}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/resources.d.ts

@@ -5,4 +5,5 @@ export declare function registerInstructionResource(server: McpServer, instructi
 export declare function registerToolCatalogResource(server: McpServer, iconInfo?: IconInfo): void;
 export declare function registerWorkflowGuideResource(server: McpServer, iconInfo?: IconInfo): void;
 export declare function registerResultResources(server: McpServer, store: ResourceStore, iconInfo?: IconInfo): void;
+export declare function registerToolInfoResource(server: McpServer, iconInfo?: IconInfo): void;
 export declare function registerMetricsResource(server: McpServer, iconInfo?: IconInfo): void;

package/dist/resources.js

@@ -2,11 +2,23 @@ import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ErrorCode, McpError } from './lib/errors.js';
 import { globalMetrics } from './lib/observability.js';
 import { buildToolCatalog } from './resources/tool-catalog.js';
+import { buildToolInfo, getToolContracts } from './resources/tool-info.js';
 import { buildWorkflowGuide } from './resources/workflows.js';
 import { withDefaultIcons } from './tools/shared.js';
 const RESULT_TEMPLATE = new ResourceTemplate('filesystem-mcp://result/{id}', {
     list: undefined,
 });
+const TOOL_INFO_TEMPLATE = new ResourceTemplate('internal://tool-info/{name}', {
+    list: () => ({
+        resources: getToolContracts().map((contract) => ({
+            uri: `internal://tool-info/${contract.name}`,
+            name: contract.name,
+            mimeType: 'text/markdown',
+        })),
+    }),
+});
+const TOOL_INFO_RESOURCE_NAME = 'filesystem-mcp-tool-info';
+const TOOL_INFO_RESOURCE_DESCRIPTION = 'Per-tool contract details, nuances, and gotchas. Read internal://tool-info/{name} with a tool name such as "read", "ls", or "grep".';
 const INSTRUCTIONS_RESOURCE_NAME = 'filesystem-mcp-instructions';
 const INSTRUCTIONS_RESOURCE_URI = 'internal://instructions';
 const INSTRUCTIONS_RESOURCE_DESCRIPTION = 'Guidance for using the filesystem-mcp MCP tools effectively.';
@@ -104,6 +116,35 @@ export function registerResultResources(server, store, iconInfo) {
         };
     });
 }
+export function registerToolInfoResource(server, iconInfo) {
+    server.registerResource(TOOL_INFO_RESOURCE_NAME, TOOL_INFO_TEMPLATE, withDefaultIcons({
+        title: 'Tool Info',
+        description: TOOL_INFO_RESOURCE_DESCRIPTION,
+        mimeType: 'text/markdown',
+        annotations: {
+            audience: ['assistant'],
+            priority: 0.65,
+        },
+    }, iconInfo), (uri, variables) => {
+        const { name } = variables;
+        if (typeof name !== 'string' || name.length === 0) {
+            throw new McpError(ErrorCode.E_INVALID_INPUT, 'Tool name is required');
+        }
+        const content = buildToolInfo(name);
+        if (content === undefined) {
+            throw new McpError(ErrorCode.E_INVALID_INPUT, `Tool not found: ${name}`);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'text/markdown',
+                    text: content,
+                },
+            ],
+        };
+    });
+}
 export function registerMetricsResource(server, iconInfo) {
     server.registerResource(METRICS_RESOURCE_NAME, METRICS_RESOURCE_URI, withDefaultIcons({
         title: 'Tool Metrics',

package/dist/server/bootstrap.js

@@ -7,12 +7,12 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest, SetLevelRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { registerCompletions } from '../completions.js';
-import { DEFAULT_LOG_LEVEL } from '../lib/constants.js';
+import { DEFAULT_LOG_LEVEL, REQUIRED_MCP_PROTOCOL_VERSION, } from '../lib/constants.js';
 import { formatUnknownErrorMessage } from '../lib/errors.js';
 import { createInMemoryResourceStore } from '../lib/resource-store.js';
 import { pkgInfo } from '../pkg-info.js';
 import { registerGetHelpPrompt } from '../prompts.js';
-import { registerInstructionResource, registerMetricsResource, registerResultResources, registerToolCatalogResource, registerWorkflowGuideResource, } from '../resources.js';
+import { registerInstructionResource, registerMetricsResource, registerResultResources, registerToolCatalogResource, registerToolInfoResource, registerWorkflowGuideResource, } from '../resources.js';
 import { buildServerInstructions } from '../resources/generated-instructions.js';
 import { registerAllTools } from '../tools.js';
 import { withDefaultIcons } from '../tools/shared.js';
@@ -59,6 +59,9 @@ export async function createServer(options = {}) {
         }),
     };
     if (taskToolSupport) {
+        // Note: InMemoryTaskStore has no TTL — tasks accumulate for the process
+        // lifetime. In HTTP mode this may grow unboundedly for long-lived servers.
+        // Use a custom TaskStore with eviction for production HTTP deployments.
         serverConfig.taskStore = new InMemoryTaskStore();
         serverConfig.taskMessageQueue = new InMemoryTaskMessageQueue();
     }
@@ -85,6 +88,7 @@ export async function createServer(options = {}) {
     registerInstructionResource(server, serverInstructions, localIcon);
     registerToolCatalogResource(server, localIcon);
     registerWorkflowGuideResource(server, localIcon);
+    registerToolInfoResource(server, localIcon);
     registerGetHelpPrompt(server, serverInstructions, localIcon);
     registerResultResources(server, resourceStore, localIcon);
     registerMetricsResource(server, localIcon);
@@ -198,11 +202,40 @@ function isAllowedOrigin(origin) {
         return true; // Non-browser clients omit Origin.
     return LOCALHOST_ORIGIN_RE.test(origin);
 }
+function getProtocolVersionHeader(req) {
+    const rawProtocolVersion = req.headers['mcp-protocol-version'];
+    if (typeof rawProtocolVersion === 'string') {
+        return rawProtocolVersion;
+    }
+    if (Array.isArray(rawProtocolVersion)) {
+        return rawProtocolVersion.find((value) => value === REQUIRED_MCP_PROTOCOL_VERSION);
+    }
+    return undefined;
+}
+function ensureProtocolVersionHeader(req, res) {
+    const protocolVersion = getProtocolVersionHeader(req);
+    if (protocolVersion === REQUIRED_MCP_PROTOCOL_VERSION) {
+        return true;
+    }
+    sendJsonRpcError(res, 400, -32000, 'Bad Request: MCP-Protocol-Version header missing or unsupported');
+    return false;
+}
+function discardRequestBody(req) {
+    req.on('error', () => {
+        // Best effort drain to avoid corrupting keep-alive pipelines.
+    });
+    req.resume();
+}
 export async function startHttpServer(port, options) {
     const sessions = new Map();
     async function handleMcpRequest(req, res) {
         const { method } = req;
-        const sessionId = req.headers['mcp-session-id'];
+        const MAX_SESSION_ID_LENGTH = 256;
+        const rawSessionId = req.headers['mcp-session-id'];
+        const sessionId = typeof rawSessionId === 'string' &&
+            rawSessionId.length <= MAX_SESSION_ID_LENGTH
+            ? rawSessionId
+            : undefined;
         const { origin } = req.headers;
         if (!isAllowedOrigin(origin)) {
             sendJsonRpcError(res, 403, -32000, 'Forbidden: disallowed origin');
@@ -235,33 +268,59 @@ export async function startHttpServer(port, options) {
         }
         try {
             if (method === 'POST') {
-                const body = await readRequestBody(req);
-                if (sessionId && sessions.has(sessionId)) {
+                if (sessionId) {
+                    if (!sessions.has(sessionId)) {
+                        sendJsonRpcError(res, 404, -32000, 'Session not found');
+                        discardRequestBody(req);
+                        return;
+                    }
+                    if (!ensureProtocolVersionHeader(req, res)) {
+                        discardRequestBody(req);
+                        return;
+                    }
+                    const body = await readRequestBody(req);
                     const session = sessions.get(sessionId);
                     if (session) {
                         await session.transport.handleRequest(req, res, body);
                     }
+                    else {
+                        sendJsonRpcError(res, 404, -32000, 'Session not found');
+                    }
+                    return;
                 }
-                else if (!sessionId && isInitializeRequest(body)) {
+                const body = await readRequestBody(req);
+                if (isInitializeRequest(body)) {
+                    const maxSessions = parseInt(process.env['FILESYSTEM_MCP_MAX_HTTP_SESSIONS'] ?? '', 10) || 100;
+                    if (sessions.size >= maxSessions) {
+                        sendJsonRpcError(res, 503, -32000, 'Too many sessions');
+                        return;
+                    }
                     const { transport } = await createHttpSession(options, sessions);
                     await transport.handleRequest(req, res, body);
+                    return;
                 }
-                else if (sessionId) {
-                    sendJsonRpcError(res, 400, -32000, 'Bad Request: Session not found');
-                }
-                else {
-                    sendJsonRpcError(res, 400, -32000, 'Bad Request: No valid session ID provided');
-                }
+                sendJsonRpcError(res, 400, -32000, 'Bad Request: No valid session ID provided');
+                discardRequestBody(req);
             }
             else if (method === 'GET' || method === 'DELETE') {
-                if (!sessionId || !sessions.has(sessionId)) {
-                    sendJsonRpcError(res, 400, -32000, 'Bad Request: Invalid or missing session ID');
+                if (!sessionId) {
+                    sendJsonRpcError(res, 400, -32000, 'Bad Request: Missing session ID');
+                    return;
+                }
+                if (!sessions.has(sessionId)) {
+                    sendJsonRpcError(res, 404, -32000, 'Session not found');
+                    return;
+                }
+                if (!ensureProtocolVersionHeader(req, res)) {
                     return;
                 }
                 const session = sessions.get(sessionId);
                 if (session) {
                     await session.transport.handleRequest(req, res);
                 }
+                else {
+                    sendJsonRpcError(res, 404, -32000, 'Session not found');
+                }
             }
             else {
                 res.writeHead(405, { Allow: 'GET, POST, DELETE' });

package/dist/server/capabilities.js

@@ -27,6 +27,11 @@ export function buildServerCapabilities(options = {}) {
         completions: {},
     };
     if (options.enableTaskToolRequests) {
+        // NOTE: enabling task tool requests requires the caller to configure
+        // an InMemoryTaskStore and InMemoryTaskMessageQueue on the McpServer.
+        // InMemoryTaskStore accumulates completed task records with no TTL eviction —
+        // suitable for short-lived stdio sessions. Long-running HTTP servers should
+        // replace it with a TTL-evicting store to avoid unbounded memory growth.
         capabilities.tasks = {
             list: {},
             cancel: {},

package/dist/tools/edit-file.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
+import RE2 from 're2';
 import { ErrorCode } from '../lib/errors.js';
 import { atomicWriteFile } from '../lib/fs-helpers.js';
 import { validateExistingPath } from '../lib/path-validation.js';
@@ -35,7 +36,7 @@ function applyEdits(content, edits, ignoreWhitespace) {
     for (const edit of edits) {
         if (ignoreWhitespace) {
             const pattern = escapeRegExp(edit.oldText).replace(/\s+/g, '\\s+');
-            const regex = new RegExp(pattern);
+            const regex = new RE2(pattern);
             const match = regex.exec(newContent);
             if (!match) {
                 unmatchedEdits.push(edit.oldText);

package/dist/tools/list-directory.js

@@ -17,9 +17,10 @@ export const LIST_DIRECTORY_TOOL = {
     inputSchema: ListDirectoryInputSchema,
     outputSchema: ListDirectoryOutputSchema,
     annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    taskSupport: 'optional',
     nuances: ['`pattern` enables filtered recursive traversal up to `maxDepth`.'],
 };
-function buildListTextResult(result) {
+function buildListTextResult(result, nextCursor) {
     const { entries, summary, path } = result;
     if (entries.length === 0) {
         if (!summary.entriesScanned || summary.entriesScanned === 0) {
@@ -45,7 +46,11 @@ function buildListTextResult(result) {
         truncated: summary.truncated,
         ...(truncatedReason ? { truncatedReason } : {}),
     };
-    return joinLines(lines) + formatOperationSummary(summaryOptions);
+    let text = joinLines(lines) + formatOperationSummary(summaryOptions);
+    if (nextCursor) {
+        text += `\n[Next page available. Use cursor: "${nextCursor}"]`;
+    }
+    return text;
 }
 function buildStructuredListEntry(entry) {
     return {
@@ -115,7 +120,7 @@ async function handleListDirectory(args, signal) {
         ? encodeCursor(cursorOffset + displayEntries.length)
         : undefined;
     const displayResult = { ...result, entries: displayEntries };
-    return buildToolResponse(buildListTextResult(displayResult), buildStructuredListResult(displayResult, nextCursor));
+    return buildToolResponse(buildListTextResult(displayResult, nextCursor), buildStructuredListResult(displayResult, nextCursor));
 }
 export function registerListDirectoryTool(server, options = {}) {
     const handler = (args, extra) => executeToolWithDiagnostics({

package/dist/tools/search-content.js

@@ -224,6 +224,11 @@ export function registerSearchContentTool(server, options = {}) {
                 });
             };
             try {
+                if (signal) {
+                    signal.addEventListener('abort', () => {
+                        console.error('searchContent signal aborted!');
+                    });
+                }
                 const result = await handleSearchContent(args, signal, options.resourceStore, progressWithMessage);
                 const sc = result.structuredContent;
                 const count = sc.ok && sc.totalMatches ? sc.totalMatches : 0;

package/dist/tools/search-files.js

@@ -113,7 +113,10 @@ async function handleSearchFiles(args, signal, onProgress) {
             textLines.push(`  ${entry.path}`);
         }
     }
-    const text = joinLines(textLines) + formatOperationSummary(summaryOptions);
+    let text = joinLines(textLines) + formatOperationSummary(summaryOptions);
+    if (nextCursor) {
+        text += `\n[Next page available. Use cursor: "${nextCursor}"]`;
+    }
     return buildToolResponse(text, structured);
 }
 export function registerSearchFilesTool(server, options = {}) {

package/dist/tools/shared.d.ts

@@ -3,7 +3,6 @@ import { z } from 'zod';
 import type { FileInfo } from '../config.js';
 import { ErrorCode } from '../lib/errors.js';
 import type { ResourceStore } from '../lib/resource-store.js';
-import type { ToolErrorResponseSchema } from '../schemas.js';
 export { type ToolContract } from './contract.js';
 export declare const READ_ONLY_TOOL_ANNOTATIONS: {
     readonly readOnlyHint: true;
@@ -42,11 +41,11 @@ export declare function buildToolResponse<T>(text: string, structuredContent: T,
     content: ContentBlock[];
     structuredContent: T;
 };
-export type ToolResponse<T> = ReturnType<typeof buildToolResponse<T>> & Record<string, unknown>;
-type ToolErrorStructuredContent = z.infer<typeof ToolErrorResponseSchema>;
+export type ToolResponse<T> = ReturnType<typeof buildToolResponse<T>> & {
+    isError?: never;
+} & Record<string, unknown>;
 interface ToolErrorResponse extends Record<string, unknown> {
     content: ContentBlock[];
-    structuredContent: ToolErrorStructuredContent;
     isError: true;
 }
 export type ToolResult<T> = ToolResponse<T> | ToolErrorResponse;

package/dist/tools/shared.js

@@ -195,23 +195,8 @@ export async function executeToolWithDiagnostics(options) {
 export function buildToolErrorResponse(error, defaultCode, path) {
     const detailed = resolveDetailedError(error, defaultCode, path);
     const text = formatDetailedError(detailed);
-    const errorContent = {
-        code: detailed.code,
-        message: detailed.message,
-    };
-    if (detailed.path !== undefined) {
-        errorContent.path = detailed.path;
-    }
-    if (detailed.suggestion !== undefined) {
-        errorContent.suggestion = detailed.suggestion;
-    }
-    const structuredContent = {
-        ok: false,
-        error: errorContent,
-    };
     return {
         content: [{ type: 'text', text }],
-        structuredContent,
         isError: true,
     };
 }

package/dist/tools/task-support.js

@@ -134,14 +134,17 @@ function normalizeCallToolResult(value) {
 function getToolResultErrorCode(result) {
     if (!isRecord(result) || result['isError'] !== true)
         return undefined;
-    const structured = result['structuredContent'];
-    if (!isRecord(structured))
+    const { content } = result;
+    if (!Array.isArray(content) || content.length === 0)
         return undefined;
-    const { error } = structured;
-    if (!isRecord(error))
+    const first = content[0];
+    if (!isRecord(first) || first['type'] !== 'text')
         return undefined;
-    const { code } = error;
-    return typeof code === 'string' ? code : undefined;
+    const { text } = first;
+    if (typeof text !== 'string')
+        return undefined;
+    const match = /^Error \[([A-Z0-9_]+)\]:/.exec(text);
+    return match ? match[1] : undefined;
 }
 function isCancelledToolResult(result) {
     return getToolResultErrorCode(result) === ErrorCode.E_CANCELLED;
@@ -222,7 +225,7 @@ function getTaskId(extra) {
     return extra.taskId;
 }
 function isErrorResult(result) {
-    return 'isError' in result && result.isError === true;
+    return 'isError' in result && result.isError;
 }
 // Strips structuredContent from a tool result if present, without modifying the original object.  This is used when storing error results as 'completed' to prevent client-side output schema validation errors, while still allowing the human-readable error message in content[0].text to be returned to clients.
 function withoutStructuredContent(result) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/filesystem-mcp",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "mcpName": "io.github.j0hanz/filesystem-mcp",
   "description": "MCP Server that enables LLMs to interact with the local filesystem.",
   "type": "module",