@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/tools/stat-many.js

@@ -1,104 +0,0 @@
-import { DEFAULT_SEARCH_TIMEOUT_MS } from '../lib/constants.js';
-import { classifyError, 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 { FILE_READ_ICONS } from './icons.js';
-import { 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',
-    description: 'Get metadata for multiple files/directories in one request. ' +
-        'Use `tokenEstimate` (size\u00f74) to pre-screen token cost before reading.',
-    inputSchema: GetMultipleFileInfoInputSchema,
-    outputSchema: GetMultipleFileInfoOutputSchema,
-    annotations: READ_ONLY_TOOL_ANNOTATIONS,
-    icons: FILE_READ_ICONS,
-    taskSupport: 'optional',
-};
-function formatFileInfoDetail(info) {
-    const lines = [
-        `${info.name} (${info.type})`,
-        `  Path: ${info.path}`,
-        `  Size: ${formatBytes(info.size)}`,
-        `  Modified: ${info.modified.toISOString()}`,
-    ];
-    if (info.mimeType)
-        lines.push(`  Type: ${info.mimeType}`);
-    if (info.symlinkTarget)
-        lines.push(`  Target: ${info.symlinkTarget}`);
-    return joinLines(lines);
-}
-async function handleGetMultipleFileInfo(args, signal, onProgress) {
-    const result = await getMultipleFileInfo(args.paths, {
-        includeMimeType: true,
-        ...(signal ? { signal } : {}),
-        ...(onProgress ? { onProgress } : {}),
-    });
-    const structuredResults = result.results.map((entry) => ({
-        path: entry.path,
-        info: entry.info ? buildFileInfoPayload(entry.info) : undefined,
-        error: entry.error
-            ? buildStructuredError(entry.error, ErrorCode.NOT_FOUND, entry.path)
-            : undefined,
-    }));
-    const text = result.results
-        .map((entry) => {
-        if (entry.error) {
-            return `${entry.path}: ${buildStructuredError(entry.error, ErrorCode.NOT_FOUND, entry.path).message}`;
-        }
-        if (entry.info) {
-            return formatFileInfoDetail(entry.info);
-        }
-        return entry.path;
-    })
-        .join('\n\n');
-    const structured = {
-        ok: true,
-        results: structuredResults,
-        summary: {
-            total: result.summary.total,
-            succeeded: result.summary.succeeded,
-            failed: result.summary.failed,
-        },
-    };
-    return buildToolResponse(text, structured);
-}
-export function registerGetMultipleFileInfoTool(server, options = {}) {
-    const handler = (args, ctx) => {
-        const primaryPath = args.paths[0] ?? '';
-        return executeToolWithDiagnostics({
-            toolName: 'stat_many',
-            ctx,
-            outputSchema: GetMultipleFileInfoOutputSchema,
-            timedSignal: { timeoutMs: DEFAULT_SEARCH_TIMEOUT_MS },
-            context: { path: primaryPath },
-            run: async (signal) => {
-                const context = buildBatchPathContext(args.paths);
-                const { progress, onItemComplete } = createBatchProgressCallbacks(ctx, {
-                    toolLabel: GET_MULTIPLE_FILE_INFO_TOOL.title,
-                    context,
-                    totalItems: args.paths.length,
-                    itemVerb: 'done',
-                });
-                try {
-                    const result = await handleGetMultipleFileInfo(args, signal, onItemComplete);
-                    const sc = result.structuredContent;
-                    const total = sc.summary?.total ?? 0;
-                    const failed = sc.summary?.failed ?? 0;
-                    const suffix = failed ? `${failed} failed` : 'done';
-                    const finalCurrent = resolveFinalProgressCurrent(progress, total);
-                    progress.complete(`${GET_MULTIPLE_FILE_INFO_TOOL.title}: ${context} • ${suffix}`, finalCurrent);
-                    return result;
-                }
-                catch (error) {
-                    progress.fail(`${GET_MULTIPLE_FILE_INFO_TOOL.title}: ${context} • ${classifyError(error)}`);
-                    throw error;
-                }
-            },
-            onError: (error) => buildToolErrorResponse(error, ErrorCode.NOT_FOUND, primaryPath),
-        });
-    };
-    registerStandardTool(server, GET_MULTIPLE_FILE_INFO_TOOL, handler, options);
-}

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

@@ -1,29 +0,0 @@
-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';
-/**
- * Report an intermediate 'working' status update for the current task.
- * No-op when called outside of a task context.
- */
-export declare function reportTaskStatus(statusMessage: string): Promise<void>;
-type TaskToolContext = ToolContext & {
-    taskId?: string;
-    taskStore?: RequestTaskStore;
-    taskRequestedTtl?: number;
-};
-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, 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,472 +0,0 @@
-import { isTerminal, RELATED_TASK_META_KEY, } from '@modelcontextprotocol/server';
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { channel } from 'node:diagnostics_channel';
-import { performance } from 'node:perf_hooks';
-import { format } from 'node:util';
-import { DEFAULT_TASK_TTL_MS, MAX_CONCURRENT_TASKS, MAX_TASK_TTL_MS, TASK_CANCEL_POLL_MS, TASK_POLL_INTERVAL_MS, } from '../lib/constants.js';
-import { ErrorCode, McpError } from '../lib/errors.js';
-import { Logger } from '../lib/logger.js';
-import { isRecord } from '../lib/utils.js';
-import { buildToolErrorResponse, maybeStripStructuredContentFromResult, resolveToolTaskSupportLevel, toToolContext, withDefaultIcons, withValidatedArgs, wrapToolHandler, } from './shared.js';
-const taskContext = new AsyncLocalStorage();
-/**
- * Report an intermediate 'working' status update for the current task.
- * No-op when called outside of a task context.
- */
-export async function reportTaskStatus(statusMessage) {
-    const store = taskContext.getStore();
-    if (!store)
-        return;
-    const { taskId, taskStore, ctx, toolName } = store;
-    try {
-        await taskStore.updateTaskStatus(taskId, 'working', statusMessage);
-        await notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName);
-    }
-    catch {
-        // Best-effort: never fail tool execution for status updates.
-    }
-}
-const TASK_DIAGNOSTICS_CHANNEL = channel('filesystem-mcp:tasks');
-function publishTaskDiagnostics(event) {
-    if (TASK_DIAGNOSTICS_CHANNEL.hasSubscribers) {
-        TASK_DIAGNOSTICS_CHANNEL.publish(event);
-    }
-}
-// --- Type Guards & Helpers ---
-function hasTaskToolCapability(server) {
-    try {
-        const capabilities = server.server.getCapabilities();
-        return capabilities.tasks?.requests?.tools?.call !== undefined;
-    }
-    catch {
-        return false;
-    }
-}
-const TASK_STATUS_NOTIFICATION_METHOD = 'notifications/tasks/status';
-const TASK_CREATED_NOTIFICATION_METHOD = 'notifications/tasks/created';
-function assertCreateTaskContext(value) {
-    if (!isRecord(value.task) || typeof value.task.store !== 'object') {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
-    }
-}
-function assertTaskRequestContext(value) {
-    if (!isRecord(value.task) ||
-        typeof value.task.store !== 'object' ||
-        typeof value.task.id !== 'string' ||
-        value.task.id.length === 0) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Task id or store missing.');
-    }
-}
-function toTaskToolContext(ctx) {
-    return {
-        ...toToolContext(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 }
-            : {}),
-    };
-}
-function toGetTaskResult(task) {
-    return task;
-}
-function toCallToolResult(value) {
-    return value;
-}
-function getToolResultErrorCode(result) {
-    if (!isRecord(result) || result.isError !== true)
-        return undefined;
-    if (typeof result.errorCode === 'string')
-        return result.errorCode;
-    const { content } = result;
-    if (!Array.isArray(content) || content.length === 0)
-        return undefined;
-    const first = content[0];
-    if (!isRecord(first) || first.type !== 'text')
-        return 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.CANCELLED;
-}
-function resolveTaskResultStatuses(result) {
-    if (isCancelledToolResult(result)) {
-        return { storedStatus: 'failed', reportedStatus: 'cancelled' };
-    }
-    if (isRecord(result) && result.isError === true) {
-        return { storedStatus: 'failed', reportedStatus: 'failed' };
-    }
-    return { storedStatus: 'completed', reportedStatus: 'completed' };
-}
-function attachRelatedTaskMeta(result, taskId) {
-    const existingMeta = isRecord(result._meta) ? result._meta : {};
-    return {
-        ...result,
-        _meta: {
-            ...existingMeta,
-            [RELATED_TASK_META_KEY]: { taskId },
-        },
-    };
-}
-async function projectCancelledTaskStatus(taskStore, task) {
-    if (task.status !== 'failed')
-        return task;
-    try {
-        const result = await taskStore.getTaskResult(task.taskId);
-        if (isCancelledToolResult(result)) {
-            return { ...task, status: 'cancelled' };
-        }
-    }
-    catch {
-        // Best effort only: task result may not be available yet.
-    }
-    return task;
-}
-function buildTaskStatusNotificationParams(task) {
-    const params = {
-        taskId: task.taskId,
-        status: task.status,
-        ttl: task.ttl,
-        createdAt: task.createdAt,
-        lastUpdatedAt: task.lastUpdatedAt,
-    };
-    if (task.pollInterval !== undefined)
-        params.pollInterval = task.pollInterval;
-    if (task.statusMessage !== undefined)
-        params.statusMessage = task.statusMessage;
-    return params;
-}
-async function notifyTaskCreatedIfPossible(ctx, taskId, toolName) {
-    if (!ctx.sendNotification)
-        return;
-    try {
-        await ctx.sendNotification({
-            method: TASK_CREATED_NOTIFICATION_METHOD,
-            params: {
-                _meta: {
-                    [RELATED_TASK_META_KEY]: {
-                        taskId,
-                    },
-                },
-            },
-        });
-    }
-    catch {
-        publishTaskDiagnostics({
-            phase: 'task_status_notify_failed',
-            taskId,
-            ...(toolName ? { toolName } : {}),
-        });
-    }
-}
-async function notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName) {
-    if (!ctx.sendNotification)
-        return;
-    try {
-        const task = await taskStore.getTask(taskId);
-        const normalized = await projectCancelledTaskStatus(taskStore, toGetTaskResult(task));
-        await ctx.sendNotification({
-            method: TASK_STATUS_NOTIFICATION_METHOD,
-            params: buildTaskStatusNotificationParams(normalized),
-        });
-        publishTaskDiagnostics({
-            phase: 'task_status_notified',
-            taskId,
-            status: normalized.status,
-            ...(toolName ? { toolName } : {}),
-        });
-    }
-    catch {
-        publishTaskDiagnostics({
-            phase: 'task_status_notify_failed',
-            taskId,
-            ...(toolName ? { toolName } : {}),
-        });
-        // Never fail task execution because status notifications are optional.
-    }
-}
-function getTaskStore(ctx) {
-    if (!ctx.taskStore) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Task store not configured.');
-    }
-    return ctx.taskStore;
-}
-function getTaskId(ctx) {
-    if (!ctx.taskId) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Task id missing.');
-    }
-    return ctx.taskId;
-}
-function isErrorResult(result) {
-    return 'isError' in result && result.isError;
-}
-// Strips structuredContent from a tool result if present, without modifying the original object.
-function withoutStructuredContent(result) {
-    if (!Object.hasOwn(result, 'structuredContent'))
-        return result;
-    const stripped = { ...result };
-    delete stripped['structuredContent'];
-    return stripped;
-}
-const taskCreationLocks = new WeakMap();
-async function acquireTaskCreationLock(taskStore) {
-    const previous = taskCreationLocks.get(taskStore) ?? Promise.resolve();
-    let release;
-    const next = new Promise((resolve) => {
-        release = resolve;
-    });
-    taskCreationLocks.set(taskStore, previous.catch(() => { }).then(() => next));
-    await previous.catch(() => { });
-    return () => {
-        release();
-    };
-}
-async function isTaskAlreadyTerminal(taskStore, taskId) {
-    try {
-        const task = await taskStore.getTask(taskId);
-        if (!isRecord(task))
-            return false;
-        const { status } = task;
-        return typeof status === 'string' && isTerminal(status);
-    }
-    catch {
-        return false;
-    }
-}
-function isMissingTaskStoreError(error) {
-    return (error instanceof Error &&
-        /Task .*not found|not found after cancellation/iu.test(error.message));
-}
-async function countActiveTasks(taskStore) {
-    if (typeof taskStore.listTasks !== 'function')
-        return 0;
-    const listed = await taskStore.listTasks();
-    const tasks = Array.isArray(listed.tasks) ? listed.tasks : [];
-    let active = 0;
-    for (const task of tasks) {
-        if (!isRecord(task) || typeof task.status !== 'string')
-            continue;
-        if (!isTerminal(task.status)) {
-            active += 1;
-        }
-    }
-    return active;
-}
-function resolveRequestedTaskTtl(requestedTtl) {
-    if (requestedTtl === undefined)
-        return DEFAULT_TASK_TTL_MS;
-    if (!Number.isFinite(requestedTtl)) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Task TTL must be finite.');
-    }
-    const normalized = Math.trunc(requestedTtl);
-    if (normalized <= 0) {
-        throw new McpError(ErrorCode.INVALID_INPUT, 'Task TTL must be > 0.');
-    }
-    return Math.min(normalized, MAX_TASK_TTL_MS);
-}
-async function safelyStoreTaskResult(taskStore, taskId, storedStatus, result) {
-    try {
-        await taskStore.storeTaskResult(taskId, storedStatus, result);
-    }
-    catch (error) {
-        if (isMissingTaskStoreError(error))
-            return;
-        // If task was already cancelled/failed by another process, ignore the write error
-        if (await isTaskAlreadyTerminal(taskStore, taskId))
-            return;
-        throw error;
-    }
-}
-async function isTaskCancelled(taskStore, taskId) {
-    try {
-        const task = await taskStore.getTask(taskId);
-        return isRecord(task) && task.status === 'cancelled';
-    }
-    catch {
-        return false;
-    }
-}
-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 = { ...ctx, signal: taskAbort.signal };
-    // Poll the task store for client-initiated cancellation.
-    const cancelPoller = setInterval(() => {
-        void isTaskCancelled(taskStore, taskId).then((cancelled) => {
-            if (cancelled)
-                taskAbort.abort(new Error('Task cancelled by client'));
-        });
-    }, cancelPollMs ?? TASK_CANCEL_POLL_MS);
-    const start = performance.now();
-    let taskStatuses;
-    let result;
-    try {
-        const rawResult = await taskContext.run({ taskId, toolName, startTime: start, taskStore, ctx: taskExtra }, () => run(args, taskExtra));
-        taskStatuses = resolveTaskResultStatuses(rawResult);
-        result = isErrorResult(rawResult)
-            ? withoutStructuredContent(rawResult)
-            : maybeStripStructuredContentFromResult(rawResult);
-    }
-    catch (error) {
-        taskStatuses = { storedStatus: 'failed', reportedStatus: 'failed' };
-        result = maybeStripStructuredContentFromResult(buildToolErrorResponse(error, ErrorCode.UNKNOWN));
-    }
-    finally {
-        clearInterval(cancelPoller);
-    }
-    const durationMs = performance.now() - start;
-    try {
-        await safelyStoreTaskResult(taskStore, taskId, taskStatuses.storedStatus, result);
-        publishTaskDiagnostics({
-            phase: 'task_result_stored',
-            taskId,
-            status: taskStatuses.reportedStatus,
-            toolName,
-            durationMs,
-        });
-        await notifyTaskStatusIfPossible(ctx, taskStore, taskId, toolName);
-    }
-    catch (innerError) {
-        Logger.error(format('Failed to store task result for task %s:', taskId), innerError);
-        const syntheticTask = {
-            taskId,
-            status: taskStatuses.reportedStatus === 'cancelled' ? 'cancelled' : 'failed',
-            ttl: null,
-            createdAt: new Date().toISOString(),
-            lastUpdatedAt: new Date().toISOString(),
-            statusMessage: 'Internal system error while storing result',
-        };
-        if (ctx.sendNotification) {
-            try {
-                await ctx.sendNotification({
-                    method: TASK_STATUS_NOTIFICATION_METHOD,
-                    params: buildTaskStatusNotificationParams(syntheticTask),
-                });
-            }
-            catch {
-                // Best effort only: transport may already be closed while a cancelled
-                // task is still unwinding in the background.
-            }
-        }
-    }
-}
-/**
- * Registers a tool preferring task-capable registration when available, and
- * returns `true`. Returns `false` so the caller can fall through to standard
- * `server.registerTool`.
- */
-function tryRegisterToolTask(server, toolName, toolDef, taskHandler, iconInfo) {
-    if (!hasTaskToolCapability(server))
-        return false;
-    const def = toolDef;
-    const existingExecution = def.execution ?? {};
-    const taskSupport = resolveToolTaskSupportLevel(def.taskSupport, existingExecution.taskSupport);
-    if (!taskSupport || taskSupport === 'forbidden')
-        return false;
-    server.experimental.tasks.registerToolTask(toolName, withDefaultIcons({ ...toolDef, execution: { ...existingExecution, taskSupport } }, iconInfo), taskHandler);
-    return true;
-}
-export function registerToolTaskIfAvailable(server, toolName, toolDef, run, iconInfo, guard) {
-    const taskOptions = {
-        ...(guard ? { guard } : {}),
-        toolName,
-    };
-    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 (...params) => {
-        let args;
-        let serverCtx;
-        if (params.length === 1) {
-            serverCtx = params[0];
-        }
-        else {
-            [args, serverCtx] = params;
-        }
-        assertCreateTaskContext(serverCtx);
-        const ctx = toTaskToolContext(serverCtx);
-        if (options?.guard && !options.guard()) {
-            throw new McpError(ErrorCode.INVALID_INPUT, 'Client not initialized; wait for notifications/initialized');
-        }
-        const taskStore = getTaskStore(ctx);
-        const releaseCreationLock = await acquireTaskCreationLock(taskStore);
-        let task;
-        try {
-            if ((await countActiveTasks(taskStore)) >= MAX_CONCURRENT_TASKS) {
-                throw new McpError(ErrorCode.INVALID_INPUT, `Too many active tasks (limit: ${String(MAX_CONCURRENT_TASKS)}).`);
-            }
-            task = await taskStore.createTask({
-                ttl: resolveRequestedTaskTtl(ctx.taskRequestedTtl),
-                pollInterval: options?.pollIntervalMs ?? TASK_POLL_INTERVAL_MS,
-            });
-        }
-        finally {
-            releaseCreationLock();
-        }
-        const toolLabel = options?.toolName ?? 'tool';
-        try {
-            await taskStore.updateTaskStatus(task.taskId, 'working', `${toolLabel}: starting`);
-        }
-        catch {
-            // Best effort — status message is informational.
-        }
-        publishTaskDiagnostics({
-            phase: 'task_created',
-            taskId: task.taskId,
-            status: task.status,
-            ...(options?.toolName ? { toolName: options.toolName } : {}),
-        });
-        const taskExtra = {
-            ...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,
-        };
-    });
-    const getTask = (async (...params) => {
-        const serverCtx = params.length === 1 ? params[0] : params[1];
-        assertTaskRequestContext(serverCtx);
-        const ctx = toTaskToolContext(serverCtx);
-        const taskStore = getTaskStore(ctx);
-        const taskId = getTaskId(ctx);
-        const task = await taskStore.getTask(taskId);
-        return projectCancelledTaskStatus(taskStore, toGetTaskResult(task));
-    });
-    const getTaskResult = (async (...params) => {
-        const serverCtx = params.length === 1 ? params[0] : params[1];
-        assertTaskRequestContext(serverCtx);
-        const ctx = toTaskToolContext(serverCtx);
-        const taskStore = getTaskStore(ctx);
-        const taskId = getTaskId(ctx);
-        const result = await taskStore.getTaskResult(taskId);
-        return attachRelatedTaskMeta(toCallToolResult(result), taskId);
-    });
-    return {
-        createTask,
-        getTask,
-        getTaskResult,
-    };
-}

package/dist/tools/tree.d.ts

@@ -1,4 +0,0 @@
-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;