@dpesch/mantisbt-mcp-server 1.4.0 → 1.5.1

package/tests/search/embedder.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Embedder } from '../../src/search/embedder.js';
+
+// ---------------------------------------------------------------------------
+// Mock @huggingface/transformers (dynamic import)
+// ---------------------------------------------------------------------------
+
+const mockPipelineFn = vi.fn(async (texts: string | string[]) => {
+  if (Array.isArray(texts)) {
+    return texts.map(() => ({ data: new Float32Array(4).fill(0.1), dims: [1, 4] }));
+  }
+  return { data: new Float32Array(4).fill(0.1), dims: [4] };
+});
+
+const mockPipelineFactory = vi.fn(async (_task: string, _model: string, _opts?: unknown) => mockPipelineFn);
+
+vi.mock('@huggingface/transformers', () => ({
+  pipeline: mockPipelineFactory,
+}));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+// ---------------------------------------------------------------------------
+// Thread configuration
+// ---------------------------------------------------------------------------
+
+describe('Embedder – thread configuration', () => {
+  it('passes intra_op_num_threads=1 by default', async () => {
+    const embedder = new Embedder('test-model');
+    await embedder.embed('hello');
+
+    expect(mockPipelineFactory).toHaveBeenCalledWith(
+      'feature-extraction',
+      'test-model',
+      expect.objectContaining({
+        session_options: { intra_op_num_threads: 1, inter_op_num_threads: 1 },
+      }),
+    );
+  });
+
+  it('passes configured numThreads to intra_op_num_threads; inter stays 1', async () => {
+    const embedder = new Embedder('test-model', 4);
+    await embedder.embed('hello');
+
+    expect(mockPipelineFactory).toHaveBeenCalledWith(
+      'feature-extraction',
+      'test-model',
+      expect.objectContaining({
+        session_options: { intra_op_num_threads: 4, inter_op_num_threads: 1 },
+      }),
+    );
+  });
+
+  it('loads the pipeline only once (lazy singleton)', async () => {
+    const embedder = new Embedder('test-model', 1);
+    await embedder.embed('first');
+    await embedder.embed('second');
+
+    expect(mockPipelineFactory).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Embedder default — numThreads omitted
+// ---------------------------------------------------------------------------
+
+describe('Embedder – numThreads default', () => {
+  it('uses intra_op_num_threads=1 when numThreads is not passed', async () => {
+    const embedder = new Embedder('m');
+    await embedder.embed('x');
+    expect(mockPipelineFactory).toHaveBeenCalledWith(
+      'feature-extraction',
+      'm',
+      expect.objectContaining({
+        session_options: expect.objectContaining({ intra_op_num_threads: 1 }),
+      }),
+    );
+  });
+});

package/tests/search/tools.test.ts

@@ -159,6 +159,123 @@ describe('rebuild_search_index – full: false', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// search_issues – select parameter
+// ---------------------------------------------------------------------------
+
+describe('search_issues – select parameter', () => {
+  it('returns plain {id, score} array when select is not provided', async () => {
+    const store = makeMockStore({ itemCount: 2 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    const result = await mockServer.callTool('search_issues', { query: 'test', top_n: 2 });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<{ id: number; score: number }>;
+    expect(parsed[0]).toEqual(expect.objectContaining({ id: expect.any(Number), score: expect.any(Number) }));
+    expect(Object.keys(parsed[0]!)).toEqual(['id', 'score']);
+  });
+
+  it('fetches issues and projects requested fields when select is provided', async () => {
+    const store = makeMockStore({ itemCount: 2 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(
+        makeResponse(200, JSON.stringify({ issues: [{ id: 1, summary: 'Login bug', status: { id: 10, name: 'new' }, priority: { id: 30, name: 'normal' } }] }))
+      )
+      .mockResolvedValueOnce(
+        makeResponse(200, JSON.stringify({ issues: [{ id: 2, summary: 'Crash on save', status: { id: 50, name: 'assigned' }, priority: { id: 40, name: 'high' } }] }))
+      );
+
+    const result = await mockServer.callTool('search_issues', { query: 'test', top_n: 2, select: 'summary,status' });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed).toHaveLength(2);
+    // id and score always present
+    expect(parsed[0]).toHaveProperty('id');
+    expect(parsed[0]).toHaveProperty('score');
+    // requested fields present
+    expect(parsed[0]).toHaveProperty('summary', 'Login bug');
+    expect(parsed[0]).toHaveProperty('status');
+    // non-requested field absent
+    expect(parsed[0]).not.toHaveProperty('priority');
+  });
+
+  it('id and score are always included even when not listed in select', async () => {
+    const store = makeMockStore({ itemCount: 1 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValueOnce(
+      makeResponse(200, JSON.stringify({ issues: [{ id: 1, summary: 'Test issue' }] }))
+    );
+
+    const result = await mockServer.callTool('search_issues', { query: 'test', top_n: 1, select: 'summary' });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).toHaveProperty('id', 1);
+    expect(parsed[0]).toHaveProperty('score');
+    expect(parsed[0]).toHaveProperty('summary', 'Test issue');
+  });
+
+  it('falls back to {id, score} when issue fetch fails', async () => {
+    const store = makeMockStore({ itemCount: 2 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [{ id: 1, summary: 'OK issue' }] })))
+      .mockResolvedValueOnce(makeResponse(500, 'Internal Server Error'));
+
+    const result = await mockServer.callTool('search_issues', { query: 'test', top_n: 2, select: 'summary' });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed).toHaveLength(2);
+    // First item enriched
+    expect(parsed[0]).toHaveProperty('summary');
+    // Second item fallback — only id and score
+    expect(Object.keys(parsed[1]!).sort()).toEqual(['id', 'score']);
+  });
+
+  it('omits non-existent fields silently', async () => {
+    const store = makeMockStore({ itemCount: 1 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValueOnce(
+      makeResponse(200, JSON.stringify({ issues: [{ id: 1, summary: 'Test' }] }))
+    );
+
+    const result = await mockServer.callTool('search_issues', { query: 'test', top_n: 1, select: 'summary,nonexistent_field' });
+
+    const parsed = JSON.parse(result.content[0]!.text) as Array<Record<string, unknown>>;
+    expect(parsed[0]).toHaveProperty('summary', 'Test');
+    expect(parsed[0]).not.toHaveProperty('nonexistent_field');
+  });
+
+  it('makes one API call per result when select is provided', async () => {
+    const store = makeMockStore({ itemCount: 3 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(200, JSON.stringify({ issues: [{ id: 1, summary: 'Issue' }] }))
+    );
+
+    await mockServer.callTool('search_issues', { query: 'test', top_n: 3, select: 'summary' });
+
+    expect(fetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('makes no API calls when select is not provided', async () => {
+    const store = makeMockStore({ itemCount: 3 });
+    registerSearchTools(mockServer as never, client, store, embedder);
+
+    await mockServer.callTool('search_issues', { query: 'test', top_n: 3 });
+
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // get_search_index_status – registration
 // ---------------------------------------------------------------------------

package/tests/tools/config.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-type EnumResult = Record<string, Array<{ id: number; name: string; label?: string }>>;
+type EnumEntry = { id: number; name: string; label?: string; canonical_name?: string };
+type EnumResult = Record<string, Array<EnumEntry>>;
 import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -100,8 +101,9 @@ describe('get_issue_enums', () => {
 
     it('label wird weggelassen wenn er identisch mit name ist', () => {
       // severity: name === label (z.B. "Feature-Wunsch" === "Feature-Wunsch") → kein label-Feld
+      // canonical_name is present because "Feature-Wunsch" differs from English "feature"
       const severityFirst = parsed.severity.find(e => e.id === 10)!;
-      expect(severityFirst).toEqual({ id: 10, name: 'Feature-Wunsch' });
+      expect(severityFirst).toMatchObject({ id: 10, name: 'Feature-Wunsch', canonical_name: 'feature' });
       expect(severityFirst).not.toHaveProperty('label');
 
       // priority: name="normal", label="normal" → kein label-Feld
@@ -132,6 +134,73 @@ describe('get_issue_enums', () => {
     expect(parsed.reproducibility).toContainEqual({ id: 70, name: 'have not tried' });
   });
 
+  describe('canonical_name für lokalisierte Installationen', () => {
+    it('fügt canonical_name hinzu wenn name von englischem Standardwert abweicht', async () => {
+      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
+      const result = await mockServer.callTool('get_issue_enums', {});
+      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
+
+      // severity: names are German in fixture → canonical_name must be present
+      const minor = parsed.severity.find(e => e.id === 50)!;
+      expect(minor.name).toBe('kleinerer Fehler');
+      expect(minor.canonical_name).toBe('minor');
+
+      const block = parsed.severity.find(e => e.id === 80)!;
+      expect(block.name).toBe('Blocker');
+      expect(block.canonical_name).toBe('block');
+    });
+
+    it('lässt canonical_name weg wenn name bereits englischer Standardwert ist', async () => {
+      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
+      const result = await mockServer.callTool('get_issue_enums', {});
+      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
+
+      // status: names are already English → no canonical_name
+      const statusNew = parsed.status.find(e => e.id === 10)!;
+      expect(statusNew.name).toBe('new');
+      expect(statusNew).not.toHaveProperty('canonical_name');
+
+      // priority: "normal" is already the canonical name
+      const priorityNormal = parsed.priority.find(e => e.id === 30)!;
+      expect(priorityNormal.name).toBe('normal');
+      expect(priorityNormal).not.toHaveProperty('canonical_name');
+    });
+
+    it('lässt canonical_name weg für unbekannte/benutzerdefinierte IDs', async () => {
+      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(enumFixture)));
+      const result = await mockServer.callTool('get_issue_enums', {});
+      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
+
+      // severity ID 200 ("Technische Schuld") is a custom entry with no canonical mapping
+      const custom = parsed.severity.find(e => e.id === 200)!;
+      expect(custom).toBeDefined();
+      expect(custom).not.toHaveProperty('canonical_name');
+    });
+
+    it('fügt canonical_name auch im String-Format (Legacy) hinzu', async () => {
+      // Override: use German names in legacy string format
+      const germanStringFixture = {
+        configs: [
+          { option: 'severity_enum_string', value: '50:kleinerer Fehler,80:Blocker' },
+          { option: 'status_enum_string',   value: '10:new,80:resolved' },
+          { option: 'priority_enum_string', value: '30:normal' },
+          { option: 'resolution_enum_string', value: '20:fixed' },
+          { option: 'reproducibility_enum_string', value: '10:always' },
+        ],
+      };
+      vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify(germanStringFixture)));
+      const result = await mockServer.callTool('get_issue_enums', {});
+      const parsed = JSON.parse(result.content[0]!.text) as EnumResult;
+
+      const minor = parsed.severity.find(e => e.id === 50)!;
+      expect(minor.canonical_name).toBe('minor');
+
+      // status "new" is already canonical — no canonical_name
+      const statusNew = parsed.status.find(e => e.id === 10)!;
+      expect(statusNew).not.toHaveProperty('canonical_name');
+    });
+  });
+
   it('gibt isError: true bei API-Fehler zurück', async () => {
     vi.mocked(fetch).mockResolvedValue(makeResponse(403, JSON.stringify({ message: 'Access denied' })));
 

package/tests/tools/issues.test.ts

@@ -4,9 +4,21 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { MantisClient } from '../../src/client.js';
 import { registerIssueTools } from '../../src/tools/issues.js';
+import { MetadataCache } from '../../src/cache.js';
 import { MockMcpServer, makeResponse } from '../helpers/mock-server.js';
 import { MANTIS_RESOLVED_STATUS_ID } from '../../src/constants.js';
 
+function makeStubCache(projectUsers?: Array<{ id: number; name: string; real_name?: string }>): MetadataCache {
+  return {
+    loadIfValid: vi.fn(async () => projectUsers ? {
+      timestamp: Date.now(),
+      projects: [],
+      tags: [],
+      byProject: { 1: { users: projectUsers, versions: [], categories: [] } },
+    } : null),
+  } as unknown as MetadataCache;
+}
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const fixturesDir = join(__dirname, '..', 'fixtures');
@@ -41,7 +53,7 @@ let client: MantisClient;
 beforeEach(() => {
   mockServer = new MockMcpServer();
   client = new MantisClient('https://mantis.example.com', 'test-token');
-  registerIssueTools(mockServer as never, client);
+  registerIssueTools(mockServer as never, client, makeStubCache());
   vi.stubGlobal('fetch', vi.fn());
 });
 
@@ -117,6 +129,57 @@ describe('create_issue', () => {
     expect(body.severity).toEqual({ name: 'minor' });
   });
 
+  it('returns full issue object when API responds with complete issue', async () => {
+    const fullIssue = { id: 100, summary: 'New issue', status: { id: 10, name: 'new' }, severity: { id: 50, name: 'minor' } };
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: fullIssue }))
+    );
+
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'New issue', project_id: 1, category: 'General',
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as typeof fullIssue;
+    expect(parsed.id).toBe(100);
+    expect(parsed.summary).toBe('New issue');
+    // Only one API call — no extra GET needed
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('fetches full issue via GET when API returns only an id (older MantisBT)', async () => {
+    const fullIssue = { id: 101, summary: 'Created issue', status: { id: 10, name: 'new' } };
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ id: 101 })))
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ issues: [fullIssue] })));
+
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Created issue', project_id: 1, category: 'General',
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as typeof fullIssue;
+    expect(parsed.summary).toBe('Created issue');
+    // Two API calls: POST + GET
+    expect(fetch).toHaveBeenCalledTimes(2);
+    const getUrl = vi.mocked(fetch).mock.calls[1]![0] as string;
+    expect(getUrl).toContain('issues/101');
+  });
+
+  it('returns minimal object when GET fallback fails (issue was already created)', async () => {
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ id: 102 })))
+      .mockResolvedValueOnce(makeResponse(500, 'Server Error'));
+
+    const result = await mockServer.callTool('create_issue', {
+      summary: 'Test', project_id: 1, category: 'General',
+    });
+
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0]!.text) as { id: number };
+    expect(parsed.id).toBe(102);
+  });
+
   it('respects an explicitly passed severity', async () => {
     vi.mocked(fetch).mockResolvedValue(
       makeResponse(201, JSON.stringify({ issue: { id: 101, summary: 'Test' } }))
@@ -134,6 +197,98 @@ describe('create_issue', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// create_issue – handler username
+// ---------------------------------------------------------------------------
+
+describe('create_issue – handler username', () => {
+  it('resolves handler username to id from cache and sets handler in body', async () => {
+    const cache = makeStubCache([{ id: 7, name: 'dom' }, { id: 8, name: 'jane' }]);
+    const server = new MockMcpServer();
+    registerIssueTools(server as never, client, cache);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 200, summary: 'New issue', handler: { id: 7, name: 'dom' } } }))
+    );
+
+    await server.callTool('create_issue', {
+      summary: 'Test', project_id: 1, category: 'General', handler: 'dom',
+    });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
+    expect(body.handler).toEqual({ id: 7 });
+  });
+
+  it('resolves handler by real_name when name does not match', async () => {
+    const cache = makeStubCache([{ id: 9, name: 'jdoe', real_name: 'John Doe' }]);
+    const server = new MockMcpServer();
+    registerIssueTools(server as never, client, cache);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 201, summary: 'New' } }))
+    );
+
+    await server.callTool('create_issue', {
+      summary: 'Test', project_id: 1, category: 'General', handler: 'John Doe',
+    });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
+    expect(body.handler).toEqual({ id: 9 });
+  });
+
+  it('fetches users from API when cache returns null', async () => {
+    const cache = makeStubCache(); // returns null from loadIfValid
+    const server = new MockMcpServer();
+    registerIssueTools(server as never, client, cache);
+
+    vi.mocked(fetch)
+      .mockResolvedValueOnce(makeResponse(200, JSON.stringify({ users: [{ id: 42, name: 'alice' }] })))
+      .mockResolvedValueOnce(makeResponse(201, JSON.stringify({ issue: { id: 202, summary: 'New' } })));
+
+    await server.callTool('create_issue', {
+      summary: 'Test', project_id: 1, category: 'General', handler: 'alice',
+    });
+
+    const projectUsersCall = vi.mocked(fetch).mock.calls[0]![0] as string;
+    expect(projectUsersCall).toContain('projects/1/users');
+
+    const createBody = JSON.parse(vi.mocked(fetch).mock.calls[1]![1]!.body as string) as { handler: { id: number } };
+    expect(createBody.handler).toEqual({ id: 42 });
+  });
+
+  it('returns error when handler username is not found', async () => {
+    const cache = makeStubCache([{ id: 7, name: 'dom' }]);
+    const server = new MockMcpServer();
+    registerIssueTools(server as never, client, cache);
+
+    const result = await server.callTool('create_issue', {
+      summary: 'Test', project_id: 1, category: 'General', handler: 'nonexistent',
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('nonexistent');
+    expect(result.content[0]!.text).toContain('dom');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('handler_id takes precedence over handler username', async () => {
+    const cache = makeStubCache([{ id: 7, name: 'dom' }]);
+    const server = new MockMcpServer();
+    registerIssueTools(server as never, client, cache);
+
+    vi.mocked(fetch).mockResolvedValue(
+      makeResponse(201, JSON.stringify({ issue: { id: 203, summary: 'New' } }))
+    );
+
+    await server.callTool('create_issue', {
+      summary: 'Test', project_id: 1, category: 'General', handler_id: 99, handler: 'dom',
+    });
+
+    const body = JSON.parse(vi.mocked(fetch).mock.calls[0]![1]!.body as string) as { handler: { id: number } };
+    expect(body.handler).toEqual({ id: 99 });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // list_issues
 // ---------------------------------------------------------------------------

package/tests/tools/relationships.test.ts

@@ -60,6 +60,81 @@ describe('add_relationship', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// add_relationship – type_name parameter
+// ---------------------------------------------------------------------------
+
+describe('add_relationship – type_name', () => {
+  it('accepts "related_to" and sends type_id 1', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
+
+    await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_name: 'related_to' });
+
+    const body = JSON.parse((vi.mocked(fetch).mock.calls[0]![1] as RequestInit).body as string) as { type: { id: number } };
+    expect(body.type.id).toBe(1);
+  });
+
+  it('accepts "related-to" (dash variant) and sends type_id 1', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
+
+    await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_name: 'related-to' });
+
+    const body = JSON.parse((vi.mocked(fetch).mock.calls[0]![1] as RequestInit).body as string) as { type: { id: number } };
+    expect(body.type.id).toBe(1);
+  });
+
+  it('accepts "duplicate_of" and sends type_id 0', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
+
+    await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_name: 'duplicate_of' });
+
+    const body = JSON.parse((vi.mocked(fetch).mock.calls[0]![1] as RequestInit).body as string) as { type: { id: number } };
+    expect(body.type.id).toBe(0);
+  });
+
+  it('accepts "depends_on" as alias for parent_of (type_id 2)', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
+
+    await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_name: 'depends_on' });
+
+    const body = JSON.parse((vi.mocked(fetch).mock.calls[0]![1] as RequestInit).body as string) as { type: { id: number } };
+    expect(body.type.id).toBe(2);
+  });
+
+  it('accepts "blocks" as alias for child_of (type_id 3)', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
+
+    await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_name: 'blocks' });
+
+    const body = JSON.parse((vi.mocked(fetch).mock.calls[0]![1] as RequestInit).body as string) as { type: { id: number } };
+    expect(body.type.id).toBe(3);
+  });
+
+  it('type_id takes precedence when both type_id and type_name are given', async () => {
+    vi.mocked(fetch).mockResolvedValue(makeResponse(200, JSON.stringify({ id: 5 })));
+
+    await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_id: 4, type_name: 'related_to' });
+
+    const body = JSON.parse((vi.mocked(fetch).mock.calls[0]![1] as RequestInit).body as string) as { type: { id: number } };
+    expect(body.type.id).toBe(4);
+  });
+
+  it('returns error for unknown type_name', async () => {
+    const result = await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20, type_name: 'nonsense' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0]!.text).toContain('nonsense');
+    expect(fetch).not.toHaveBeenCalled();
+  });
+
+  it('returns error when neither type_id nor type_name is given', async () => {
+    const result = await mockServer.callTool('add_relationship', { issue_id: 10, target_id: 20 });
+
+    expect(result.isError).toBe(true);
+    expect(fetch).not.toHaveBeenCalled();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // remove_relationship
 // ---------------------------------------------------------------------------

package/tests/tools/string-coercion.test.ts

@@ -12,6 +12,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { MantisClient } from '../../src/client.js';
 import { registerIssueTools } from '../../src/tools/issues.js';
+import { MetadataCache } from '../../src/cache.js';
 import { registerNoteTools } from '../../src/tools/notes.js';
 import { registerFileTools } from '../../src/tools/files.js';
 import { registerMonitorTools } from '../../src/tools/monitors.js';
@@ -30,7 +31,8 @@ let client: MantisClient;
 beforeEach(() => {
   mockServer = new MockMcpServer();
   client = new MantisClient('https://mantis.example.com', 'test-token');
-  registerIssueTools(mockServer as never, client);
+  const stubCache = { loadIfValid: vi.fn(async () => null) } as unknown as MetadataCache;
+  registerIssueTools(mockServer as never, client, stubCache);
   registerNoteTools(mockServer as never, client);
   registerFileTools(mockServer as never, client);
   registerMonitorTools(mockServer as never, client);