@dpesch/mantisbt-mcp-server 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.3.0] – 2026-03-16
+
+### Added
+- New tool `get_search_index_status`: returns the current fill level of the semantic search index — how many issues are indexed vs. total, plus the timestamp of the last sync. Only active when `MANTIS_SEARCH_ENABLED=true`.
+- New tool `get_issue_enums`: returns structured ID/name pairs for all issue enum fields (severity, status, priority, resolution, reproducibility) — ready for direct use in `create_issue` / `update_issue` without requiring knowledge of MantisBT-internal config option names.
+- `sync_metadata` now fetches and caches all tags globally (`tags` field at root level of the cached metadata). When the dedicated `GET /tags` endpoint is unavailable (MantisBT < 2.26), tags are collected by scanning all issues across all projects (`select=id,tags`).
+- New tool `get_mcp_version`: returns the version of the running mantisbt-mcp-server instance.
+
+### Fixed
+- `list_tags` now falls back to the metadata cache when `GET /tags` returns 404 instead of returning an error. Run `sync_metadata` first to populate the cache.
+- Numeric ID parameters now accept string inputs (e.g. `"1940"`) — MCP clients that pass IDs as strings no longer receive error -32602.
+- `create_issue` now always sends a `severity` to MantisBT (default: `"minor"`). Previously omitting severity caused MantisBT to store `0`, which was displayed as `@0@`.
+- `get_search_index_status` now correctly reports the total issue count on MantisBT installations that do not return `total_count` in the issues list API. The total is persisted after every sync: `total_count` from the API takes precedence, otherwise the current store size is used as a best-effort estimate. The status tool will therefore no longer show "total unknown" after any sync has completed.
+- `sync_metadata` tags endpoint failure now degrades gracefully to an empty array instead of propagating an error.
+- `sync_metadata` now correctly populates `byProject[id].categories`.
+- `sync_metadata` now fetches all versions including obsolete and inherited ones (`obsolete=1&inherit=1`). Previously only non-obsolete versions were returned, causing the version count in the cache to be far too low.
+- `get_project_versions` now accepts optional `obsolete` and `inherit` boolean parameters to include obsolete and/or inherited versions (both default to `false`). Previously the wrong endpoint (`projects/{id}/categories`) was called, which returned an empty array on many installations. Categories are now read from the project detail response (`projects/{id}`), identical to the source used by `get_project_categories`.
+
+---
+
 ## [1.2.0] – 2026-03-16
 
 ### Added

package/README.de.md

@@ -130,7 +130,7 @@ Falls keine Umgebungsvariablen gesetzt sind, wird `~/.claude/mantis.json` ausgel
 
 | Tool | Beschreibung |
 |---|---|
-| `list_tags` | Alle verfügbaren Tags auflisten |
+| `list_tags` | Alle verfügbaren Tags auflisten; greift auf den Metadaten-Cache zurück, wenn `GET /tags` mit 404 antwortet (vorher `sync_metadata` ausführen) |
 | `attach_tags` | Tags an ein Issue hängen |
 | `detach_tag` | Tag von einem Issue entfernen |
 
@@ -139,20 +139,39 @@ Falls keine Umgebungsvariablen gesetzt sind, wird `~/.claude/mantis.json` ausgel
 | Tool | Beschreibung |
 |---|---|
 | `list_projects` | Alle zugänglichen Projekte auflisten |
-| `get_project_versions` | Versionen eines Projekts abrufen |
+| `get_project_versions` | Versionen eines Projekts abrufen; optionale Booleans `obsolete` und `inherit` für veraltete bzw. vom Elternprojekt geerbte Versionen |
 | `get_project_categories` | Kategorien eines Projekts abrufen |
 | `get_project_users` | Benutzer eines Projekts abrufen |
 
 ### Semantische Suche *(optional)*
 
-Aktivierung mit `MANTIS_SEARCH_ENABLED=true`. Beim ersten Start wird das Embedding-Modell (~80 MB) heruntergeladen und lokal gecacht. Alle Issues werden danach bei jedem Serverstart inkrementell indexiert.
+Statt einfachem Keyword-Matching versteht die semantische Suche die *Bedeutung* einer Anfrage. Formuliere in natürlicher Sprache — die Suche findet konzeptuell verwandte Issues, auch wenn die genauen Begriffe nicht übereinstimmen:
+
+- *„Login funktioniert nach Passwort-Reset nicht"* — findet Issues rund um Authentifizierungsgrenzfälle
+- *„Performance-Probleme auf der Checkout-Seite"* — liefert verwandte Meldungen unabhängig von der verwendeten Terminologie
+- *„doppelte Einträge in der Rechnungsliste"* — erkennt auch Issues, die als „zweifach angezeigt", „dupliziert" o.ä. beschrieben sind
+
+Das Embedding-Modell (~80 MB) läuft vollständig **offline** — kein OpenAI-Key, keine externe API. Es wird beim ersten Start einmalig heruntergeladen und lokal gecacht. Issues werden bei jedem Serverstart inkrementell indexiert (nur neue und geänderte Issues werden neu verarbeitet).
+
+Aktivierung mit `MANTIS_SEARCH_ENABLED=true`.
 
 | Tool | Beschreibung |
 |---|---|
 | `search_issues` | Natürlichsprachige Suche über alle indizierten Issues – liefert Top-N-Ergebnisse mit Cosine-Similarity-Score |
 | `rebuild_search_index` | Suchindex aufbauen oder aktualisieren; `full: true` löscht und baut ihn vollständig neu |
+| `get_search_index_status` | Aktuellen Füllstand des Suchindex zurückgeben: wie viele Issues bereits indiziert sind im Verhältnis zur Gesamtanzahl, plus Zeitstempel der letzten Synchronisation |
+
+#### Welches Backend wählen?
+
+| | `vectra` *(Standard)* | `sqlite-vec` |
+|---|---|---|
+| Abhängigkeiten | Keine (reines JS) | Benötigt native Build-Tools |
+| Installation | Enthalten | `npm install sqlite-vec better-sqlite3` |
+| Geeignet für | Bis ~10.000 Issues | Ab 10.000 Issues |
+| Performance | Für die meisten Instanzen ausreichend | Schneller bei großen Datenmengen |
+
+Mit `vectra` starten. Zu `sqlite-vec` wechseln, wenn Indexierungszeiten oder Abfragen spürbar langsam werden.
 
-**`sqlite-vec`-Backend** (optional, schneller bei großen Instanzen):
 ```bash
 npm install sqlite-vec better-sqlite3
 # dann MANTIS_SEARCH_BACKEND=sqlite-vec setzen
@@ -169,7 +188,9 @@ npm install sqlite-vec better-sqlite3
 | `get_current_user` | Eigenes Benutzerprofil abrufen |
 | `list_languages` | Verfügbare Sprachen auflisten |
 | `get_config` | Server-Konfiguration (Basis-URL, Cache-TTL) anzeigen |
+| `get_issue_enums` | Gültige ID/Name-Paare für alle Enum-Felder zurückgeben (Severity, Status, Priority, Resolution, Reproducibility) — vor `create_issue` / `update_issue` verwenden, um korrekte Werte nachzuschlagen |
 | `get_mantis_version` | MantisBT-Version abrufen und auf Updates prüfen |
+| `get_mcp_version` | Version dieser mantisbt-mcp-server-Instanz zurückgeben |
 
 ## HTTP-Modus
 

package/README.md

@@ -130,7 +130,7 @@ If no environment variables are set, `~/.claude/mantis.json` is read:
 
 | Tool | Description |
 |---|---|
-| `list_tags` | List all available tags |
+| `list_tags` | List all available tags; falls back to the metadata cache when `GET /tags` returns 404 (run `sync_metadata` first to populate) |
 | `attach_tags` | Attach tags to an issue |
 | `detach_tag` | Remove a tag from an issue |
 
@@ -139,20 +139,39 @@ If no environment variables are set, `~/.claude/mantis.json` is read:
 | Tool | Description |
 |---|---|
 | `list_projects` | List all accessible projects |
-| `get_project_versions` | Get versions of a project |
+| `get_project_versions` | Get versions of a project; optional `obsolete` and `inherit` booleans to include obsolete or parent-inherited versions |
 | `get_project_categories` | Get categories of a project |
 | `get_project_users` | Get users of a project |
 
 ### Semantic search *(optional)*
 
-Activate with `MANTIS_SEARCH_ENABLED=true`. On first start the embedding model (~80 MB) is downloaded and cached locally. All issues are then indexed incrementally on each server start.
+Instead of exact keyword matching, semantic search understands the *meaning* behind a query. Ask in plain language — the search engine finds conceptually related issues even when the wording doesn't match:
+
+- *"login fails after password reset"* — finds issues about authentication edge cases
+- *"performance problems on the checkout page"* — surfaces related reports regardless of the exact terminology used
+- *"duplicate entries in the invoice list"* — catches issues described as "shown twice", "double records", etc.
+
+The embedding model (~80 MB) runs entirely **offline** — no OpenAI key, no external API. It is downloaded once on first start and cached locally. Issues are indexed incrementally on every server start (only new and updated issues are re-indexed).
+
+Activate with `MANTIS_SEARCH_ENABLED=true`.
 
 | Tool | Description |
 |---|---|
 | `search_issues` | Natural language search over all indexed issues — returns top-N results with cosine similarity score |
 | `rebuild_search_index` | Build or update the search index; `full: true` clears and rebuilds from scratch |
+| `get_search_index_status` | Return the current fill level of the search index: how many issues are indexed vs. total, and the timestamp of the last sync |
+
+#### Which backend to choose?
+
+| | `vectra` *(default)* | `sqlite-vec` |
+|---|---|---|
+| Dependencies | None (pure JS) | Requires native build tools |
+| Install | Included | `npm install sqlite-vec better-sqlite3` |
+| Best for | Up to ~10,000 issues | 10,000+ issues |
+| Performance | Fast enough for most setups | Faster for large corpora |
+
+Start with `vectra`. Switch to `sqlite-vec` if indexing or query times become noticeably slow.
 
-**`sqlite-vec` backend** (optional, faster for large instances):
 ```bash
 npm install sqlite-vec better-sqlite3
 # then set MANTIS_SEARCH_BACKEND=sqlite-vec
@@ -169,7 +188,9 @@ npm install sqlite-vec better-sqlite3
 | `get_current_user` | Retrieve your own user profile |
 | `list_languages` | List available languages |
 | `get_config` | Show server configuration (base URL, cache TTL) |
+| `get_issue_enums` | Return valid ID/name pairs for all issue enum fields (severity, status, priority, resolution, reproducibility) — use before `create_issue` / `update_issue` to look up correct values |
 | `get_mantis_version` | Get MantisBT version and check for updates |
+| `get_mcp_version` | Return the version of this mantisbt-mcp-server instance |
 
 ## HTTP mode
 

package/dist/index.js

@@ -50,10 +50,10 @@ async function createMcpServer() {
     registerProjectTools(server, client);
     registerUserTools(server, client);
     registerFilterTools(server, client);
-    registerConfigTools(server, client);
+    registerConfigTools(server, client, cache);
     registerMetadataTools(server, client, cache);
     registerTagTools(server, client);
-    registerVersionTools(server, client, versionHint);
+    registerVersionTools(server, client, versionHint, version);
     // Optional: Semantic search module
     if (config.search.enabled) {
         const { initializeSearchModule } = await import('./search/index.js');

package/dist/search/index.js

@@ -11,6 +11,12 @@ export async function initializeSearchModule(server, client, config) {
     const store = createVectorStore(config.backend, config.dir);
     const embedder = new Embedder(config.modelName);
     registerSearchTools(server, client, store, embedder);
+    // Pre-initialize lastKnownTotal so get_search_index_status shows a value
+    // immediately on startup, even while the background sync is still running.
+    const [startupCount, startupTotal] = await Promise.all([store.count(), store.getLastKnownTotal()]);
+    if (startupTotal === null && startupCount > 0) {
+        await store.setLastKnownTotal(startupCount);
+    }
     // Non-blocking background sync on startup
     const syncService = new SearchSyncService(client, store, embedder);
     syncService.sync().catch((err) => {

package/dist/search/store.js

@@ -7,12 +7,14 @@ export class VectraStore {
     dir;
     vectraDir;
     lastSyncFile;
+    lastTotalFile;
     items = new Map();
     loaded = false;
     constructor(dir) {
         this.dir = dir;
         this.vectraDir = join(dir, 'vectra');
         this.lastSyncFile = join(dir, 'last_sync.txt');
+        this.lastTotalFile = join(dir, 'last_total.txt');
     }
     async ensureLoaded() {
         if (this.loaded)
@@ -93,6 +95,20 @@ export class VectraStore {
                 throw err;
         }
     }
+    async getLastKnownTotal() {
+        try {
+            const content = await readFile(this.lastTotalFile, 'utf-8');
+            const parsed = parseInt(content.trim(), 10);
+            return isNaN(parsed) ? null : parsed;
+        }
+        catch {
+            return null;
+        }
+    }
+    async setLastKnownTotal(total) {
+        await mkdir(this.dir, { recursive: true });
+        await writeFile(this.lastTotalFile, String(total), 'utf-8');
+    }
 }
 // ---------------------------------------------------------------------------
 // Cosine similarity helper

package/dist/search/sync.js

@@ -14,7 +14,7 @@ export class SearchSyncService {
     }
     async sync(projectId) {
         const lastSyncedAt = await this.store.getLastSyncedAt();
-        const allIssues = await this.fetchAllIssues(lastSyncedAt ?? undefined, projectId);
+        const { issues: allIssues, totalFromApi } = await this.fetchAllIssues(lastSyncedAt ?? undefined, projectId);
         let indexed = 0;
         let skipped = 0;
         // Process in batches of EMBED_BATCH_SIZE
@@ -45,10 +45,19 @@ export class SearchSyncService {
             indexed += batchItems.length;
         }
         await this.store.setLastSyncedAt(new Date().toISOString());
-        return { indexed, skipped };
+        // Persist the best known total for get_search_index_status.
+        // Priority: API total_count > full-rebuild count > current store size.
+        // The store size fallback handles MantisBT installations that never return
+        // total_count and ensures the status tool never shows "total unknown" after
+        // any sync has completed.
+        const storeCount = await this.store.count();
+        const total = totalFromApi ?? (lastSyncedAt === null ? indexed + skipped : storeCount);
+        await this.store.setLastKnownTotal(total);
+        return { indexed, skipped, total };
     }
     async fetchAllIssues(updatedAfter, projectId) {
         const allIssues = [];
+        let totalFromApi = null;
         let page = 1;
         while (true) {
             const params = {
@@ -67,12 +76,15 @@ export class SearchSyncService {
             const response = await this.client.get('issues', params);
             const pageIssues = response.issues ?? [];
             allIssues.push(...pageIssues);
+            // Capture total_count from the first page that provides it
+            if (totalFromApi === null && response.total_count != null) {
+                totalFromApi = response.total_count;
+            }
             // Stop when we have fetched all issues:
             // - total_count is provided and reached, or
             // - page returned fewer items than requested (last page)
-            const total = response.total_count;
-            if (total !== undefined && total !== null) {
-                if (allIssues.length >= total)
+            if (totalFromApi !== null) {
+                if (allIssues.length >= totalFromApi)
                     break;
             }
             else if (pageIssues.length < PAGE_SIZE) {
@@ -80,6 +92,6 @@ export class SearchSyncService {
             }
             page++;
         }
-        return allIssues;
+        return { issues: allIssues, totalFromApi };
     }
 }

package/dist/search/tools.js

@@ -1,5 +1,12 @@
 import { z } from 'zod';
 import { SearchSyncService } from './sync.js';
+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}`;
+}
 // ---------------------------------------------------------------------------
 // registerSearchTools
 // ---------------------------------------------------------------------------
@@ -14,7 +21,7 @@ export function registerSearchTools(server, client, store, embedder) {
         inputSchema: z.object({
             query: z.string().describe('Natural language search query'),
             top_n: z
-                .number()
+                .coerce.number()
                 .int()
                 .positive()
                 .max(50)
@@ -48,7 +55,47 @@ export function registerSearchTools(server, client, store, embedder) {
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // get_search_index_status
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_search_index_status', {
+        title: 'Search Index Status',
+        description: 'Returns the current fill level of the semantic search index: how many issues are ' +
+            'indexed vs. the total number of issues in MantisBT, plus the timestamp of the last sync.',
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async () => {
+        try {
+            const [indexed, lastSyncedAt, total] = await Promise.all([
+                store.count(),
+                store.getLastSyncedAt(),
+                store.getLastKnownTotal(),
+            ]);
+            const percent = total !== null
+                ? (total > 0 ? Math.round((indexed / total) * 100) : 0)
+                : null;
+            const summary = total !== null
+                ? `${indexed}/${total} (${percent} %)`
+                : `${indexed}/? (total unknown)`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ summary, indexed, total, percent, last_synced_at: lastSyncedAt }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
         }
     });
     // ---------------------------------------------------------------------------
@@ -60,7 +107,7 @@ export function registerSearchTools(server, client, store, embedder) {
             'Use full: true to clear the existing index and rebuild from scratch.',
         inputSchema: z.object({
             project_id: z
-                .number()
+                .coerce.number()
                 .int()
                 .positive()
                 .optional()
@@ -83,20 +130,20 @@ export function registerSearchTools(server, client, store, embedder) {
             }
             const startMs = Date.now();
             const syncService = new SearchSyncService(client, store, embedder);
-            const { indexed, skipped } = await syncService.sync(project_id);
+            const { indexed, skipped, total } = await syncService.sync(project_id);
             const duration_ms = Date.now() - startMs;
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({ indexed, skipped, duration_ms }, null, 2),
+                        text: JSON.stringify({ indexed, skipped, total, duration_ms }, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
         }
     });
 }

package/dist/tools/config.js

@@ -6,7 +6,21 @@ function errorText(msg) {
     const hint = vh?.getUpdateHint();
     return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
 }
-export function registerConfigTools(server, client) {
+// Parse a MantisBT enum string ("10:feature,20:trivial,...") into {id, name}[]
+function parseEnumString(raw) {
+    return raw
+        .split(',')
+        .map((entry) => {
+        const colonIdx = entry.indexOf(':');
+        if (colonIdx === -1)
+            return null;
+        const id = parseInt(entry.slice(0, colonIdx), 10);
+        const name = entry.slice(colonIdx + 1).trim();
+        return isNaN(id) ? null : { id, name };
+    })
+        .filter((e) => e !== null);
+}
+export function registerConfigTools(server, client, cache) {
     // ---------------------------------------------------------------------------
     // get_config
     // ---------------------------------------------------------------------------
@@ -47,6 +61,70 @@ Common option names:
         }
     });
     // ---------------------------------------------------------------------------
+    // get_issue_enums
+    // ---------------------------------------------------------------------------
+    server.registerTool('get_issue_enums', {
+        title: 'Get Issue Enum Values',
+        description: `Return valid ID and name pairs for all issue enum fields.
+
+Use this tool before creating or updating issues to look up the correct value
+for severity, status, priority, resolution, or reproducibility.
+
+Example response:
+{
+  "severity":         [{"id": 10, "name": "feature"}, {"id": 50, "name": "minor"}, ...],
+  "status":           [{"id": 10, "name": "new"}, {"id": 20, "name": "feedback"}, ...],
+  "priority":         [{"id": 10, "name": "none"}, {"id": 30, "name": "normal"}, ...],
+  "resolution":       [{"id": 10, "name": "open"}, {"id": 20, "name": "fixed"}, ...],
+  "reproducibility":  [{"id": 10, "name": "always"}, {"id": 70, "name": "have not tried"}, ...]
+}
+
+The "name" field is the value to pass to create_issue or update_issue.`,
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async () => {
+        try {
+            const enumOptions = [
+                'severity_enum_string',
+                'status_enum_string',
+                'priority_enum_string',
+                'resolution_enum_string',
+                'reproducibility_enum_string',
+            ];
+            const params = {};
+            enumOptions.forEach((opt, i) => {
+                params[`option[${i}]`] = opt;
+            });
+            const result = await client.get('config', params);
+            const configs = result.configs ?? [];
+            const keyMap = {
+                severity_enum_string: 'severity',
+                status_enum_string: 'status',
+                priority_enum_string: 'priority',
+                resolution_enum_string: 'resolution',
+                reproducibility_enum_string: 'reproducibility',
+            };
+            const enums = {};
+            for (const { option, value } of configs) {
+                const key = keyMap[option];
+                if (key && typeof value === 'string') {
+                    enums[key] = parseEnumString(value);
+                }
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(enums, 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', {
@@ -77,12 +155,12 @@ Common option names:
         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.`,
+The MantisBT REST API exposes a GET /tags endpoint on some installations.
+If that endpoint is not available, this tool falls back to the local metadata
+cache populated by sync_metadata.`,
         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)'),
+            page: z.coerce.number().int().positive().default(1).describe('Page number (default: 1)'),
+            page_size: z.coerce.number().int().min(1).max(200).default(50).describe('Tags per page (default: 50)'),
         }),
         annotations: {
             readOnlyHint: true,
@@ -98,10 +176,28 @@ In that case, use get_issue to read the tags of a specific issue instead.`,
         }
         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 };
+            if (msg.includes('404')) {
+                // GET /tags endpoint not available — fall back to metadata cache
+                const metadata = await cache.load();
+                if (metadata && Array.isArray(metadata.tags) && metadata.tags.length > 0) {
+                    const start = (page - 1) * page_size;
+                    const paginated = metadata.tags.slice(start, start + page_size);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({ tags: paginated, source: 'cache' }, null, 2),
+                            }],
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: ${msg}\n\nThe GET /tags endpoint is not available in this MantisBT installation. No cached tags found either — run sync_metadata to populate the cache if your installation provides this endpoint.`,
+                        }],
+                    isError: true,
+                };
+            }
+            return { content: [{ type: 'text', text: errorText(msg) }], isError: true };
         }
     });
 }

package/dist/tools/files.js

@@ -16,7 +16,7 @@ export function registerFileTools(server, client) {
         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'),
+            issue_id: z.coerce.number().int().positive().describe('Numeric issue ID'),
         }),
         annotations: {
             readOnlyHint: true,
@@ -49,7 +49,7 @@ Two input modes (exactly one must be provided):
 
 The optional content_type parameter sets the MIME type (e.g. "image/png"). If omitted, "application/octet-stream" is used.`,
         inputSchema: z.object({
-            issue_id: z.number().int().positive().describe('Numeric issue ID'),
+            issue_id: z.coerce.number().int().positive().describe('Numeric issue ID'),
             file_path: z.string().min(1).optional().describe('Absolute path to the local file to upload (mutually exclusive with content)'),
             content: z.string().min(1).optional().describe('Base64-encoded file content (mutually exclusive with file_path)'),
             filename: z.string().min(1).optional().describe('File name for the attachment (required when using content; overrides the derived name when using file_path)'),

package/dist/tools/issues.js

@@ -15,7 +15,7 @@ export function registerIssueTools(server, client) {
         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'),
+            id: z.coerce.number().int().positive().describe('Numeric issue ID'),
         }),
         annotations: {
             readOnlyHint: true,
@@ -42,12 +42,12 @@ export function registerIssueTools(server, client) {
         title: 'List Issues',
         description: 'List MantisBT issues with optional filtering. Returns a paginated list of issues. Use the "select" parameter to limit returned fields and reduce response size significantly.',
         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'),
+            project_id: z.coerce.number().int().positive().optional().describe('Filter by project ID'),
+            page: z.coerce.number().int().positive().default(1).describe('Page number (default: 1)'),
+            page_size: z.coerce.number().int().min(1).max(50).default(50).describe('Issues per page (default: 50, max: 50)'),
+            assigned_to: z.coerce.number().int().positive().optional().describe('Filter by handler/assignee user ID'),
+            reporter_id: z.coerce.number().int().positive().optional().describe('Filter by reporter user ID'),
+            filter_id: z.coerce.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'),
             select: z.string().optional().describe('Comma-separated list of fields to include in the response (server-side projection). Significantly reduces response size. Example: "id,summary,status,priority,handler,updated_at"'),
@@ -100,11 +100,11 @@ export function registerIssueTools(server, client) {
         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'),
+            project_id: z.coerce.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'),
+            severity: z.string().default('minor').describe('Severity name (e.g. "minor", "major", "crash", "block", "feature", "trivial", "text") — default: "minor"'),
+            handler_id: z.coerce.number().int().positive().optional().describe('User ID of the person to assign the issue to'),
         }),
         annotations: {
             readOnlyHint: false,
@@ -121,8 +121,7 @@ export function registerIssueTools(server, client) {
             };
             if (priority)
                 body.priority = { name: priority };
-            if (severity)
-                body.severity = { name: severity };
+            body.severity = { name: severity };
             if (handler_id)
                 body.handler = { id: handler_id };
             const result = await client.post('issues', body);
@@ -156,7 +155,7 @@ The "fields" object accepts any combination of:
 
 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'),
+            id: z.coerce.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: {
@@ -183,7 +182,7 @@ Important: when resolving an issue, always set BOTH status and resolution to avo
         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'),
+            id: z.coerce.number().int().positive().describe('Numeric issue ID to delete'),
         }),
         annotations: {
             readOnlyHint: false,