@dpesch/mantisbt-mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+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 { createServer } from 'node:http';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { join, dirname } from 'node:path';
+import { getConfig } from './config.js';
+import { MantisClient } from './client.js';
+import { VersionHintService, setGlobalVersionHint } from './version-hint.js';
+import { MetadataCache } from './cache.js';
+import { registerIssueTools } from './tools/issues.js';
+import { registerNoteTools } from './tools/notes.js';
+import { registerFileTools } from './tools/files.js';
+import { registerRelationshipTools } from './tools/relationships.js';
+import { registerMonitorTools } from './tools/monitors.js';
+import { registerProjectTools } from './tools/projects.js';
+import { registerUserTools } from './tools/users.js';
+import { registerFilterTools } from './tools/filters.js';
+import { registerConfigTools } from './tools/config.js';
+import { registerMetadataTools } from './tools/metadata.js';
+import { registerTagTools } from './tools/tags.js';
+import { registerVersionTools } from './tools/version.js';
+// ---------------------------------------------------------------------------
+// Read version from package.json
+// ---------------------------------------------------------------------------
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+const version = packageJson.version;
+// ---------------------------------------------------------------------------
+// Bootstrap
+// ---------------------------------------------------------------------------
+async function createMcpServer() {
+    const config = await getConfig();
+    const versionHint = new VersionHintService();
+    setGlobalVersionHint(versionHint);
+    const client = new MantisClient(config.baseUrl, config.apiKey, (response) => versionHint.onSuccessfulResponse(response));
+    const cache = new MetadataCache(config.cacheDir, config.cacheTtl);
+    const server = new McpServer({
+        name: 'mantisbt-mcp-server',
+        version,
+    });
+    registerIssueTools(server, client);
+    registerNoteTools(server, client);
+    registerFileTools(server, client);
+    registerRelationshipTools(server, client);
+    registerMonitorTools(server, client);
+    registerProjectTools(server, client);
+    registerUserTools(server, client);
+    registerFilterTools(server, client);
+    registerConfigTools(server, client);
+    registerMetadataTools(server, client, cache);
+    registerTagTools(server, client);
+    registerVersionTools(server, client, versionHint);
+    return server;
+}
+// ---------------------------------------------------------------------------
+// Transport: stdio (default) or HTTP
+// ---------------------------------------------------------------------------
+async function runStdio() {
+    const server = await createMcpServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`MantisBT MCP Server v${version} running (stdio)`);
+}
+async function runHttp() {
+    const server = await createMcpServer();
+    const port = parseInt(process.env.PORT ?? '3000', 10);
+    const httpServer = createServer(async (req, res) => {
+        if (req.method === 'POST' && req.url === '/mcp') {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', async () => {
+                try {
+                    const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                    const transport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: undefined,
+                        enableJsonResponse: true,
+                    });
+                    res.on('close', () => transport.close());
+                    await server.connect(transport);
+                    await transport.handleRequest(req, res, body);
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Bad Request' }));
+                }
+            });
+        }
+        else if (req.method === 'GET' && req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', server: 'mantisbt-mcp-server', version }));
+        }
+        else {
+            res.writeHead(404);
+            res.end();
+        }
+    });
+    httpServer.listen(port, () => {
+        console.error(`MantisBT MCP Server v${version} running on http://localhost:${port}/mcp`);
+    });
+}
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+const transport = process.env.TRANSPORT ?? 'stdio';
+if (transport === 'http') {
+    runHttp().catch((err) => {
+        console.error('Server startup error:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}
+else {
+    runStdio().catch((err) => {
+        console.error('Server startup error:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}

package/dist/tools/config.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { getVersionHint } from '../version-hint.js';
+function errorText(msg) {
+    const vh = getVersionHint();
+    vh?.triggerLatestVersionFetch();
+    const hint = vh?.getUpdateHint();
+    return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
+}
+export function registerConfigTools(server, client) {
+    // ---------------------------------------------------------------------------
+    // get_config
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_config', {
+        title: 'Get MantisBT Configuration',
+        description: `Retrieve one or more MantisBT configuration options.
+
+Common option names:
+- "status_enum_string" — issue status values and their IDs
+- "priority_enum_string" — priority values
+- "severity_enum_string" — severity values
+- "resolution_enum_string" — resolution values
+- "reproducibility_enum_string" — reproducibility values
+- "view_state_enum_string" — view state values
+- "access_levels_enum_string" — access level values`,
+        inputSchema: z.object({
+            options: z.array(z.string()).min(1).describe('Array of configuration option names to retrieve'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ options }) => {
+        try {
+            const params = {};
+            options.forEach((opt, i) => {
+                params[`option[${i}]`] = opt;
+            });
+            const result = await client.get('config', params);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // list_languages
+    // ---------------------------------------------------------------------------
+    server.registerTool('list_languages', {
+        title: 'List Supported Languages',
+        description: 'List all languages supported by the MantisBT installation.',
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async () => {
+        try {
+            const result = await client.get('lang');
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // list_tags
+    // ---------------------------------------------------------------------------
+    server.registerTool('list_tags', {
+        title: 'List Tags',
+        description: `List all tags defined in the MantisBT installation.
+
+Note: The GET /tags endpoint is not available in MantisBT 2.25 and earlier.
+If your MantisBT version does not support this endpoint, you will receive an error.
+In that case, use get_issue to read the tags of a specific issue instead.`,
+        inputSchema: z.object({
+            page: z.number().int().positive().default(1).describe('Page number (default: 1)'),
+            page_size: z.number().int().min(1).max(200).default(50).describe('Tags per page (default: 50)'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ page, page_size }) => {
+        try {
+            const result = await client.get('tags', { page, page_size });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            const hint = msg.includes('404')
+                ? `${msg}\n\nThe GET /tags endpoint is not supported by this MantisBT version. Use get_issue to read tags of a specific issue instead.`
+                : msg;
+            return { content: [{ type: 'text', text: `Error: ${hint}` }], isError: true };
+        }
+    });
+}

package/dist/tools/files.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { getVersionHint } from '../version-hint.js';
+function errorText(msg) {
+    const vh = getVersionHint();
+    vh?.triggerLatestVersionFetch();
+    const hint = vh?.getUpdateHint();
+    return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
+}
+export function registerFileTools(server, client) {
+    // ---------------------------------------------------------------------------
+    // list_issue_files
+    // ---------------------------------------------------------------------------
+    server.registerTool('list_issue_files', {
+        title: 'List Issue File Attachments',
+        description: 'List all file attachments of a MantisBT issue.',
+        inputSchema: z.object({
+            issue_id: z.number().int().positive().describe('Numeric issue ID'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ issue_id }) => {
+        try {
+            const result = await client.get(`issues/${issue_id}`);
+            const attachments = result.issues?.[0]?.attachments ?? [];
+            return {
+                content: [{ type: 'text', text: JSON.stringify(attachments, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+}

package/dist/tools/filters.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { getVersionHint } from '../version-hint.js';
+function errorText(msg) {
+    const vh = getVersionHint();
+    vh?.triggerLatestVersionFetch();
+    const hint = vh?.getUpdateHint();
+    return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
+}
+export function registerFilterTools(server, client) {
+    // ---------------------------------------------------------------------------
+    // list_filters
+    // ---------------------------------------------------------------------------
+    server.registerTool('list_filters', {
+        title: 'List Saved Filters',
+        description: 'List all saved MantisBT issue filters accessible to the current user. Filter IDs can be used with list_issues.',
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async () => {
+        try {
+            const result = await client.get('filters');
+            const filters = Array.isArray(result) ? result : result.filters ?? result;
+            return {
+                content: [{ type: 'text', text: JSON.stringify(filters, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+}

package/dist/tools/issues.js

@@ -0,0 +1,191 @@
+import { z } from 'zod';
+import { getVersionHint } from '../version-hint.js';
+function errorText(msg) {
+    const vh = getVersionHint();
+    vh?.triggerLatestVersionFetch();
+    const hint = vh?.getUpdateHint();
+    return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
+}
+export function registerIssueTools(server, client) {
+    // ---------------------------------------------------------------------------
+    // get_issue
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_issue', {
+        title: 'Get Issue',
+        description: 'Retrieve a single MantisBT issue by its numeric ID. Returns all issue fields including notes, attachments, and relationships.',
+        inputSchema: z.object({
+            id: z.number().int().positive().describe('Numeric issue ID'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ id }) => {
+        try {
+            const result = await client.get(`issues/${id}`);
+            const issue = result.issues?.[0] ?? result;
+            return {
+                content: [{ type: 'text', text: JSON.stringify(issue, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // list_issues
+    // ---------------------------------------------------------------------------
+    server.registerTool('list_issues', {
+        title: 'List Issues',
+        description: 'List MantisBT issues with optional filtering. Returns a paginated list of issues.',
+        inputSchema: z.object({
+            project_id: z.number().int().positive().optional().describe('Filter by project ID'),
+            page: z.number().int().positive().default(1).describe('Page number (default: 1)'),
+            page_size: z.number().int().min(1).max(50).default(50).describe('Issues per page (default: 50, max: 50)'),
+            assigned_to: z.number().int().positive().optional().describe('Filter by handler/assignee user ID'),
+            reporter_id: z.number().int().positive().optional().describe('Filter by reporter user ID'),
+            filter_id: z.number().int().positive().optional().describe('Use a saved MantisBT filter ID'),
+            sort: z.string().optional().describe('Sort field (e.g. "last_updated", "id")'),
+            direction: z.enum(['ASC', 'DESC']).optional().describe('Sort direction'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ project_id, page, page_size, assigned_to, reporter_id, filter_id, sort, direction }) => {
+        try {
+            const params = {
+                page,
+                page_size,
+                project_id,
+                assigned_to,
+                reporter_id,
+                filter_id,
+                sort,
+                direction,
+            };
+            const result = await client.get('issues', params);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // create_issue
+    // ---------------------------------------------------------------------------
+    server.registerTool('create_issue', {
+        title: 'Create Issue',
+        description: 'Create a new MantisBT issue. Returns the created issue including its assigned ID.',
+        inputSchema: z.object({
+            summary: z.string().min(1).describe('Issue summary/title'),
+            description: z.string().default('').describe('Detailed issue description'),
+            project_id: z.number().int().positive().describe('Project ID the issue belongs to'),
+            category: z.string().min(1).describe('Category name (use get_project_categories to list available categories)'),
+            priority: z.string().optional().describe('Priority name (e.g. "normal", "high", "urgent", "immediate", "low", "none")'),
+            severity: z.string().optional().describe('Severity name (e.g. "minor", "major", "crash", "block", "feature", "trivial", "text")'),
+            handler_id: z.number().int().positive().optional().describe('User ID of the person to assign the issue to'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ summary, description, project_id, category, priority, severity, handler_id }) => {
+        try {
+            const body = {
+                summary,
+                description,
+                project: { id: project_id },
+                category: { name: category },
+            };
+            if (priority)
+                body.priority = { name: priority };
+            if (severity)
+                body.severity = { name: severity };
+            if (handler_id)
+                body.handler = { id: handler_id };
+            const result = await client.post('issues', body);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.issue ?? result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // update_issue
+    // ---------------------------------------------------------------------------
+    server.registerTool('update_issue', {
+        title: 'Update Issue',
+        description: `Update one or more fields of an existing MantisBT issue using a partial PATCH.
+
+The "fields" object accepts any combination of:
+- summary (string)
+- description (string)
+- status: { name: "new"|"feedback"|"acknowledged"|"confirmed"|"assigned"|"resolved"|"closed" }
+- resolution: { id: 20 }  (20 = fixed/resolved)
+- handler: { id: <user_id> } or { name: "<username>" }
+- priority: { name: "<priority_name>" }
+- severity: { name: "<severity_name>" }
+- category: { name: "<category_name>" }
+- target_version: { name: "<version_name>" }
+- fixed_in_version: { name: "<version_name>" }
+
+Important: when resolving an issue, always set BOTH status and resolution to avoid leaving resolution as "open".`,
+        inputSchema: z.object({
+            id: z.number().int().positive().describe('Numeric issue ID to update'),
+            fields: z.record(z.unknown()).describe('Object containing the fields to update (partial update — only provided fields are changed)'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ id, fields }) => {
+        try {
+            const result = await client.patch(`issues/${id}`, fields);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.issue ?? result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // delete_issue
+    // ---------------------------------------------------------------------------
+    server.registerTool('delete_issue', {
+        title: 'Delete Issue',
+        description: 'Permanently delete a MantisBT issue. This action is irreversible.',
+        inputSchema: z.object({
+            id: z.number().int().positive().describe('Numeric issue ID to delete'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+        },
+    }, async ({ id }) => {
+        try {
+            await client.delete(`issues/${id}`);
+            return {
+                content: [{ type: 'text', text: `Issue #${id} deleted successfully.` }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+}

package/dist/tools/metadata.js

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import { getVersionHint } from '../version-hint.js';
+function errorText(msg) {
+    const vh = getVersionHint();
+    vh?.triggerLatestVersionFetch();
+    const hint = vh?.getUpdateHint();
+    return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
+}
+async function fetchAndCacheMetadata(client, cache) {
+    // Fetch all projects
+    const projectResult = await client.get('projects');
+    const projects = projectResult.projects ?? [];
+    const byProject = {};
+    // For each project, fetch users, versions, categories in parallel
+    await Promise.all(projects.map(async (project) => {
+        const [usersResult, versionsResult, categoriesResult] = await Promise.allSettled([
+            client.get(`projects/${project.id}/users`),
+            client.get(`projects/${project.id}/versions`),
+            client.get(`projects/${project.id}/categories`),
+        ]);
+        const users = usersResult.status === 'fulfilled'
+            ? (usersResult.value.users ?? [])
+            : [];
+        const versions = versionsResult.status === 'fulfilled'
+            ? (versionsResult.value.versions ?? [])
+            : [];
+        const ALL_PROJECTS_PREFIX = '[All Projects] ';
+        const rawCategories = categoriesResult.status === 'fulfilled'
+            ? (categoriesResult.value.categories ?? categoriesResult.value)
+            : [];
+        const categories = Array.isArray(rawCategories)
+            ? rawCategories.map((cat) => ({
+                ...cat,
+                name: cat.name.startsWith(ALL_PROJECTS_PREFIX)
+                    ? cat.name.slice(ALL_PROJECTS_PREFIX.length)
+                    : cat.name,
+            }))
+            : rawCategories;
+        byProject[project.id] = { users, versions, categories };
+    }));
+    const data = {
+        timestamp: Date.now(),
+        projects,
+        byProject,
+    };
+    await cache.save(data);
+    return data;
+}
+export function registerMetadataTools(server, client, cache) {
+    // ---------------------------------------------------------------------------
+    // sync_metadata
+    // ---------------------------------------------------------------------------
+    server.registerTool('sync_metadata', {
+        title: 'Sync Metadata Cache',
+        description: `Fetch all projects and their associated users, versions, and categories from MantisBT and store them in the local metadata cache.
+
+This is useful for getting a complete overview of your MantisBT installation.
+The cache is valid for 1 hour by default (configurable via MANTIS_CACHE_TTL env var).
+Use this tool to refresh stale data.`,
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+    }, async () => {
+        try {
+            const data = await fetchAndCacheMetadata(client, cache);
+            const projectCount = data.projects.length;
+            const summary = data.projects.map((p) => {
+                const meta = data.byProject[p.id];
+                return `  - ${p.name} (ID ${p.id}): ${meta?.users.length ?? 0} users, ${meta?.versions.length ?? 0} versions, ${meta?.categories.length ?? 0} categories`;
+            }).join('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Metadata synced successfully.\n\n${projectCount} project(s):\n${summary}`,
+                    }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // get_metadata
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_metadata', {
+        title: 'Get Cached Metadata',
+        description: `Return cached MantisBT metadata (projects, users, versions, categories).
+
+If the cache does not exist or has expired (default TTL: 24 hours), it will automatically sync first.
+Use sync_metadata to force a refresh.`,
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async () => {
+        try {
+            let data = null;
+            if (await cache.isValid()) {
+                data = await cache.load();
+            }
+            if (!data) {
+                data = await fetchAndCacheMetadata(client, cache);
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+}

package/dist/tools/monitors.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { getVersionHint } from '../version-hint.js';
+function errorText(msg) {
+    const vh = getVersionHint();
+    vh?.triggerLatestVersionFetch();
+    const hint = vh?.getUpdateHint();
+    return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
+}
+export function registerMonitorTools(server, client) {
+    // ---------------------------------------------------------------------------
+    // add_monitor
+    // ---------------------------------------------------------------------------
+    server.registerTool('add_monitor', {
+        title: 'Add Issue Monitor',
+        description: 'Add a user as a monitor (watcher) of a MantisBT issue. Monitors receive email notifications for issue updates.',
+        inputSchema: z.object({
+            issue_id: z.number().int().positive().describe('Numeric issue ID'),
+            username: z.string().min(1).describe('Username of the user to add as monitor'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ issue_id, username }) => {
+        try {
+            const body = { name: username };
+            const result = await client.post(`issues/${issue_id}/monitors`, body);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result ?? { success: true }, null, 2) }],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+}