@dpesch/mantisbt-mcp-server 1.14.1 → 1.16.0

package/dist/tools/project-versions.js

@@ -1,20 +1,21 @@
 import { z } from 'zod';
+import { coerceBool } from '../coerce.js';
 import { getVersionHint } from '../version-hint.js';
+import { deprecationNote } from '../deprecation.js';
 function errorText(msg) {
     const vh = getVersionHint();
     vh?.triggerLatestVersionFetch();
     const hint = vh?.getUpdateHint();
     return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
 }
-const coerceBool = (val) => val === 'true' ? true : val === 'false' ? false : val;
 /** Drops undefined values so PATCH only touches the fields the caller set. */
 function definedFields(fields) {
     return Object.fromEntries(Object.entries(fields).filter(([, v]) => v !== undefined));
 }
 const PERMISSION_NOTE = 'Requires the manage_project_threshold access level in the project (MantisBT default: manager).';
-const OWNING_PROJECT_NOTE = 'The version must belong to project_id itself: versions inherited from a parent project can only be changed via the parent\'s project_id (otherwise MantisBT answers "Version not found"). get_project_versions with inherit=false (the default) lists the project\'s own versions.';
+const OWNING_PROJECT_NOTE = 'The version must belong to project_id itself: versions inherited from a parent project can only be changed via the parent\'s project_id (otherwise MantisBT answers "Version not found"). get_project with include: ["versions"] and without inherit lists the project\'s own versions.';
 const projectIdSchema = z.coerce.number().int().positive().describe('Numeric ID of the project the version belongs to — use list_projects to discover project IDs');
-const versionIdSchema = z.coerce.number().int().positive().describe('Numeric version ID — use get_project_versions to discover version IDs');
+const versionIdSchema = z.coerce.number().int().positive().describe('Numeric version ID — use get_project with include: ["versions"] to discover version IDs');
 const timestampSchema = z.string().min(1).describe('Version date as ISO 8601 string, e.g. "2026-09-27" or "2026-09-27T10:00:00+02:00". Determines the order in roadmap and changelog.');
 const boolFlag = z.preprocess(coerceBool, z.boolean());
 export function registerProjectVersionTools(server, client, cache) {
@@ -39,6 +40,18 @@ export function registerProjectVersionTools(server, client, cache) {
         await patchCachedVersions((_pid, versions) => versions.map((v) => (v.id === versionId ? result.version : v)));
         return result.version;
     }
+    /**
+     * Creates the follow-up version after a release. A failure must not hide the
+     * release that already succeeded, so it is reported as next_version_error.
+     */
+    async function createFollowUpVersion(projectId, name) {
+        try {
+            return { next_version: await createVersion(projectId, { name }) };
+        }
+        catch (error) {
+            return { next_version_error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     // ---------------------------------------------------------------------------
     // create_version
     // ---------------------------------------------------------------------------
@@ -83,7 +96,9 @@ ${PERMISSION_NOTE}`,
 
 Renaming a version also rewrites the version, target_version and fixed_in_version fields of all issues that reference it (including subprojects if versions are inherited).
 
-Setting released=true does not change the version date — pass timestamp as well, or use release_version, which does both.
+Setting released=true does not change the version date — pass timestamp as well (e.g. the release date).
+
+To release a version: released=true, timestamp=<release date>, and optionally next_version=<name> to create the follow-up version in the same call. With next_version the response is { version: <updated>, next_version: <created> } — or next_version_error: <message> if creating the follow-up failed (the update itself stays in effect). Without next_version the response is the updated version object.
 
 ${OWNING_PROJECT_NOTE}
 
@@ -96,36 +111,48 @@ ${PERMISSION_NOTE}`,
             released: boolFlag.optional().describe('Released flag'),
             obsolete: boolFlag.optional().describe('Obsolete flag'),
             timestamp: timestampSchema.optional(),
+            next_version: z.string().trim().min(1).optional().describe('Only with released=true: name of a follow-up version to create as unreleased placeholder, e.g. "1.2.1". Used as-is — no automatic numbering.'),
         }),
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: true,
         },
-    }, async ({ project_id, version_id, ...fields }) => {
+    }, async ({ project_id, version_id, next_version, ...fields }) => {
         if (Object.keys(definedFields(fields)).length === 0) {
             return {
                 content: [{ type: 'text', text: errorText('No fields to update — pass at least one of name, description, released, obsolete, timestamp.') }],
                 isError: true,
             };
         }
-        try {
-            const updated = await updateVersion(project_id, version_id, fields);
+        if (next_version !== undefined && fields.released !== true) {
             return {
-                content: [{ type: 'text', text: JSON.stringify(updated, null, 2) }],
+                content: [{ type: 'text', text: errorText('next_version is only allowed together with released=true.') }],
+                isError: true,
             };
         }
+        let updated;
+        try {
+            updated = await updateVersion(project_id, version_id, fields);
+        }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
             return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
         }
+        if (next_version === undefined) {
+            return { content: [{ type: 'text', text: JSON.stringify(updated, null, 2) }] };
+        }
+        const result = { version: updated, ...(await createFollowUpVersion(project_id, next_version)) };
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     });
     // ---------------------------------------------------------------------------
     // release_version
     // ---------------------------------------------------------------------------
     server.registerTool('release_version', {
         title: 'Release Version',
-        description: `Mark a version as released and set its date (default: now). Optionally create a follow-up version in the same step.
+        description: `${deprecationNote('release_version', 'update_version with released=true, timestamp and (optionally) next_version')}
+
+Mark a version as released and set its date (default: now). Optionally create a follow-up version in the same step.
 
 The follow-up version is only created when next_version is given; its name is used as-is — no automatic numbering.
 
@@ -157,15 +184,10 @@ ${PERMISSION_NOTE}`,
             const msg = error instanceof Error ? error.message : String(error);
             return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
         }
-        const result = { released };
-        if (next_version !== undefined) {
-            try {
-                result.next_version = await createVersion(project_id, { name: next_version });
-            }
-            catch (error) {
-                result.next_version_error = error instanceof Error ? error.message : String(error);
-            }
-        }
+        const result = {
+            released,
+            ...(next_version !== undefined ? await createFollowUpVersion(project_id, next_version) : {}),
+        };
         return {
             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
         };

package/dist/tools/projects.js

@@ -1,15 +1,105 @@
 import { z } from 'zod';
+import { coerceBool } from '../coerce.js';
 import { getVersionHint } from '../version-hint.js';
-import { ALL_PROJECTS_PREFIX } from '../constants.js';
-import { normalizeProject } from './metadata.js';
+import { normalizeProject, stripAllProjectsPrefix } from './metadata.js';
+import { deprecationNote } from '../deprecation.js';
 function errorText(msg) {
     const vh = getVersionHint();
     vh?.triggerLatestVersionFetch();
     const hint = vh?.getUpdateHint();
     return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
 }
-const coerceBool = (val) => val === 'true' ? true : val === 'false' ? false : val;
+/** Case-insensitive substring match on login name, real name and email. */
+const matchMembers = (users, query) => {
+    const q = query.toLowerCase();
+    return users.filter(u => u.name.toLowerCase().includes(q) ||
+        (u.real_name?.toLowerCase().includes(q) ?? false) ||
+        (u.email?.toLowerCase().includes(q) ?? false));
+};
+const PROJECT_INCLUDES = ['categories', 'users', 'versions'];
 export function registerProjectTools(server, client, cache) {
+    async function fetchVersions(projectId, obsolete, inherit) {
+        const params = {};
+        if (obsolete)
+            params.obsolete = 1;
+        if (inherit)
+            params.inherit = 1;
+        const result = await client.get(`projects/${projectId}/versions`, params);
+        return result.versions ?? [];
+    }
+    /**
+     * Project users. The metadata cache has no access-level filter, so it is
+     * used only when access_level is not given; otherwise the API filters.
+     */
+    async function fetchUsers(projectId, accessLevel) {
+        if (accessLevel === undefined) {
+            const cached = cache ? await cache.loadIfValid() : null;
+            const cachedUsers = cached?.byProject[projectId]?.users;
+            if (cachedUsers)
+                return cachedUsers;
+        }
+        const params = {};
+        if (accessLevel !== undefined)
+            params.access_level = accessLevel;
+        const result = await client.get(`projects/${projectId}/users`, params);
+        return result.users ?? [];
+    }
+    // ---------------------------------------------------------------------------
+    // get_project
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_project', {
+        title: 'Get Project',
+        description: `Get one MantisBT project: its master data (id, name, description, status, enabled, view_state, access_level, subprojects) and, on request, its categories, users and versions in the same call.
+
+- include: any of "categories", "users", "versions" (default: none — master data only).
+- categories: names come without the "[All Projects] " prefix, ready for create_issue / update_issue.
+- users: id, name (login name), real_name, email, access_level. access_level returns only users at or above that level (10=viewer, 25=reporter, 40=updater, 55=developer, 70=manager, 90=administrator) and implies include "users".
+- member_query: case-insensitive substring search in login name, real name and email; returns all matching users. Implies include "users".
+- versions: id, name, released, obsolete, timestamp. obsolete=true adds obsolete versions, inherit=true adds versions of parent projects; either implies include "versions".
+
+Users come from the local metadata cache when it is fresh and no access_level is given. Prerequisites: obtain project_id from list_projects.`,
+        inputSchema: z.object({
+            project_id: z.coerce.number().int().positive().describe('Numeric project ID — use list_projects to discover project IDs'),
+            include: z.array(z.enum(PROJECT_INCLUDES)).optional().describe('Related data to add: "categories", "users", "versions"'),
+            access_level: z.coerce.number().int().optional().describe('Only users at or above this access level; implies include "users"'),
+            member_query: z.string().min(1).optional().describe('Case-insensitive substring to find users by login name, real name or email; implies include "users"'),
+            obsolete: z.preprocess(coerceBool, z.boolean().optional()).describe('Also return obsolete versions; implies include "versions"'),
+            inherit: z.preprocess(coerceBool, z.boolean().optional()).describe('Also return versions inherited from parent projects; implies include "versions"'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project_id, include, access_level, member_query, obsolete, inherit }) => {
+        const wants = new Set(include);
+        if (member_query !== undefined || access_level !== undefined)
+            wants.add('users');
+        if (obsolete !== undefined || inherit !== undefined)
+            wants.add('versions');
+        try {
+            // Categories come with the project itself; users and versions need their own requests.
+            const [projectResult, users, versions] = await Promise.all([
+                client.get(`projects/${project_id}`),
+                wants.has('users') ? fetchUsers(project_id, access_level) : undefined,
+                wants.has('versions') ? fetchVersions(project_id, obsolete, inherit) : undefined,
+            ]);
+            const raw = projectResult.projects?.[0];
+            if (!raw)
+                throw new Error(`Project ${project_id} not found or not accessible.`);
+            const project = {
+                ...normalizeProject(raw),
+                ...(wants.has('categories') && { categories: stripAllProjectsPrefix(raw.categories ?? []) }),
+                ...(users && { users: member_query !== undefined ? matchMembers(users, member_query) : users }),
+                ...(versions && { versions }),
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(project, null, 2) }] };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
     // ---------------------------------------------------------------------------
     // list_projects
     // ---------------------------------------------------------------------------
@@ -40,9 +130,9 @@ export function registerProjectTools(server, client, cache) {
     // ---------------------------------------------------------------------------
     server.registerTool('get_project_users', {
         title: 'Get Project Users',
-        description: `List all users with access to a specific MantisBT project. Returns an array of user objects, each containing id, name (login name), real_name, email, and access_level fields.
+        description: `${deprecationNote('get_project_users', 'get_project with include: ["users"]')}
 
-Use get_project_users when you need the complete user list for a project — for example, to verify who has access or to build a handler list. For name-based lookup of a single user, prefer find_project_member which supports case-insensitive substring search and is significantly faster on large projects.
+List all users with access to a specific MantisBT project. Returns an array of user objects, each containing id, name (login name), real_name, email, and access_level fields.
 
 Access level IDs: 10=viewer, 25=reporter, 40=updater, 55=developer, 70=manager, 90=administrator.
 
@@ -76,7 +166,9 @@ Prerequisites: obtain project_id from list_projects.`,
     // ---------------------------------------------------------------------------
     server.registerTool('get_project_versions', {
         title: 'Get Project Versions',
-        description: `List all versions defined for a MantisBT project. Returns an array of version objects, each containing id, name, released (boolean), obsolete (boolean), and timestamp (version date). To create, change, release or delete versions use create_version, update_version, release_version and delete_version.
+        description: `${deprecationNote('get_project_versions', 'get_project with include: ["versions"]')}
+
+List all versions defined for a MantisBT project. Returns an array of version objects, each containing id, name, released (boolean), obsolete (boolean), and timestamp (version date). To create, change, release or delete versions use create_version, update_version, release_version and delete_version.
 
 Use the returned version names directly when creating or updating issues via create_issue and update_issue (version, target_version, fixed_in_version fields).
 
@@ -95,14 +187,9 @@ Prerequisites: obtain project_id from list_projects.`,
         },
     }, async ({ project_id, obsolete, inherit }) => {
         try {
-            const params = {};
-            if (obsolete)
-                params.obsolete = 1;
-            if (inherit)
-                params.inherit = 1;
-            const result = await client.get(`projects/${project_id}/versions`, params);
+            const versions = await fetchVersions(project_id, obsolete, inherit);
             return {
-                content: [{ type: 'text', text: JSON.stringify(result.versions ?? result, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(versions, null, 2) }],
             };
         }
         catch (error) {
@@ -115,7 +202,9 @@ Prerequisites: obtain project_id from list_projects.`,
     // ---------------------------------------------------------------------------
     server.registerTool('get_project_categories', {
         title: 'Get Project Categories',
-        description: `List all categories available for a MantisBT project.
+        description: `${deprecationNote('get_project_categories', 'get_project with include: ["categories"]')}
+
+List all categories available for a MantisBT project.
 
 Note: The MantisBT API returns global (cross-project) categories with a "[All Projects] " prefix.
 This tool strips that prefix so the returned names can be used directly when creating issues.`,
@@ -130,13 +219,7 @@ This tool strips that prefix so the returned names can be used directly when cre
     }, async ({ project_id }) => {
         try {
             const result = await client.get(`projects/${project_id}`);
-            const raw = result.projects?.[0]?.categories ?? [];
-            const categories = raw.map((cat) => ({
-                ...cat,
-                name: cat.name.startsWith(ALL_PROJECTS_PREFIX)
-                    ? cat.name.slice(ALL_PROJECTS_PREFIX.length)
-                    : cat.name,
-            }));
+            const categories = stripAllProjectsPrefix(result.projects?.[0]?.categories ?? []);
             return {
                 content: [{ type: 'text', text: JSON.stringify(categories, null, 2) }],
             };
@@ -151,7 +234,9 @@ This tool strips that prefix so the returned names can be used directly when cre
     // ---------------------------------------------------------------------------
     server.registerTool('find_project_member', {
         title: 'Find Project Member',
-        description: `Search for users with access to a MantisBT project by name, display name, or email.
+        description: `${deprecationNote('find_project_member', 'get_project with member_query')}
+
+Search for users with access to a MantisBT project by name, display name, or email.
 
 Returns up to \`limit\` matching users (default: 10, max: 100). Matching is case-insensitive substring search across \`name\`, \`real_name\`, and \`email\` fields. Omit \`query\` to list the first \`limit\` users.
 
@@ -168,21 +253,8 @@ Data is served from the local metadata cache when fresh; falls back to a live AP
         },
     }, async ({ project_id, query, limit }) => {
         try {
-            let users;
-            const cached = cache ? await cache.loadIfValid() : null;
-            if (cached?.byProject[project_id]) {
-                users = cached.byProject[project_id].users;
-            }
-            else {
-                const result = await client.get(`projects/${project_id}/users`);
-                users = result.users ?? [];
-            }
-            if (query) {
-                const q = query.toLowerCase();
-                users = users.filter((u) => u.name.toLowerCase().includes(q) ||
-                    (u.real_name?.toLowerCase().includes(q) ?? false) ||
-                    (u.email?.toLowerCase().includes(q) ?? false));
-            }
+            const all = await fetchUsers(project_id);
+            const users = query ? matchMembers(all, query) : all;
             return {
                 content: [{ type: 'text', text: JSON.stringify(users.slice(0, limit), null, 2) }],
             };

package/dist/tools/users.js

@@ -12,7 +12,9 @@ export function registerUserTools(server, client) {
     // ---------------------------------------------------------------------------
     server.registerTool('get_current_user', {
         title: 'Get Current User',
-        description: 'Retrieve the profile of the user associated with the current API key.',
+        description: `Retrieve the profile of the user associated with the current API key: id, name (login name), real_name, email, language, timezone, access_level, created_at and the accessible projects.
+
+"language" is the MantisBT language of this user (e.g. "german", "english") — use it as the hint for which language to write issue texts and notes in, and expect localized enum labels in that language.`,
         inputSchema: z.object({}),
         annotations: {
             readOnlyHint: true,

package/dist/tools/version.js

@@ -1,13 +1,68 @@
 import { z } from 'zod';
+import { coerceBool } from '../coerce.js';
 import { parseVersion, compareVersions } from '../version-hint.js';
-const coerceBool = (val) => val === 'true' ? true : val === 'false' ? false : val;
+import { deprecationNote } from '../deprecation.js';
 export function registerVersionTools(server, client, versionHint, mcpVersion) {
+    /**
+     * Installed MantisBT version (X-Mantis-Version header), optionally compared
+     * with the latest MantisBT release on GitHub.
+     */
+    async function mantisVersionInfo(checkLatest) {
+        // Start the GitHub lookup first so it overlaps with the MantisBT request.
+        if (checkLatest)
+            versionHint.triggerLatestVersionFetch();
+        const installedRaw = await client.getVersion();
+        const result = { installed_version: installedRaw };
+        if (!checkLatest)
+            return result;
+        const latestRaw = await versionHint.waitForLatestVersion(5000);
+        result.latest_version = latestRaw;
+        if (latestRaw === null) {
+            result.status = 'unknown';
+            result.github_note = 'Could not fetch latest version from GitHub (timeout or network error).';
+            return result;
+        }
+        const installed = parseVersion(installedRaw);
+        const latest = parseVersion(latestRaw);
+        if (installed && latest) {
+            const cmp = compareVersions(installed, latest);
+            result.status = cmp === 0 ? 'up-to-date' : cmp > 0 ? 'newer-than-release' : 'update-available';
+        }
+        else {
+            result.status = 'unknown';
+        }
+        return result;
+    }
+    const checkLatestSchema = z.preprocess(coerceBool, z.boolean().default(true)).describe('Whether to fetch the latest MantisBT release from GitHub and compare (default: true)');
+    // ---------------------------------------------------------------------------
+    // get_version
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_version', {
+        title: 'Get Versions',
+        description: `Return the version of this mantisbt-mcp-server and of the connected MantisBT installation in one response:
+{ mcp_server: { version }, mantis: { installed_version, latest_version?, status?, github_note? } }
+
+The MantisBT version is read from the X-Mantis-Version response header. With check_latest (default: true) it is compared against the latest MantisBT release on GitHub (outbound HTTPS request, up to 5 seconds); status is "up-to-date", "update-available", "newer-than-release" or "unknown". If MantisBT cannot be reached, mantis contains "error" instead and mcp_server is still returned.`,
+        inputSchema: z.object({ check_latest: checkLatestSchema }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ check_latest }) => {
+        const mantis = await mantisVersionInfo(check_latest).catch((error) => ({
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ mcp_server: { version: mcpVersion }, mantis }, null, 2) }],
+        };
+    });
     // ---------------------------------------------------------------------------
     // get_mcp_version
     // ---------------------------------------------------------------------------
     server.registerTool('get_mcp_version', {
         title: 'Get MCP Server Version',
-        description: 'Returns the version of this mantisbt-mcp-server instance.',
+        description: `${deprecationNote('get_mcp_version', 'get_version')}\n\nReturns the version of this mantisbt-mcp-server instance.`,
         inputSchema: z.object({}),
         annotations: {
             readOnlyHint: true,
@@ -22,13 +77,10 @@ export function registerVersionTools(server, client, versionHint, mcpVersion) {
     // ---------------------------------------------------------------------------
     server.registerTool('get_mantis_version', {
         title: 'Get MantisBT Version',
-        description: `Returns the version of the connected MantisBT installation and optionally compares it against the latest official release on GitHub.
+        description: `${deprecationNote('get_mantis_version', 'get_version')}
 
-The version is read from the X-Mantis-Version response header sent by every API call.
-The GitHub comparison requires an outbound HTTPS request to the GitHub API.`,
-        inputSchema: z.object({
-            check_latest: z.preprocess(coerceBool, z.boolean().default(true)).describe('Whether to fetch the latest release from GitHub and compare (default: true)'),
-        }),
+Returns the version of the connected MantisBT installation and optionally compares it against the latest official release on GitHub.`,
+        inputSchema: z.object({ check_latest: checkLatestSchema }),
         annotations: {
             readOnlyHint: true,
             destructiveHint: false,
@@ -36,34 +88,8 @@ The GitHub comparison requires an outbound HTTPS request to the GitHub API.`,
         },
     }, async ({ check_latest }) => {
         try {
-            const installedRaw = await client.getVersion();
-            const result = { installed_version: installedRaw };
-            if (check_latest) {
-                versionHint.triggerLatestVersionFetch();
-                const latestRaw = await versionHint.waitForLatestVersion(5000);
-                result.latest_version = latestRaw;
-                if (latestRaw === null) {
-                    result.status = 'unknown';
-                    result.github_note = 'Could not fetch latest version from GitHub (timeout or network error).';
-                }
-                else {
-                    const installed = parseVersion(installedRaw);
-                    const latest = parseVersion(latestRaw);
-                    if (installed && latest) {
-                        const cmp = compareVersions(installed, latest);
-                        result.status = cmp === 0
-                            ? 'up-to-date'
-                            : cmp > 0
-                                ? 'newer-than-release'
-                                : 'update-available';
-                    }
-                    else {
-                        result.status = 'unknown';
-                    }
-                }
-            }
             return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(await mantisVersionInfo(check_latest), null, 2) }],
             };
         }
         catch (error) {

package/dist/toolsets.js

@@ -0,0 +1,104 @@
+// ---------------------------------------------------------------------------
+// Tool groups for MANTIS_TOOLSETS and MANTIS_DISABLE_DESTRUCTIVE (#8500)
+// ---------------------------------------------------------------------------
+export const TOOLSETS = ['issues', 'notes', 'links', 'files', 'projects', 'versions', 'meta', 'search'];
+/**
+ * Group of every tool. A deprecated tool belongs to the group of its
+ * replacement, so switching a group off hides old and new name together.
+ * tests/toolsets.test.ts checks this list against the registered tools in
+ * both directions — keep it in sync when adding or removing a tool.
+ */
+export const TOOL_GROUPS = {
+    // issues
+    get_issue: 'issues',
+    get_issues: 'issues', // deprecated → get_issue
+    list_issues: 'issues',
+    create_issue: 'issues',
+    update_issue: 'issues',
+    delete_issue: 'issues',
+    list_notes: 'issues', // deprecated → get_issue
+    list_issue_files: 'issues', // deprecated → get_issue
+    add_monitor: 'issues', // deprecated → update_issue
+    remove_monitor: 'issues', // deprecated → update_issue
+    // notes
+    add_note: 'notes',
+    delete_note: 'notes',
+    // links
+    add_relationship: 'links',
+    remove_relationship: 'links',
+    attach_tags: 'links',
+    detach_tag: 'links',
+    list_tags: 'links',
+    // files
+    upload_file: 'files',
+    // projects
+    list_projects: 'projects',
+    get_project: 'projects',
+    list_filters: 'projects',
+    get_project_categories: 'projects', // deprecated → get_project
+    get_project_users: 'projects', // deprecated → get_project
+    get_project_versions: 'projects', // deprecated → get_project
+    find_project_member: 'projects', // deprecated → get_project
+    // versions
+    create_version: 'versions',
+    update_version: 'versions',
+    delete_version: 'versions',
+    release_version: 'versions', // deprecated → update_version
+    // meta
+    get_metadata: 'meta',
+    get_metadata_full: 'meta', // deprecated → get_metadata
+    sync_metadata: 'meta', // deprecated → get_metadata
+    get_search_index_status: 'meta', // deprecated → get_metadata
+    get_issue_schema: 'meta',
+    get_issue_fields: 'meta', // deprecated → get_issue_schema
+    get_issue_enums: 'meta', // deprecated → get_issue_schema
+    get_config: 'meta',
+    get_version: 'meta',
+    get_mcp_version: 'meta', // deprecated → get_version
+    get_mantis_version: 'meta', // deprecated → get_version
+    get_current_user: 'meta',
+    list_languages: 'meta', // deprecated → get_current_user
+    // search (additionally requires MANTIS_SEARCH_ENABLED=true)
+    search_issues: 'search',
+    rebuild_search_index: 'search',
+};
+/**
+ * Parses MANTIS_TOOLSETS: comma-separated group names, case-insensitive.
+ * Unset or empty means all groups. An unknown name throws, listing the valid
+ * ones, so a typo does not silently hide tools.
+ */
+export function parseToolsets(raw) {
+    const names = (raw ?? '').split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
+    if (names.length === 0)
+        return new Set(TOOLSETS);
+    const unknown = names.find(name => !isToolset(name));
+    if (unknown !== undefined) {
+        throw new Error(`Unknown MANTIS_TOOLSETS group "${unknown}". Valid groups: ${TOOLSETS.join(', ')}.`);
+    }
+    return new Set(names.filter(isToolset));
+}
+const isToolset = (name) => TOOLSETS.includes(name);
+/**
+ * Returns the server with registerTool filtered: tools of disabled groups and,
+ * with disableDestructive, destructive tools are skipped. Everything else
+ * (resources, prompts, connect, …) passes through unchanged. The register*Tools
+ * functions receive this instead of the server and need no changes.
+ */
+export function filterToolRegistration(server, filter) {
+    const registerTool = ((name, config, callback) => {
+        const group = TOOL_GROUPS[name];
+        if (group === undefined) {
+            throw new Error(`Tool "${name}" has no group — add it to TOOL_GROUPS in src/toolsets.ts.`);
+        }
+        // A skipped tool is never registered, so it is neither listed nor callable.
+        // No caller uses registerTool's return value.
+        if (!filter.toolsets.has(group))
+            return undefined;
+        if (filter.disableDestructive && config.annotations?.destructiveHint === true)
+            return undefined;
+        return server.registerTool(name, config, callback);
+    });
+    return new Proxy(server, {
+        get: (target, prop, receiver) => (prop === 'registerTool' ? registerTool : Reflect.get(target, prop, receiver)),
+    });
+}