@dpesch/mantisbt-mcp-server 1.3.1 → 1.5.0

package/.env.local

@@ -0,0 +1,3 @@
+MANTIS_BASE_URL=https://mantis.dev.11com7.de
+MANTIS_API_KEY=3vhKDwxVavmCzRUR7Cp0Lk7F8E4dha6n
+MANTIS_SEARCH_ENABLED=true

package/CHANGELOG.md

@@ -7,6 +7,27 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.5.0] – 2026-03-17
+
+### Added
+- `create_issue`: always returns the complete issue object. Older MantisBT versions returned only `{ id: N }` on `POST /issues`; the tool now detects this and performs an automatic `GET /issues/{id}` to retrieve the full issue. If that fetch fails the minimal object is returned instead (the issue was already created).
+- `get_issue_enums`: each entry now includes an optional `canonical_name` field containing the standard English API name (e.g. `"minor"`, `"block"`) when the returned `name` differs from it. This occurs on localized MantisBT installations where enum values have been customized at the database level (e.g. `name: "kleinerer Fehler"` instead of `"minor"`). The field is omitted when `name` already matches the canonical value and for custom entries without a known canonical name. Available for all five enum groups (severity, status, priority, resolution, reproducibility).
+- `create_issue`: new optional `handler` parameter accepts a username string as alternative to `handler_id`. The server resolves the name against the project members list (from the metadata cache when available, otherwise via a direct API call). If the username is not found, an error is returned with a list of available users.
+- `add_relationship`: new optional `type_name` parameter accepts string names as alternative to the numeric `type_id` (e.g. `"related_to"`, `"duplicate_of"`, `"depends_on"`, `"blocks"`). Dash variants (`"related-to"`) are also accepted. `type_id` becomes optional — at least one of the two must be provided; `type_id` takes precedence when both are given.
+- `search_issues`: new optional `select` parameter. When provided, each matching issue is fetched from MantisBT and the response is enriched with the requested fields (comma-separated, e.g. `"id,summary,status,handler,priority"`). Without `select` the behaviour is unchanged — only `id` and `score` are returned. `id` and `score` are always included regardless of the `select` value. If an individual issue fetch fails, that result falls back silently to `{id, score}`.
+
+---
+
+## [1.4.0] – 2026-03-17
+
+### Added
+- `get_issue_enums` now includes a `label` field in each enum entry when it differs from `name`. On localized MantisBT installations (e.g. German UI) this provides a translation table from the UI language back to the API name/id: `{"id": 10, "name": "new", "label": "Neu"}`. When `label` and `name` are identical the field is omitted to keep the output compact. The tool description also clarifies that `name` may itself be localized on installations where enum values have been customized at the database level.
+
+### Fixed
+- `list_issues`: `assigned_to`, `reporter_id`, and `status` filters now reliably return matching issues regardless of the requested `page_size`. Previously, the tool fetched exactly `page_size` items from the API before filtering — so a small `page_size` combined with an active filter returned zero results if the matching issues were not at the top of the unfiltered list. The tool now internally fetches batches of 50 (API maximum) and scans up to 500 issues until enough matching results are found. All filter parameters are still forwarded to the API as a hint for installations that support server-side filtering.
+
+---
+
 ## [1.3.1] – 2026-03-16
 
 ### Fixed

package/README.de.md

@@ -93,7 +93,7 @@ Falls keine Umgebungsvariablen gesetzt sind, wird `~/.claude/mantis.json` ausgel
 |---|---|
 | `get_issue` | Ein Issue anhand seiner ID abrufen |
 | `list_issues` | Issues nach Projekt, Status, Autor u.v.m. filtern; optionales `select` für Feldprojektion und `status` für clientseitige Statusfilterung |
-| `create_issue` | Neues Issue anlegen |
+| `create_issue` | Neues Issue anlegen; optionaler `handler`-Parameter akzeptiert einen Benutzernamen als Alternative zu `handler_id` (wird gegen die Projektmitglieder aufgelöst) |
 | `update_issue` | Bestehendes Issue bearbeiten |
 | `delete_issue` | Issue löschen |
 
@@ -116,7 +116,7 @@ Falls keine Umgebungsvariablen gesetzt sind, wird `~/.claude/mantis.json` ausgel
 
 | Tool | Beschreibung |
 |---|---|
-| `add_relationship` | Beziehung zwischen zwei Issues erstellen |
+| `add_relationship` | Beziehung zwischen zwei Issues erstellen; optionaler `type_name`-Parameter akzeptiert einen String-Namen (z.B. `"related_to"`, `"duplicate_of"`) als Alternative zur numerischen `type_id` |
 | `remove_relationship` | Beziehung von einem Issue entfernen (die `id` aus dem Beziehungsobjekt verwenden, nicht die type-ID) |
 
 ### Beobachter
@@ -157,7 +157,7 @@ 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 |
+| `search_issues` | Natürlichsprachige Suche über alle indizierten Issues – liefert Top-N-Ergebnisse mit Cosine-Similarity-Score; optionales `select` (kommagetrennte Feldnamen) reichert jedes Ergebnis mit den angeforderten Issue-Feldern an |
 | `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 |
 
@@ -188,7 +188,7 @@ 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_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; auf lokalisierten Installationen kann jeder Eintrag ein `canonical_name`-Feld mit dem englischen Standard-API-Namen enthalten |
 | `get_mantis_version` | MantisBT-Version abrufen und auf Updates prüfen |
 | `get_mcp_version` | Version dieser mantisbt-mcp-server-Instanz zurückgeben |
 

package/README.md

@@ -93,7 +93,7 @@ If no environment variables are set, `~/.claude/mantis.json` is read:
 |---|---|
 | `get_issue` | Retrieve an issue by its numeric ID |
 | `list_issues` | Filter issues by project, status, author, and more; optional `select` for field projection and `status` for client-side status filtering |
-| `create_issue` | Create a new issue |
+| `create_issue` | Create a new issue; optional `handler` parameter accepts a username as alternative to `handler_id` (resolved against project members) |
 | `update_issue` | Update an existing issue |
 | `delete_issue` | Delete an issue |
 
@@ -116,7 +116,7 @@ If no environment variables are set, `~/.claude/mantis.json` is read:
 
 | Tool | Description |
 |---|---|
-| `add_relationship` | Create a relationship between two issues |
+| `add_relationship` | Create a relationship between two issues; optional `type_name` parameter accepts a string name (e.g. `"related_to"`, `"duplicate_of"`) as alternative to numeric `type_id` |
 | `remove_relationship` | Remove a relationship from an issue (use the `id` from the relationship object, not the type) |
 
 ### Monitors
@@ -157,7 +157,7 @@ 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 |
+| `search_issues` | Natural language search over all indexed issues — returns top-N results with cosine similarity score; optional `select` (comma-separated field names) enriches each result with the requested issue fields |
 | `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 |
 
@@ -188,7 +188,7 @@ 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_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; on localized installations each entry may include a `canonical_name` with the standard English API name |
 | `get_mantis_version` | Get MantisBT version and check for updates |
 | `get_mcp_version` | Return the version of this mantisbt-mcp-server instance |
 

package/dist/constants.js

@@ -10,12 +10,89 @@ export const RELATIONSHIP_TYPES = {
     HAS_DUPLICATE: 4,
 };
 // ---------------------------------------------------------------------------
+// Relationship type name → ID mapping (string aliases accepted by add_relationship)
+// ---------------------------------------------------------------------------
+export const RELATIONSHIP_NAME_TO_ID = {
+    'duplicate_of': RELATIONSHIP_TYPES.DUPLICATE_OF,
+    'duplicate-of': RELATIONSHIP_TYPES.DUPLICATE_OF,
+    'duplicateof': RELATIONSHIP_TYPES.DUPLICATE_OF,
+    'related_to': RELATIONSHIP_TYPES.RELATED_TO,
+    'related-to': RELATIONSHIP_TYPES.RELATED_TO,
+    'relatedto': RELATIONSHIP_TYPES.RELATED_TO,
+    'parent_of': RELATIONSHIP_TYPES.PARENT_OF,
+    'parent-of': RELATIONSHIP_TYPES.PARENT_OF,
+    'parentof': RELATIONSHIP_TYPES.PARENT_OF,
+    'depends_on': RELATIONSHIP_TYPES.PARENT_OF,
+    'depends-on': RELATIONSHIP_TYPES.PARENT_OF,
+    'dependson': RELATIONSHIP_TYPES.PARENT_OF,
+    'child_of': RELATIONSHIP_TYPES.CHILD_OF,
+    'child-of': RELATIONSHIP_TYPES.CHILD_OF,
+    'childof': RELATIONSHIP_TYPES.CHILD_OF,
+    'blocks': RELATIONSHIP_TYPES.CHILD_OF,
+    'has_duplicate': RELATIONSHIP_TYPES.HAS_DUPLICATE,
+    'has-duplicate': RELATIONSHIP_TYPES.HAS_DUPLICATE,
+    'hasduplicate': RELATIONSHIP_TYPES.HAS_DUPLICATE,
+};
+// ---------------------------------------------------------------------------
 // Status names (internal English names used in API calls)
 // ---------------------------------------------------------------------------
 // MantisBT default status ID for "resolved". Issues with status.id strictly
 // below this value are considered open (new/feedback/acknowledged/confirmed/assigned).
 export const MANTIS_RESOLVED_STATUS_ID = 80;
 // ---------------------------------------------------------------------------
+// Canonical English enum names for standard MantisBT installations.
+// Keyed by the enum group name (without _enum_string suffix).
+// Used by get_issue_enums to add a canonical_name field on localized installs.
+// ---------------------------------------------------------------------------
+export const MANTIS_CANONICAL_ENUM_NAMES = {
+    severity: {
+        10: 'feature',
+        20: 'trivial',
+        30: 'text',
+        40: 'tweak',
+        50: 'minor',
+        60: 'major',
+        70: 'crash',
+        80: 'block',
+    },
+    status: {
+        10: 'new',
+        20: 'feedback',
+        30: 'acknowledged',
+        40: 'confirmed',
+        50: 'assigned',
+        80: 'resolved',
+        90: 'closed',
+    },
+    priority: {
+        10: 'none',
+        20: 'low',
+        30: 'normal',
+        40: 'high',
+        50: 'urgent',
+        60: 'immediate',
+    },
+    resolution: {
+        10: 'open',
+        20: 'fixed',
+        30: 'reopened',
+        40: 'unable to duplicate',
+        50: 'not fixable',
+        60: 'duplicate',
+        70: 'no change required',
+        80: 'suspended',
+        90: 'wont fix',
+    },
+    reproducibility: {
+        10: 'always',
+        30: 'sometimes',
+        50: 'random',
+        70: 'have not tried',
+        90: 'unable to reproduce',
+        100: 'N/A',
+    },
+};
+// ---------------------------------------------------------------------------
 // Issue enum config option names
 // ---------------------------------------------------------------------------
 export const ISSUE_ENUM_OPTIONS = [

package/dist/index.js

@@ -42,7 +42,7 @@ async function createMcpServer() {
         name: 'mantisbt-mcp-server',
         version,
     });
-    registerIssueTools(server, client);
+    registerIssueTools(server, client, cache);
     registerNoteTools(server, client);
     registerFileTools(server, client);
     registerRelationshipTools(server, client);

package/dist/search/tools.js

@@ -27,13 +27,16 @@ export function registerSearchTools(server, client, store, embedder) {
                 .max(50)
                 .default(10)
                 .describe('Number of results to return (default: 10, max: 50)'),
+            select: z.string().optional().describe('Comma-separated list of fields to include for each result (e.g. "id,summary,status,handler,priority"). ' +
+                'When provided, each matching issue is fetched from MantisBT and enriched with the requested fields. ' +
+                'The relevance score is always included. Without this parameter only id and score are returned.'),
         }),
         annotations: {
             readOnlyHint: true,
             destructiveHint: false,
             idempotentHint: true,
         },
-    }, async ({ query, top_n }) => {
+    }, async ({ query, top_n, select }) => {
         try {
             const count = await store.count();
             if (count === 0) {
@@ -49,8 +52,30 @@ export function registerSearchTools(server, client, store, embedder) {
             }
             const queryVector = await embedder.embed(query);
             const results = await store.search(queryVector, top_n);
+            if (!select) {
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            const fields = select.split(',').map(f => f.trim()).filter(Boolean);
+            const enriched = await Promise.all(results.map(async ({ id, score }) => {
+                try {
+                    const issueResult = await client.get(`issues/${id}`);
+                    const issue = issueResult.issues?.[0] ?? {};
+                    const projected = { id, score };
+                    for (const field of fields) {
+                        if (field !== 'id' && field in issue) {
+                            projected[field] = issue[field];
+                        }
+                    }
+                    return projected;
+                }
+                catch {
+                    return { id, score };
+                }
+            }));
             return {
-                content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(enriched, null, 2) }],
             };
         }
         catch (error) {

package/dist/tools/config.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ISSUE_ENUM_OPTIONS } from '../constants.js';
+import { ISSUE_ENUM_OPTIONS, MANTIS_CANONICAL_ENUM_NAMES } from '../constants.js';
 import { getVersionHint } from '../version-hint.js';
 function errorText(msg) {
     const vh = getVersionHint();
@@ -21,6 +21,10 @@ function parseEnumString(raw) {
     })
         .filter((e) => e !== null);
 }
+function resolveCanonicalName(id, name, canonicalMap) {
+    const canonical = canonicalMap[id];
+    return canonical !== undefined && canonical !== name ? canonical : undefined;
+}
 export function registerConfigTools(server, client, cache) {
     // ---------------------------------------------------------------------------
     // get_config
@@ -66,12 +70,12 @@ Common option names:
     // ---------------------------------------------------------------------------
     server.registerTool('get_issue_enums', {
         title: 'Get Issue Enum Values',
-        description: `Return valid ID and name pairs for all issue enum fields.
+        description: `Return valid ID, name, and (if available) localized label 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:
+Example response (English installation):
 {
   "severity":         [{"id": 10, "name": "feature"}, {"id": 50, "name": "minor"}, ...],
   "status":           [{"id": 10, "name": "new"}, {"id": 20, "name": "feedback"}, ...],
@@ -80,7 +84,30 @@ Example response:
   "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.`,
+Example response (localized installation, e.g. German):
+{
+  "status": [
+    {"id": 10, "name": "new",      "label": "Neu"},
+    {"id": 20, "name": "feedback", "label": "Feedback"},
+    {"id": 30, "name": "acknowledged", "label": "Bestätigt"},
+    ...
+  ],
+  ...
+}
+
+Fields:
+- "id"    — numeric ID accepted by the API
+- "name"  — the API value to pass to create_issue or update_issue; normally English, but may be
+            localized if the installation has customized enum values in the database
+- "label" — localized display label shown in the UI (only present when it differs from "name")
+
+Always pass either the "id" or the "name" value to create_issue or update_issue — never the "label".
+Use the "label" to map user input in the UI language back to the correct "name"/"id" for the API.
+
+Note: on some installations enum values are customized at the database level. In that case "name"
+itself may be localized (e.g. "kleinerer Fehler" instead of "minor") and no "label" will be present
+because there is no separate English original. The "name" value returned is always the correct one
+to use for API calls — regardless of language.`,
         inputSchema: z.object({}),
         annotations: {
             readOnlyHint: true,
@@ -107,11 +134,26 @@ The "name" field is the value to pass to create_issue or update_issue.`,
                 const key = keyMap[option];
                 if (!key)
                     continue;
+                const canonicalMap = MANTIS_CANONICAL_ENUM_NAMES[key] ?? {};
                 if (typeof value === 'string') {
-                    enums[key] = parseEnumString(value);
+                    enums[key] = parseEnumString(value).map(({ id, name }) => {
+                        const entry = { id, name };
+                        const canonical_name = resolveCanonicalName(id, name, canonicalMap);
+                        if (canonical_name !== undefined)
+                            entry.canonical_name = canonical_name;
+                        return entry;
+                    });
                 }
                 else if (Array.isArray(value)) {
-                    enums[key] = value.map(({ id, name }) => ({ id, name }));
+                    enums[key] = value.map(({ id, name, label }) => {
+                        const entry = { id, name };
+                        if (label && label !== name)
+                            entry.label = label;
+                        const canonical_name = resolveCanonicalName(id, name, canonicalMap);
+                        if (canonical_name !== undefined)
+                            entry.canonical_name = canonical_name;
+                        return entry;
+                    });
                 }
             }
             return {

package/dist/tools/issues.js

@@ -7,7 +7,7 @@ function errorText(msg) {
     const hint = vh?.getUpdateHint();
     return hint ? `Error: ${msg}\n\n${hint}` : `Error: ${msg}`;
 }
-export function registerIssueTools(server, client) {
+export function registerIssueTools(server, client, cache) {
     // ---------------------------------------------------------------------------
     // get_issue
     // ---------------------------------------------------------------------------
@@ -40,7 +40,7 @@ export function registerIssueTools(server, client) {
     // ---------------------------------------------------------------------------
     server.registerTool('list_issues', {
         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.',
+        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.\n\nNote: "assigned_to", "reporter_id", and "status" filters are applied client-side (the MantisBT REST API does not reliably support these as server-side filters). When any of these filters are active the tool automatically fetches multiple pages internally until enough matching results are found (up to 500 issues scanned). The "page" and "page_size" parameters refer to the resulting filtered list.',
         inputSchema: z.object({
             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)'),
@@ -60,9 +60,7 @@ export function registerIssueTools(server, client) {
         },
     }, async ({ project_id, page, page_size, assigned_to, reporter_id, filter_id, sort, direction, select, status }) => {
         try {
-            const params = {
-                page,
-                page_size,
+            const baseParams = {
                 project_id,
                 assigned_to,
                 reporter_id,
@@ -71,19 +69,57 @@ export function registerIssueTools(server, client) {
                 direction,
                 select,
             };
-            const result = await client.get('issues', params);
-            if (status && result.issues) {
-                const statusLower = status.toLowerCase();
-                result.issues = result.issues.filter(issue => {
-                    if (!issue.status)
-                        return false;
-                    if (statusLower === 'open')
-                        return (issue.status.id ?? 0) < MANTIS_RESOLVED_STATUS_ID;
-                    return issue.status.name?.toLowerCase() === statusLower;
+            const needsClientFilter = status !== undefined || assigned_to !== undefined || reporter_id !== undefined;
+            if (!needsClientFilter) {
+                // No client-side filtering — single API call, pass pagination as-is
+                const result = await client.get('issues', { ...baseParams, page, page_size });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            // Client-side filtering active: scan multiple API pages until we have
+            // enough matching results for the requested logical page.
+            const API_PAGE_SIZE = 50; // always fetch max to minimise round-trips
+            const MAX_API_PAGES = 10; // hard cap: scan at most 500 issues
+            const neededTotal = page * page_size; // need this many matches to serve page N
+            const matching = [];
+            let serverPage = 1;
+            let hasMore = true;
+            const statusLower = status?.toLowerCase();
+            while (matching.length < neededTotal && serverPage <= MAX_API_PAGES && hasMore) {
+                const batch = await client.get('issues', {
+                    ...baseParams,
+                    page: serverPage,
+                    page_size: API_PAGE_SIZE,
                 });
+                const issues = batch.issues ?? [];
+                hasMore = issues.length === API_PAGE_SIZE;
+                for (const issue of issues) {
+                    if (statusLower) {
+                        if (!issue.status)
+                            continue;
+                        if (statusLower === 'open') {
+                            if ((issue.status.id ?? 0) >= MANTIS_RESOLVED_STATUS_ID)
+                                continue;
+                        }
+                        else if (issue.status.name?.toLowerCase() !== statusLower) {
+                            continue;
+                        }
+                    }
+                    if (assigned_to !== undefined && issue.handler?.id !== assigned_to)
+                        continue;
+                    if (reporter_id !== undefined && issue.reporter?.id !== reporter_id)
+                        continue;
+                    matching.push(issue);
+                }
+                serverPage++;
             }
+            const start = (page - 1) * page_size;
             return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ issues: matching.slice(start, start + page_size) }, null, 2),
+                    }],
             };
         }
         catch (error) {
@@ -105,13 +141,38 @@ export function registerIssueTools(server, client) {
             priority: z.string().optional().describe('Priority name (e.g. "normal", "high", "urgent", "immediate", "low", "none")'),
             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'),
+            handler: z.string().optional().describe('Username (login name) of the person to assign the issue to. Alternative to handler_id — the server resolves the name to a user ID from the project members. Use get_project_users to see available users.'),
         }),
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: false,
         },
-    }, async ({ summary, description, project_id, category, priority, severity, handler_id }) => {
+    }, async ({ summary, description, project_id, category, priority, severity, handler_id, handler }) => {
+        // Resolve handler username to handler_id when only a name is given
+        let resolvedHandlerId = handler_id;
+        if (resolvedHandlerId === undefined && handler !== undefined) {
+            const metadata = await cache.loadIfValid();
+            let users = metadata?.byProject[project_id]?.users ?? [];
+            if (users.length === 0) {
+                try {
+                    const usersResult = await client.get(`projects/${project_id}/users`);
+                    users = usersResult.users ?? [];
+                }
+                catch {
+                    users = [];
+                }
+            }
+            const user = users.find(u => u.name === handler || u.real_name === handler);
+            if (!user) {
+                const names = users.map(u => u.name).join(', ');
+                return {
+                    content: [{ type: 'text', text: errorText(`User "${handler}" not found in project ${project_id}. Available users: ${names || 'none (run sync_metadata or check project_id)'}`) }],
+                    isError: true,
+                };
+            }
+            resolvedHandlerId = user.id;
+        }
         try {
             const body = {
                 summary,
@@ -122,11 +183,26 @@ export function registerIssueTools(server, client) {
             if (priority)
                 body.priority = { name: priority };
             body.severity = { name: severity };
-            if (handler_id)
-                body.handler = { id: handler_id };
-            const result = await client.post('issues', body);
+            if (resolvedHandlerId)
+                body.handler = { id: resolvedHandlerId };
+            const raw = await client.post('issues', body);
+            const partial = ('issue' in raw && typeof raw['issue'] === 'object' && raw['issue'] !== null)
+                ? raw['issue']
+                : raw;
+            let issue = partial;
+            if (!('summary' in partial)) {
+                // Older MantisBT returned only { id: N } — fetch the full issue.
+                // Suppress GET errors: the issue was already created.
+                try {
+                    const fetched = await client.get(`issues/${partial.id}`);
+                    issue = fetched.issues?.[0] ?? partial;
+                }
+                catch {
+                    // unable to fetch details — return minimal object
+                }
+            }
             return {
-                content: [{ type: 'text', text: JSON.stringify(result.issue ?? result, null, 2) }],
+                content: [{ type: 'text', text: JSON.stringify(issue, null, 2) }],
             };
         }
         catch (error) {

package/dist/tools/relationships.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { RELATIONSHIP_TYPES } from '../constants.js';
+import { RELATIONSHIP_TYPES, RELATIONSHIP_NAME_TO_ID } from '../constants.js';
 import { getVersionHint } from '../version-hint.js';
 function errorText(msg) {
     const vh = getVersionHint();
@@ -15,31 +15,47 @@ export function registerRelationshipTools(server, client) {
         title: 'Add Issue Relationship',
         description: `Add a relationship between two MantisBT issues.
 
-Relationship type IDs:
-- ${RELATIONSHIP_TYPES.DUPLICATE_OF} = duplicate_of    — this issue is a duplicate of target
-- ${RELATIONSHIP_TYPES.RELATED_TO}   = related_to      — this issue is related to target
-- ${RELATIONSHIP_TYPES.PARENT_OF}    = parent_of       — this issue depends on target (target must be done first)
-- ${RELATIONSHIP_TYPES.CHILD_OF}     = child_of        — this issue blocks target (target can't proceed until this is done)
-- ${RELATIONSHIP_TYPES.HAS_DUPLICATE} = has_duplicate  — this issue has target as a duplicate
+Relationship types — use either type_id (numeric) or type_name (string):
+- ${RELATIONSHIP_TYPES.DUPLICATE_OF} / "duplicate_of"  — this issue is a duplicate of target
+- ${RELATIONSHIP_TYPES.RELATED_TO}   / "related_to"    — this issue is related to target
+- ${RELATIONSHIP_TYPES.PARENT_OF}    / "parent_of"     — this issue depends on target (target must be done first); alias: "depends_on"
+- ${RELATIONSHIP_TYPES.CHILD_OF}     / "child_of"      — this issue blocks target (target can't proceed until this is done); alias: "blocks"
+- ${RELATIONSHIP_TYPES.HAS_DUPLICATE} / "has_duplicate" — this issue has target as a duplicate
 
 Directionality note: "A child_of B" means A blocks B. "A parent_of B" means A depends on B.
 
-Important: The API only accepts numeric type IDs, not string names.`,
+Dash variants (e.g. "related-to") are also accepted for type_name.`,
         inputSchema: z.object({
             issue_id: z.coerce.number().int().positive().describe('The source issue ID (the one the relationship is added to)'),
             target_id: z.coerce.number().int().positive().describe('The target issue ID'),
-            type_id: z.coerce.number().int().min(0).max(4).describe(`Relationship type ID: 0=duplicate_of, 1=related_to, 2=parent_of (depends on), 3=child_of (blocks), 4=has_duplicate`),
+            type_id: z.coerce.number().int().min(0).max(4).optional().describe('Relationship type ID: 0=duplicate_of, 1=related_to, 2=parent_of (depends on), 3=child_of (blocks), 4=has_duplicate. Use either type_id or type_name.'),
+            type_name: z.string().optional().describe('Relationship type name as alternative to type_id. Accepted: "duplicate_of", "related_to", "parent_of" (or "depends_on"), "child_of" (or "blocks"), "has_duplicate". Dash variants (e.g. "related-to") also work.'),
         }),
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: false,
         },
-    }, async ({ issue_id, target_id, type_id }) => {
+    }, async ({ issue_id, target_id, type_id, type_name }) => {
+        // Resolve type_id from type_name when type_id is not provided
+        let resolvedTypeId = type_id;
+        if (resolvedTypeId === undefined) {
+            if (type_name === undefined) {
+                return { content: [{ type: 'text', text: errorText('Either type_id or type_name must be provided') }], isError: true };
+            }
+            const normalized = type_name.toLowerCase().replace(/-/g, '_');
+            resolvedTypeId = RELATIONSHIP_NAME_TO_ID[normalized];
+            if (resolvedTypeId === undefined) {
+                return {
+                    content: [{ type: 'text', text: errorText(`Unknown relationship type name: "${type_name}". Valid values: duplicate_of, related_to, parent_of, child_of, has_duplicate`) }],
+                    isError: true,
+                };
+            }
+        }
         try {
             const body = {
                 issue: { id: target_id },
-                type: { id: type_id },
+                type: { id: resolvedTypeId },
             };
             const result = await client.post(`issues/${issue_id}/relationships`, body);
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dpesch/mantisbt-mcp-server",
-  "version": "1.3.1",
+  "version": "1.5.0",
   "description": "MCP server for MantisBT REST API – read and manage bug tracker issues",
   "author": "Dominik Pesch",
   "license": "MIT",