@smartbear/mcp 0.3.0 → 0.4.0

package/dist/tests/unit/insight-hub/client.test.js

@@ -441,55 +441,50 @@ describe('InsightHubClient', () => {
         });
     });
     describe('tool registration', () => {
-        let mockServer;
+        let registerToolsSpy;
+        let getInputFunctionSpy;
         beforeEach(() => {
-            mockServer = {
-                registerTool: vi.fn(),
-                resource: vi.fn()
-            };
+            registerToolsSpy = vi.fn();
+            getInputFunctionSpy = vi.fn();
         });
-        it('should register list_insight_hub_projects tool when no project API key', () => {
-            client.registerTools(mockServer);
-            expect(mockServer.registerTool).toHaveBeenCalledWith('list_insight_hub_projects', expect.any(Object), expect.any(Function));
+        it('should register list_projects tool when no project API key', () => {
+            client.registerTools(registerToolsSpy, getInputFunctionSpy);
+            expect(registerToolsSpy).toBeCalledWith(expect.any(Object), expect.any(Function));
         });
-        it('should not register list_insight_hub_projects tool when project API key is provided', () => {
+        it('should not register list_projects tool when project API key is provided', () => {
             const clientWithApiKey = new InsightHubClient('test-token', 'project-api-key');
-            clientWithApiKey.registerTools(mockServer);
-            const registeredTools = mockServer.registerTool.mock.calls.map((call) => call[0]);
-            expect(registeredTools).not.toContain('list_insight_hub_projects');
+            clientWithApiKey.registerTools(registerToolsSpy, getInputFunctionSpy);
+            const registeredTools = registerToolsSpy.mock.calls.map((call) => call[0].title);
+            expect(registeredTools).not.toContain('List Projects');
         });
         it('should register common tools regardless of project API key', () => {
-            client.registerTools(mockServer);
-            const registeredTools = mockServer.registerTool.mock.calls.map((call) => call[0]);
-            expect(registeredTools).toContain('get_insight_hub_error');
-            expect(registeredTools).toContain('get_insight_hub_event_details');
-            expect(registeredTools).toContain('list_insight_hub_project_errors');
-            expect(registeredTools).toContain('get_project_event_filters');
-            expect(registeredTools).toContain('update_error');
+            client.registerTools(registerToolsSpy, getInputFunctionSpy);
+            const registeredTools = registerToolsSpy.mock.calls.map((call) => call[0].title);
+            expect(registeredTools).toContain('Get Error');
+            expect(registeredTools).toContain('Get Event Details');
+            expect(registeredTools).toContain('List Project Errors');
+            expect(registeredTools).toContain('List Project Event Filters');
+            expect(registeredTools).toContain('Update Error');
         });
     });
     describe('resource registration', () => {
-        let mockServer;
+        let registerResourcesSpy;
         beforeEach(() => {
-            mockServer = {
-                registerTool: vi.fn(),
-                resource: vi.fn()
-            };
+            registerResourcesSpy = vi.fn();
         });
-        it('should register insight_hub_event resource', () => {
-            client.registerResources(mockServer);
-            expect(mockServer.resource).toHaveBeenCalledWith('insight_hub_event', expect.any(Object), expect.any(Function));
+        it('should register event resource', () => {
+            client.registerResources(registerResourcesSpy);
+            expect(registerResourcesSpy).toHaveBeenCalledWith('event', '{id}', expect.any(Function));
         });
     });
     describe('tool handlers', () => {
-        let mockServer;
+        let registerToolsSpy;
+        let getInputFunctionSpy;
         beforeEach(() => {
-            mockServer = {
-                registerTool: vi.fn(),
-                resource: vi.fn()
-            };
+            registerToolsSpy = vi.fn();
+            getInputFunctionSpy = vi.fn();
         });
-        describe('list_insight_hub_projects tool handler', () => {
+        describe('list_projects tool handler', () => {
             it('should return projects with pagination', async () => {
                 const mockProjects = [
                     { id: 'proj-1', name: 'Project 1' },
@@ -497,9 +492,9 @@ describe('InsightHubClient', () => {
                     { id: 'proj-3', name: 'Project 3' }
                 ];
                 mockCache.get.mockReturnValue(mockProjects);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_projects')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Projects')[1];
                 const result = await toolHandler({ page_size: 2, page: 1 });
                 const expectedResult = {
                     data: mockProjects.slice(0, 2),
@@ -510,9 +505,9 @@ describe('InsightHubClient', () => {
             it('should return all projects when no pagination specified', async () => {
                 const mockProjects = [{ id: 'proj-1', name: 'Project 1' }];
                 mockCache.get.mockReturnValue(mockProjects);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_projects')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Projects')[1];
                 const result = await toolHandler({});
                 const expectedResult = {
                     data: mockProjects,
@@ -522,9 +517,9 @@ describe('InsightHubClient', () => {
             });
             it('should handle no projects found', async () => {
                 mockCache.get.mockReturnValue([]);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_projects')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Projects')[1];
                 const result = await toolHandler({});
                 expect(result.content[0].text).toBe('No projects found.');
             });
@@ -535,9 +530,9 @@ describe('InsightHubClient', () => {
                     { id: 'proj-3', name: 'Project 3' }
                 ];
                 mockCache.get.mockReturnValue(mockProjects);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_projects')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Projects')[1];
                 const result = await toolHandler({ page_size: 2 });
                 const expectedResult = {
                     data: mockProjects.slice(0, 2),
@@ -551,9 +546,9 @@ describe('InsightHubClient', () => {
                     name: `Project ${i + 1}`
                 }));
                 mockCache.get.mockReturnValue(mockProjects);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_projects')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Projects')[1];
                 const result = await toolHandler({ page: 2 });
                 // Default page_size is 10, so page 2 should return projects 10-19
                 const expectedResult = {
@@ -563,7 +558,7 @@ describe('InsightHubClient', () => {
                 expect(result.content[0].text).toBe(JSON.stringify(expectedResult));
             });
         });
-        describe('get_insight_hub_error tool handler', () => {
+        describe('get_error tool handler', () => {
             it('should get error details with project from cache', async () => {
                 const mockProject = { id: 'proj-1', name: 'Project 1', slug: 'my-project' };
                 const mockError = { id: 'error-1', message: 'Test error' };
@@ -575,9 +570,9 @@ describe('InsightHubClient', () => {
                 mockErrorAPI.viewErrorOnProject.mockResolvedValue({ body: mockError });
                 mockErrorAPI.listEventsOnProject.mockResolvedValue({ body: mockEvents });
                 mockErrorAPI.listErrorPivots.mockResolvedValue({ body: mockPivots });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Get Error')[1];
                 const result = await toolHandler({ errorId: 'error-1' });
                 const queryString = '?filters[error][][type]=eq&filters[error][][value]=error-1';
                 const encodedQueryString = encodeURI(queryString);
@@ -590,9 +585,9 @@ describe('InsightHubClient', () => {
                 }));
             });
             it('should throw error when required arguments missing', async () => {
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Get Error')[1];
                 await expect(toolHandler({})).rejects.toThrow('Both projectId and errorId arguments are required');
             });
         });
@@ -602,9 +597,9 @@ describe('InsightHubClient', () => {
                 const mockEvent = { id: 'event-1', project_id: 'proj-1' };
                 mockCache.get.mockReturnValue(mockProjects);
                 mockErrorAPI.viewEventById.mockResolvedValue({ body: mockEvent });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_event_details')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Get Event Details')[1];
                 const result = await toolHandler({
                     link: 'https://app.bugsnag.com/my-org/my-project/errors/error-123?event_id=event-1'
                 });
@@ -612,30 +607,30 @@ describe('InsightHubClient', () => {
                 expect(result.content[0].text).toBe(JSON.stringify(mockEvent));
             });
             it('should throw error when link is invalid', async () => {
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_event_details')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Get Event Details')[1];
                 await expect(toolHandler({ link: 'invalid-url' })).rejects.toThrow();
             });
             it('should throw error when project not found', async () => {
                 mockCache.get.mockReturnValue([{ id: 'proj-1', slug: 'other-project', name: 'Other Project' }]);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_event_details')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Get Event Details')[1];
                 await expect(toolHandler({
                     link: 'https://app.bugsnag.com/my-org/my-project/errors/error-123?event_id=event-1'
                 })).rejects.toThrow('Project with the specified slug not found.');
             });
             it('should throw error when URL is missing required parameters', async () => {
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_event_details')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Get Event Details')[1];
                 await expect(toolHandler({
                     link: 'https://app.bugsnag.com/my-org/my-project/errors/error-123' // Missing event_id
                 })).rejects.toThrow('Both projectSlug and eventId must be present in the link');
             });
         });
-        describe('list_insight_hub_project_errors tool handler', () => {
+        describe('list_project_errors tool handler', () => {
             it('should list project errors with filters', async () => {
                 const mockProject = { id: 'proj-1', name: 'Project 1' };
                 const mockEventFields = [
@@ -648,9 +643,9 @@ describe('InsightHubClient', () => {
                     .mockReturnValueOnce(mockProject) // current project
                     .mockReturnValueOnce(mockEventFields); // event fields
                 mockErrorAPI.listProjectErrors.mockResolvedValue({ body: mockErrors });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_project_errors')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Project Errors')[1];
                 const result = await toolHandler({ filters });
                 expect(mockErrorAPI.listProjectErrors).toHaveBeenCalledWith('proj-1', { filters });
                 const expectedResult = {
@@ -666,16 +661,16 @@ describe('InsightHubClient', () => {
                 mockCache.get
                     .mockReturnValueOnce(mockProject)
                     .mockReturnValueOnce(mockEventFields);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_project_errors')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Project Errors')[1];
                 await expect(toolHandler({ filters })).rejects.toThrow('Invalid filter key: invalid.field');
             });
             it('should throw error when no project ID available', async () => {
                 mockCache.get.mockReturnValue(null);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_project_errors')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Project Errors')[1];
                 await expect(toolHandler({})).rejects.toThrow('No current project found. Please provide a projectId or configure a project API key.');
             });
         });
@@ -686,17 +681,17 @@ describe('InsightHubClient', () => {
                     { display_id: 'user.email', custom: false }
                 ];
                 mockCache.get.mockReturnValue(mockEventFields);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_project_event_filters')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Project Event Filters')[1];
                 const result = await toolHandler({});
                 expect(result.content[0].text).toBe(JSON.stringify(mockEventFields));
             });
             it('should throw error when no event filters in cache', async () => {
                 mockCache.get.mockReturnValue(null);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_project_event_filters')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'List Project Event Filters')[1];
                 await expect(toolHandler({})).rejects.toThrow('No event filters found in cache.');
             });
         });
@@ -705,9 +700,9 @@ describe('InsightHubClient', () => {
                 const mockProject = { id: 'proj-1', name: 'Project 1' };
                 mockCache.get.mockReturnValue(mockProject);
                 mockErrorAPI.updateErrorOnProject.mockResolvedValue({ status: 200 });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 const result = await toolHandler({
                     errorId: 'error-1',
                     operation: 'fix'
@@ -720,9 +715,9 @@ describe('InsightHubClient', () => {
                 const mockProjects = [mockProject];
                 mockCache.get.mockReturnValue(mockProjects);
                 mockErrorAPI.updateErrorOnProject.mockResolvedValue({ status: 204 });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 const result = await toolHandler({
                     projectId: 'proj-1',
                     errorId: 'error-1',
@@ -737,9 +732,9 @@ describe('InsightHubClient', () => {
                 const operations = ['open', 'fix', 'ignore', 'discard', 'undiscard'];
                 mockCache.get.mockReturnValue(mockProject);
                 mockErrorAPI.updateErrorOnProject.mockResolvedValue({ status: 200 });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 for (const operation of operations) {
                     await toolHandler({
                         errorId: 'error-1',
@@ -751,25 +746,20 @@ describe('InsightHubClient', () => {
             });
             it('should handle override_severity operation with elicitInput', async () => {
                 const mockProject = { id: 'proj-1', name: 'Project 1' };
-                const mockServerWithElicitInput = {
-                    registerTool: vi.fn(),
-                    server: {
-                        elicitInput: vi.fn().mockResolvedValue({
-                            action: 'accept',
-                            content: { severity: 'warning' }
-                        })
-                    }
-                };
+                getInputFunctionSpy.mockResolvedValue({
+                    action: 'accept',
+                    content: { severity: 'warning' }
+                });
                 mockCache.get.mockReturnValue(mockProject);
                 mockErrorAPI.updateErrorOnProject.mockResolvedValue({ status: 200 });
-                client.registerTools(mockServerWithElicitInput);
-                const toolHandler = mockServerWithElicitInput.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 const result = await toolHandler({
                     errorId: 'error-1',
                     operation: 'override_severity'
                 });
-                expect(mockServerWithElicitInput.server.elicitInput).toHaveBeenCalledWith({
+                expect(getInputFunctionSpy).toHaveBeenCalledWith({
                     message: "Please provide the new severity for the error (e.g. 'info', 'warning', 'error', 'critical')",
                     requestedSchema: {
                         type: "object",
@@ -788,19 +778,14 @@ describe('InsightHubClient', () => {
             });
             it('should handle override_severity operation when elicitInput is rejected', async () => {
                 const mockProject = { id: 'proj-1', name: 'Project 1' };
-                const mockServerWithElicitInput = {
-                    registerTool: vi.fn(),
-                    server: {
-                        elicitInput: vi.fn().mockResolvedValue({
-                            action: 'reject'
-                        })
-                    }
-                };
+                getInputFunctionSpy.mockResolvedValue({
+                    action: 'reject'
+                });
                 mockCache.get.mockReturnValue(mockProject);
                 mockErrorAPI.updateErrorOnProject.mockResolvedValue({ status: 200 });
-                client.registerTools(mockServerWithElicitInput);
-                const toolHandler = mockServerWithElicitInput.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 const result = await toolHandler({
                     errorId: 'error-1',
                     operation: 'override_severity'
@@ -812,9 +797,9 @@ describe('InsightHubClient', () => {
                 const mockProject = { id: 'proj-1', name: 'Project 1' };
                 mockCache.get.mockReturnValue(mockProject);
                 mockErrorAPI.updateErrorOnProject.mockResolvedValue({ status: 400 });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 const result = await toolHandler({
                     errorId: 'error-1',
                     operation: 'fix'
@@ -823,9 +808,9 @@ describe('InsightHubClient', () => {
             });
             it('should throw error when no project found', async () => {
                 mockCache.get.mockReturnValue(null);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 await expect(toolHandler({
                     errorId: 'error-1',
                     operation: 'fix'
@@ -834,74 +819,21 @@ describe('InsightHubClient', () => {
             it('should throw error when project ID not found', async () => {
                 const mockProjects = [{ id: 'proj-1', name: 'Project 1' }];
                 mockCache.get.mockReturnValue(mockProjects);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
+                client.registerTools(registerToolsSpy, getInputFunctionSpy);
+                const toolHandler = registerToolsSpy.mock.calls
+                    .find((call) => call[0].title === 'Update Error')[1];
                 await expect(toolHandler({
                     projectId: 'non-existent-project',
                     errorId: 'error-1',
                     operation: 'fix'
                 })).rejects.toThrow('Project with ID non-existent-project not found.');
             });
-            it('should notify Bugsnag when API call fails', async () => {
-                const Bugsnag = (await import('../../../common/bugsnag.js')).default;
-                const mockProject = { id: 'proj-1', name: 'Project 1' };
-                const mockError = new Error('API error');
-                mockCache.get.mockReturnValue(mockProject);
-                mockErrorAPI.updateErrorOnProject.mockRejectedValue(mockError);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'update_error')[2];
-                await expect(toolHandler({
-                    errorId: 'error-1',
-                    operation: 'fix'
-                })).rejects.toThrow('API error');
-                expect(Bugsnag.notify).toHaveBeenCalledWith(mockError);
-            });
-        });
-        describe('error handling in tool handlers', () => {
-            it('should notify Bugsnag when error occurs in list_insight_hub_projects', async () => {
-                const Bugsnag = (await import('../../../common/bugsnag.js')).default;
-                const mockError = new Error('Test error');
-                mockCache.get.mockImplementation(() => {
-                    throw mockError;
-                });
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'list_insight_hub_projects')[2];
-                await expect(toolHandler({})).rejects.toThrow('Test error');
-                expect(Bugsnag.notify).toHaveBeenCalledWith(mockError);
-            });
-            it('should notify Bugsnag when error occurs in get_insight_hub_error', async () => {
-                const Bugsnag = (await import('../../../common/bugsnag.js')).default;
-                const mockError = new Error('API error');
-                const mockProject = { id: 'proj-1', name: 'Project 1' };
-                mockCache.get.mockReturnValue(mockProject);
-                mockErrorAPI.viewErrorOnProject.mockRejectedValue(mockError);
-                client.registerTools(mockServer);
-                const toolHandler = mockServer.registerTool.mock.calls
-                    .find((call) => call[0] === 'get_insight_hub_error')[2];
-                await expect(toolHandler({ errorId: 'error-1' })).rejects.toThrow('API error');
-                expect(Bugsnag.notify).toHaveBeenCalledWith(mockError);
-            });
-            it('should notify Bugsnag when error occurs in resource handler', async () => {
-                const Bugsnag = (await import('../../../common/bugsnag.js')).default;
-                const mockError = new Error('Resource error');
-                mockCache.get.mockRejectedValue(mockError);
-                client.registerResources(mockServer);
-                const resourceHandler = mockServer.resource.mock.calls[0][2];
-                await expect(resourceHandler({ href: 'insighthub://event/event-1' }, { id: 'event-1' })).rejects.toThrow('Resource error');
-                expect(Bugsnag.notify).toHaveBeenCalledWith(mockError);
-            });
         });
     });
     describe('resource handlers', () => {
-        let mockServer;
+        let registerResourcesSpy;
         beforeEach(() => {
-            mockServer = {
-                registerTool: vi.fn(),
-                resource: vi.fn()
-            };
+            registerResourcesSpy = vi.fn();
         });
         describe('insight_hub_event resource handler', () => {
             it('should find event by ID across projects', async () => {
@@ -909,8 +841,8 @@ describe('InsightHubClient', () => {
                 const mockProjects = [{ id: 'proj-1', name: 'Project 1' }];
                 mockCache.get.mockReturnValueOnce(mockProjects);
                 mockErrorAPI.viewEventById.mockResolvedValue({ body: mockEvent });
-                client.registerResources(mockServer);
-                const resourceHandler = mockServer.resource.mock.calls[0][2];
+                client.registerResources(registerResourcesSpy);
+                const resourceHandler = registerResourcesSpy.mock.calls[0][2];
                 const result = await resourceHandler({ href: 'insighthub://event/event-1' }, { id: 'event-1' });
                 expect(result.contents[0].uri).toBe('insighthub://event/event-1');
                 expect(result.contents[0].text).toBe(JSON.stringify(mockEvent));

package/dist/tests/unit/pactflow/ai.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { RefineInputSchema } from "../../../pactflow/client/ai.js";
+describe("AI zod schemas validation tests", () => {
+    it("Parses RefineInputSchema with partial input", () => {
+        const result = RefineInputSchema.safeParse({
+            pactTests: {
+                filename: "test.js",
+                language: "javascript",
+                body: "describe('API', () => { it('works', () => { }); });"
+            }
+        });
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual({
+            pactTests: {
+                filename: "test.js",
+                language: "javascript",
+                body: "describe('API', () => { it('works', () => { }); });"
+            }
+        });
+    });
+});

package/dist/tests/unit/pactflow/client.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { PactflowClient } from "../../../pactflow/client.js";
+import * as toolsModule from "../../../pactflow/client/tools.js";
+describe("PactflowClient.registerTools", () => {
+    const mockRegister = vi.fn();
+    const mockGetInput = vi.fn();
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it("registers only tools matching the given clientType", () => {
+        // Arrange — mock TOOLS with multiple client types
+        const fakeTools = [
+            {
+                title: "tool1",
+                summary: "summary1",
+                purpose: "purpose1",
+                parameters: [],
+                handler: "generate",
+                clients: ["pactflow"], // should be registered
+            },
+            {
+                title: "tool2",
+                summary: "summary2",
+                purpose: "purpose2",
+                parameters: [],
+                handler: "generate",
+                clients: ["pact_broker"], // should NOT be registered
+            },
+        ];
+        vi.spyOn(toolsModule, "TOOLS", "get").mockReturnValue(fakeTools);
+        const client = new PactflowClient("token", "https://example.com", "pactflow");
+        client.registerTools(mockRegister, mockGetInput);
+        expect(mockRegister).toHaveBeenCalledTimes(1);
+        expect(mockRegister.mock.calls[0][0].title).toBe("tool1");
+        expect(mockRegister.mock.calls[0][0].summary).toBe("summary1");
+    });
+    it("registers no tools if none match the clientType", () => {
+        const fakeTools = [
+            {
+                title: "tool2",
+                summary: "summary2",
+                purpose: "purpose2",
+                parameters: [],
+                handler: "generate",
+                clients: ["pact_broker"],
+            },
+        ];
+        vi.spyOn(toolsModule, "TOOLS", "get").mockReturnValue(fakeTools);
+        const client = new PactflowClient("token", "https://example.com", "pactflow");
+        client.registerTools(mockRegister, mockGetInput);
+        expect(mockRegister).not.toHaveBeenCalled();
+    });
+    it("sets correct headers for pactflow", () => {
+        const client = new PactflowClient("my-token", "https://example.com", "pactflow");
+        expect(client["headers"]).toEqual(expect.objectContaining({
+            Authorization: expect.stringContaining("Bearer my-token"),
+            "Content-Type": expect.stringContaining("application/json"),
+        }));
+    });
+    it("sets correct headers for pact_broker", () => {
+        const client = new PactflowClient({ username: "user", password: "pass" }, "https://example.com", "pact_broker");
+        expect(client["headers"]).toEqual(expect.objectContaining({
+            Authorization: expect.stringContaining(`Basic ${Buffer.from("user:pass").toString("base64")}`),
+            "Content-Type": expect.stringContaining("application/json"),
+        }));
+    });
+});

package/dist/tests/unit/pactflow/tools.test.js

@@ -0,0 +1,34 @@
+import { TOOLS } from "../../../pactflow/client/tools.js";
+import { describe, it, expect } from 'vitest';
+describe("TOOLS definition for 'Generate Pact Tests'", () => {
+    it("defines the generate pact tests tool with correct metadata", () => {
+        const tool = TOOLS.find((t) => t.title === "Generate Pact Tests");
+        expect(tool).toBeDefined();
+        expect(tool?.summary).toMatch(/Generate Pact tests using PactFlow AI/);
+        expect(tool?.clients).toEqual(["pactflow"]);
+        expect(tool?.handler).toBe("generate");
+    });
+    it("enforces presence of matcher when openapi input is provided", () => {
+        const tool = TOOLS.find((t) => t.title === "Generate Pact Tests");
+        const schema = tool?.zodSchema;
+        const openapiSchema = schema.shape["openapi"];
+        expect(openapiSchema).toBeDefined();
+        const invalidOpenapi = {
+            openapi: {
+                document: {
+                    openapi: "3.0.0",
+                    paths: {},
+                },
+            },
+        };
+        expect(() => openapiSchema?.parse(invalidOpenapi.openapi)).toThrow(/matcher/);
+    });
+    it("rejects unsupported language values in the language field", () => {
+        const tool = TOOLS.find((t) => t.title === "Generate Pact Tests");
+        const schema = tool?.zodSchema;
+        const languageSchema = schema.shape["language"];
+        expect(languageSchema).toBeDefined();
+        const invalidData = "ruby"; // not in enum
+        expect(() => languageSchema?.parse(invalidData)).toThrow(/Invalid enum value/);
+    });
+});