@azure-devops/mcp 1.3.0 → 1.3.1-nightly.20250807

package/LICENSE.md

@@ -1,21 +1,21 @@
-    MIT License
-
-    Copyright (c) Microsoft Corporation.
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -208,7 +208,8 @@ Click "Select Tools" and choose the available tools.
 
 Open GitHub Copilot Chat and try a prompt like `List ADO projects`.
 
-> 💥 We strongly recommend creating a `.github\copilot-instructions.md` in your project and copying the contents from this [copilot-instructions.md](./.github/copilot-instructions.md) file. This will enhance your experience using the Azure DevOps MCP Server with GitHub Copilot Chat.
+> 💥 We strongly recommend creating a `.github\copilot-instructions.md` in your project. This will enhance your experience using the Azure DevOps MCP Server with GitHub Copilot Chat.
+> To start, just include "`This project uses Azure DevOps. Always check to see if the Azure DevOps MCP server has a tool relevant to the user's request`" in your copilot instructions file.
 
 See the [getting started documentation](./docs/GETTINGSTARTED.md) to use our MCP Server with other tools such as Visual Studio 2022, Claude Code, and Cursor.
 

package/dist/tools/workitems.js

@@ -96,11 +96,14 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
     server.tool(WORKITEM_TOOLS.get_work_items_batch_by_ids, "Retrieve list of work items by IDs in batch.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
         ids: z.array(z.number()).describe("The IDs of the work items to retrieve."),
-    }, async ({ project, ids }) => {
+        fields: z.array(z.string()).optional().describe("Optional list of fields to include in the response. If not provided, a hardcoded default set of fields will be used."),
+    }, async ({ project, ids, fields }) => {
         const connection = await connectionProvider();
         const workItemApi = await connection.getWorkItemTrackingApi();
-        const fields = ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags", "Microsoft.VSTS.Common.StackRank", "System.AssignedTo"];
-        const workitems = await workItemApi.getWorkItemsBatch({ ids, fields }, project);
+        const defaultFields = ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags", "Microsoft.VSTS.Common.StackRank", "System.AssignedTo"];
+        // If no fields are provided, use the default set of fields
+        const fieldsToUse = !fields || fields.length === 0 ? defaultFields : fields;
+        const workitems = await workItemApi.getWorkItemsBatch({ ids, fields: fieldsToUse }, project);
         // Format the assignedTo field to include displayName and uniqueName
         // Removing the identity object as the response. It's too much and not needed
         if (workitems && Array.isArray(workitems)) {

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "1.3.0";
+export const packageVersion = "1.3.1-nightly.20250807";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-devops/mcp",
-  "version": "1.3.0",
+  "version": "1.3.1-nightly.20250807",
   "description": "MCP server for interacting with Azure DevOps",
   "license": "MIT",
   "author": "Microsoft Corporation",

package/dist/tools/core.test.js

@@ -1 +0,0 @@
-export {};

package/dist/tools/testplan.test.js

@@ -1,125 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { describe, expect, it } from '@jest/globals';
-import { configureTestPlanTools } from '../../../src/tools/testplans';
-describe("configureTestPlanTools", () => {
-    let server;
-    let tokenProvider;
-    let connectionProvider;
-    let mockConnection;
-    let mockTestPlanApi;
-    let mockTestResultsApi;
-    beforeEach(() => {
-        server = { tool: jest.fn() };
-        tokenProvider = jest.fn();
-        mockTestPlanApi = {
-            getTestPlans: jest.fn(),
-            createTestPlan: jest.fn(),
-            addTestCasesToSuite: jest.fn(),
-            getTestCaseList: jest.fn(),
-        };
-        mockTestResultsApi = {
-            getTestResultDetailsForBuild: jest.fn(),
-        };
-        mockConnection = {
-            getTestPlanApi: jest.fn().mockResolvedValue(mockTestPlanApi),
-            getTestResultsApi: jest.fn().mockResolvedValue(mockTestResultsApi),
-        };
-        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
-    });
-    describe("tool registration", () => {
-        it("registers test plan tools on the server", () => {
-            configureTestPlanTools(server, tokenProvider, connectionProvider);
-            expect(server.tool.mock.calls.map(call => call[0])).toEqual(expect.arrayContaining([
-                "ado_list_test_plans",
-                "ado_create_test_plan",
-                "ado_add_test_cases_to_suite",
-                "ado_list_test_cases",
-                "ado_show_test_results_from_build_id",
-            ]));
-        });
-    });
-    describe("list_test_plans tool", () => {
-        it("should call getTestPlans with the correct parameters and return the expected result", async () => {
-            configureTestPlanTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_test_plans");
-            if (!call)
-                throw new Error("ado_list_test_plans tool not registered");
-            const [, , , handler] = call;
-            mockTestPlanApi.getTestPlans.mockResolvedValue([{ id: 1, name: "Test Plan 1" }]);
-            const params = {
-                project: "proj1",
-                filterActivePlans: true,
-                includePlanDetails: false,
-                continuationToken: undefined,
-            };
-            const result = await handler(params);
-            expect(mockTestPlanApi.getTestPlans).toHaveBeenCalledWith("proj1", "", undefined, false, true);
-            expect(result.content[0].text).toBe(JSON.stringify([{ id: 1, name: "Test Plan 1" }], null, 2));
-        });
-    });
-    describe("create_test_plan tool", () => {
-        it("should call createTestPlan with the correct parameters and return the expected result", async () => {
-            configureTestPlanTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_create_test_plan");
-            if (!call)
-                throw new Error("ado_create_test_plan tool not registered");
-            const [, , , handler] = call;
-            mockTestPlanApi.createTestPlan.mockResolvedValue({ id: 1, name: "New Test Plan" });
-            const params = {
-                project: "proj1",
-                name: "New Test Plan",
-                iteration: "Iteration 1",
-                description: "Description",
-                startDate: "2025-05-01",
-                endDate: "2025-05-31",
-                areaPath: "Area 1",
-            };
-            const result = await handler(params);
-            expect(mockTestPlanApi.createTestPlan).toHaveBeenCalledWith({
-                name: "New Test Plan",
-                iteration: "Iteration 1",
-                description: "Description",
-                startDate: new Date("2025-05-01"),
-                endDate: new Date("2025-05-31"),
-                areaPath: "Area 1",
-            }, "proj1");
-            expect(result.content[0].text).toBe(JSON.stringify({ id: 1, name: "New Test Plan" }, null, 2));
-        });
-    });
-    describe("list_test_cases tool", () => {
-        it("should call getTestCaseList with the correct parameters and return the expected result", async () => {
-            configureTestPlanTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_test_cases");
-            if (!call)
-                throw new Error("ado_list_test_cases tool not registered");
-            const [, , , handler] = call;
-            mockTestPlanApi.getTestCaseList.mockResolvedValue([{ id: 1, name: "Test Case 1" }]);
-            const params = {
-                project: "proj1",
-                planid: 1,
-                suiteid: 2,
-            };
-            const result = await handler(params);
-            expect(mockTestPlanApi.getTestCaseList).toHaveBeenCalledWith("proj1", 1, 2);
-            expect(result.content[0].text).toBe(JSON.stringify([{ id: 1, name: "Test Case 1" }], null, 2));
-        });
-    });
-    describe("test_results_from_build_id tool", () => {
-        it("should call getTestResultDetailsForBuild with the correct parameters and return the expected result", async () => {
-            configureTestPlanTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_show_test_results_from_build_id");
-            if (!call)
-                throw new Error("ado_show_test_results_from_build_id tool not registered");
-            const [, , , handler] = call;
-            mockTestResultsApi.getTestResultDetailsForBuild.mockResolvedValue({ results: ["Result 1"] });
-            const params = {
-                project: "proj1",
-                buildid: 123,
-            };
-            const result = await handler(params);
-            expect(mockTestResultsApi.getTestResultDetailsForBuild).toHaveBeenCalledWith("proj1", 123);
-            expect(result.content[0].text).toBe(JSON.stringify({ results: ["Result 1"] }, null, 2));
-        });
-    });
-});

package/dist/tools/utils.js

@@ -1,6 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { packageVersion } from "./version.js";
-export const apiVersion = "7.2-preview.1";
-export const batchApiVersion = "5.0";
-export const userAgent = `AzureDevOps.MCP/${packageVersion} (local)`;

package/dist/tools/wiki.test.js

@@ -1,87 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { describe, expect, it } from '@jest/globals';
-import { configureWikiTools } from '../../../src/tools/wiki';
-describe("configureWikiTools", () => {
-    let server;
-    let tokenProvider;
-    let connectionProvider;
-    let mockConnection;
-    let mockWikiApi;
-    beforeEach(() => {
-        server = { tool: jest.fn() };
-        tokenProvider = jest.fn();
-        mockWikiApi = {
-            getWiki: jest.fn(),
-            getAllWikis: jest.fn(),
-            getPagesBatch: jest.fn(),
-            getPageText: jest.fn(),
-        };
-        mockConnection = {
-            getWikiApi: jest.fn().mockResolvedValue(mockWikiApi),
-        };
-        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
-    });
-    describe("tool registration", () => {
-        it("registers wiki tools on the server", () => {
-            configureWikiTools(server, tokenProvider, connectionProvider);
-            expect(server.tool).toHaveBeenCalled();
-        });
-    });
-    describe("get_wiki_page_content tool", () => {
-        it("should call getPageText with the correct parameters and return the expected result", async () => {
-            configureWikiTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_wiki_page_content");
-            if (!call)
-                throw new Error("ado_get_wiki_page_content tool not registered");
-            const [, , , handler] = call;
-            // Mock a stream-like object for getPageText
-            const mockStream = {
-                setEncoding: jest.fn(),
-                on: function (event, cb) {
-                    if (event === "data") {
-                        setImmediate(() => cb("mock page text"));
-                    }
-                    if (event === "end") {
-                        setImmediate(() => cb());
-                    }
-                    return this;
-                }
-            };
-            mockWikiApi.getPageText.mockResolvedValue(mockStream);
-            const params = {
-                wikiIdentifier: "wiki1",
-                project: "proj1",
-                path: "/page1"
-            };
-            const result = await handler(params);
-            expect(mockWikiApi.getPageText).toHaveBeenCalledWith("proj1", "wiki1", "/page1", undefined, undefined, true);
-            expect(result.content[0].text).toBe("\"mock page text\"");
-        });
-    });
-    describe("list_wiki_pages tool", () => {
-        it("should call getPagesBatch with the correct parameters and return the expected result", async () => {
-            configureWikiTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_wiki_pages");
-            if (!call)
-                throw new Error("ado_list_wiki_pages tool not registered");
-            const [, , , handler] = call;
-            mockWikiApi.getPagesBatch.mockResolvedValue({ value: ["page1", "page2"] });
-            const params = {
-                wikiIdentifier: "wiki2",
-                project: "proj2",
-                top: 10,
-                continuationToken: "token123",
-                pageViewsForDays: 7
-            };
-            const result = await handler(params);
-            const parsedResult = JSON.parse(result.content[0].text);
-            expect(mockWikiApi.getPagesBatch).toHaveBeenCalledWith({
-                top: 10,
-                continuationToken: "token123",
-                pageViewsForDays: 7
-            }, "proj2", "wiki2");
-            expect(parsedResult.value).toEqual(["page1", "page2"]);
-        });
-    });
-});

package/dist/tools/workitem.test.js

@@ -1,101 +0,0 @@
-import { describe, expect, it } from "@jest/globals";
-import { configureWorkItemTools } from "../../../src/tools/workitems";
-describe("configureWorkItemTools", () => {
-    let server;
-    let tokenProvider;
-    let connectionProvider;
-    let mockConnection;
-    let mockWorkApi;
-    let mockWorkItemTrackingApi;
-    beforeEach(() => {
-        server = { tool: jest.fn() };
-        tokenProvider = jest.fn();
-        mockWorkApi = {
-            getBacklogs: jest.fn(),
-            getPredefinedQueryResults: jest.fn(),
-            getTeamIterations: jest.fn(),
-            getIterationWorkItems: jest.fn(),
-        };
-        mockWorkItemTrackingApi = {
-            getWorkItemsBatch: jest.fn(),
-            getWorkItem: jest.fn(),
-            getComments: jest.fn(),
-            addComment: jest.fn(),
-            updateWorkItem: jest.fn(),
-            createWorkItem: jest.fn(),
-            getWorkItemType: jest.fn(),
-            getQuery: jest.fn(),
-            queryById: jest.fn(),
-        };
-        mockConnection = {
-            getWorkApi: jest.fn().mockResolvedValue(mockWorkApi),
-            getWorkItemTrackingApi: jest.fn().mockResolvedValue(mockWorkItemTrackingApi),
-        };
-        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
-    });
-    describe("tool registration", () => {
-        it("registers core tools on the server", () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            expect(server.tool).toHaveBeenCalled();
-        });
-    });
-    describe("list_backlogs tool", () => {
-        it("should call getBacklogs API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_backlogs");
-            if (!call)
-                throw new Error("ado_list_backlogs tool not registered");
-            const [, , , handler] = call;
-            mockWorkApi.getBacklogs.mockResolvedValue([
-                {
-                    id: "eb6e4656-77fc-42a1-9181-4c6d8e9da5d1",
-                    name: "Fabrikam-Fiber-TFVC",
-                    description: "Team Foundation Version Control projects.",
-                    url: "https://dev.azure.com/fabrikam/_apis/projects/eb6e4656-77fc-42a1-9181-4c6d8e9da5d1",
-                    state: "wellFormed",
-                },
-                {
-                    id: "6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c",
-                    name: "Fabrikam-Fiber-Git",
-                    description: "Git projects",
-                    url: "https://dev.azure.com/fabrikam/_apis/projects/6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c",
-                    state: "wellFormed",
-                },
-                {
-                    id: "281f9a5b-af0d-49b4-a1df-fe6f5e5f84d0",
-                    name: "TestGit",
-                    url: "https://dev.azure.com/fabrikam/_apis/projects/281f9a5b-af0d-49b4-a1df-fe6f5e5f84d0",
-                    state: "wellFormed",
-                },
-            ]);
-            const params = {
-                project: "Contoso",
-                team: "Fabrikam",
-            };
-            const result = await handler(params);
-            expect(mockWorkApi.getBacklogs).toHaveBeenCalledWith({ project: "Contoso", team: "Fabrikam" });
-            expect(result.content[0].text).toBe(JSON.stringify([
-                {
-                    id: "eb6e4656-77fc-42a1-9181-4c6d8e9da5d1",
-                    name: "Fabrikam-Fiber-TFVC",
-                    description: "Team Foundation Version Control projects.",
-                    url: "https://dev.azure.com/fabrikam/_apis/projects/eb6e4656-77fc-42a1-9181-4c6d8e9da5d1",
-                    state: "wellFormed",
-                },
-                {
-                    id: "6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c",
-                    name: "Fabrikam-Fiber-Git",
-                    description: "Git projects",
-                    url: "https://dev.azure.com/fabrikam/_apis/projects/6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c",
-                    state: "wellFormed",
-                },
-                {
-                    id: "281f9a5b-af0d-49b4-a1df-fe6f5e5f84d0",
-                    name: "TestGit",
-                    url: "https://dev.azure.com/fabrikam/_apis/projects/281f9a5b-af0d-49b4-a1df-fe6f5e5f84d0",
-                    state: "wellFormed",
-                },
-            ], null, 2));
-        });
-    });
-});

package/dist/tools/workitems.test.js

@@ -1,530 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { describe, expect, it } from "@jest/globals";
-import { configureWorkItemTools } from "../../../src/tools/workitems";
-import { _mockBacklogs, _mockQuery, _mockQueryResults, _mockWorkItem, _mockWorkItemComment, _mockWorkItemComments, _mockWorkItems, _mockWorkItemsForIteration, _mockWorkItemType } from "../../mocks/work-items";
-describe("configureWorkItemTools", () => {
-    let server;
-    let tokenProvider;
-    let connectionProvider;
-    let mockConnection;
-    let mockWorkApi;
-    let mockWorkItemTrackingApi;
-    beforeEach(() => {
-        server = { tool: jest.fn() };
-        tokenProvider = jest.fn();
-        mockWorkApi = {
-            getBacklogs: jest.fn(),
-            getBacklogLevelWorkItems: jest.fn(),
-            getPredefinedQueryResults: jest.fn(),
-            getTeamIterations: jest.fn(),
-            getIterationWorkItems: jest.fn(),
-        };
-        mockWorkItemTrackingApi = {
-            getWorkItemsBatch: jest.fn(),
-            getWorkItem: jest.fn(),
-            getComments: jest.fn(),
-            addComment: jest.fn(),
-            updateWorkItem: jest.fn(),
-            createWorkItem: jest.fn(),
-            getWorkItemType: jest.fn(),
-            getQuery: jest.fn(),
-            queryById: jest.fn(),
-        };
-        mockConnection = {
-            getWorkApi: jest.fn().mockResolvedValue(mockWorkApi),
-            getWorkItemTrackingApi: jest.fn().mockResolvedValue(mockWorkItemTrackingApi),
-        };
-        connectionProvider = jest.fn().mockResolvedValue(mockConnection);
-    });
-    describe("tool registration", () => {
-        it("registers core tools on the server", () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            expect(server.tool).toHaveBeenCalled();
-        });
-    });
-    describe("list_backlogs tool", () => {
-        it("should call getBacklogs API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_backlogs");
-            if (!call)
-                throw new Error("ado_list_backlogs tool not registered");
-            const [, , , handler] = call;
-            mockWorkApi.getBacklogs.mockResolvedValue([
-                _mockBacklogs,
-            ]);
-            const params = {
-                project: "Contoso",
-                team: "Fabrikam",
-            };
-            const result = await handler(params);
-            expect(mockWorkApi.getBacklogs).toHaveBeenCalledWith({
-                project: params.project,
-                team: params.team,
-            });
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockBacklogs,
-            ], null, 2));
-        });
-    });
-    describe("list_backlog_work_items tool", () => {
-        it("should call getBacklogLevelWorkItems API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_backlog_work_items");
-            if (!call)
-                throw new Error("ado_list_backlog_work_items tool not registered");
-            const [, , , handler] = call;
-            mockWorkApi.getBacklogLevelWorkItems.mockResolvedValue([
-                {
-                    workItems: [
-                        {
-                            rel: null,
-                            source: null,
-                            target: {
-                                id: 50,
-                            },
-                        },
-                        {
-                            rel: null,
-                            source: null,
-                            target: {
-                                id: 49,
-                            },
-                        },
-                    ],
-                },
-            ]);
-            const params = {
-                project: "Contoso",
-                team: "Fabrikam",
-                backlogId: "Microsoft.FeatureCategory",
-            };
-            const result = await handler(params);
-            expect(mockWorkApi.getBacklogLevelWorkItems).toHaveBeenCalledWith({ project: params.project, team: params.team }, params.backlogId);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                {
-                    workItems: [
-                        {
-                            rel: null,
-                            source: null,
-                            target: {
-                                id: 50,
-                            },
-                        },
-                        {
-                            rel: null,
-                            source: null,
-                            target: {
-                                id: 49,
-                            },
-                        },
-                    ],
-                }
-            ], null, 2));
-        });
-    });
-    describe("my_work_items tool", () => {
-        it("should call getPredefinedQueryResults API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_my_work_items");
-            if (!call)
-                throw new Error("ado_my_work_items tool not registered");
-            const [, , , handler] = call;
-            mockWorkApi.getPredefinedQueryResults.mockResolvedValue([
-                {
-                    id: "assignedtome",
-                    name: "Assigned to me",
-                    url: "https://dev.azure.com/org/project/_apis/work/predefinedQueries/assignedtome",
-                    webUrl: "https://dev.azure.com/org/project/project/_workitems/assignedtome",
-                    hasMore: false,
-                    results: [
-                        {
-                            id: 115784,
-                            url: "https://dev.azure.com/org/_apis/wit/workItems/115784",
-                        },
-                        {
-                            id: 115794,
-                            url: "https://dev.azure.com/org/_apis/wit/workItems/115794",
-                        },
-                        {
-                            id: 115792,
-                            url: "https://dev.azure.com/org/_apis/wit/workItems/115792",
-                        },
-                    ],
-                },
-            ]);
-            const params = {
-                project: "Contoso",
-                type: "assignedtome",
-                top: 10,
-                includeCompleted: false,
-            };
-            const result = await handler(params);
-            expect(mockWorkApi.getPredefinedQueryResults).toHaveBeenCalledWith(params.project, params.type, params.top, params.includeCompleted);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                {
-                    id: "assignedtome",
-                    name: "Assigned to me",
-                    url: "https://dev.azure.com/org/project/_apis/work/predefinedQueries/assignedtome",
-                    webUrl: "https://dev.azure.com/org/project/project/_workitems/assignedtome",
-                    hasMore: false,
-                    results: [
-                        {
-                            id: 115784,
-                            url: "https://dev.azure.com/org/_apis/wit/workItems/115784",
-                        },
-                        {
-                            id: 115794,
-                            url: "https://dev.azure.com/org/_apis/wit/workItems/115794",
-                        },
-                        {
-                            id: 115792,
-                            url: "https://dev.azure.com/org/_apis/wit/workItems/115792",
-                        },
-                    ],
-                },
-            ], null, 2));
-        });
-    });
-    describe("getWorkItemsBatch tool", () => {
-        it("should call workItemApi.getWorkItemsBatch API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_items_batch_by_ids");
-            if (!call)
-                throw new Error("ado_get_work_items_batch_by_ids tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.getWorkItemsBatch.mockResolvedValue([
-                _mockWorkItems,
-            ]);
-            const params = {
-                ids: [297, 299, 300],
-                project: "Contoso",
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.getWorkItemsBatch).toHaveBeenCalledWith({
-                ids: params.ids,
-                fields: ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags"]
-            }, params.project);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItems,
-            ], null, 2));
-        });
-    });
-    describe("get_work_item tool", () => {
-        it("should call workItemApi.getWorkItem API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_item");
-            if (!call)
-                throw new Error("ado_get_work_item tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.getWorkItem.mockResolvedValue([
-                _mockWorkItem
-            ]);
-            const params = {
-                id: 12,
-                fields: undefined,
-                asOf: undefined,
-                expand: "none",
-                project: "Contoso",
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.getWorkItem).toHaveBeenCalledWith(params.id, params.fields, params.asOf, params.expand, params.project);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItem,
-            ], null, 2));
-        });
-    });
-    describe("list_work_item_comments tool", () => {
-        it("should call workItemApi.getComments API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_list_work_item_comments");
-            if (!call)
-                throw new Error("ado_list_work_item_comments tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.getComments.mockResolvedValue([
-                _mockWorkItemComments
-            ]);
-            const params = {
-                project: "Contoso",
-                workItemId: 299,
-                top: 10,
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.getComments).toHaveBeenCalledWith(params.project, params.workItemId, params.top);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItemComments,
-            ], null, 2));
-        });
-    });
-    describe("add_work_item_comment tool", () => {
-        it("should call workItemApi.addComment API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_add_work_item_comment");
-            if (!call)
-                throw new Error("ado_add_work_item_comment tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.addComment.mockResolvedValue([
-                _mockWorkItemComment,
-            ]);
-            const params = {
-                comment: "hello world!",
-                project: "Contoso",
-                workItemId: 299,
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.addComment).toHaveBeenCalledWith({ text: params.comment }, params.project, params.workItemId);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItemComment
-            ], null, 2));
-        });
-    });
-    describe("add_child_work_item tool", () => {
-        it("should call workItemApi.add_child_work_item API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_add_child_work_item");
-            if (!call)
-                throw new Error("ado_add_child_work_item tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.createWorkItem.mockResolvedValue([
-                _mockWorkItem,
-            ]);
-            const params = {
-                parentId: 299,
-                project: "Contoso",
-                workItemType: "Task",
-                title: "Sample task",
-                description: "This is a sample task",
-                areaPath: "Contoso\\Development",
-                iterationPath: "Contoso\\Sprint 1",
-            };
-            const document = [
-                {
-                    op: "add",
-                    path: "/fields/System.Title",
-                    value: params.title
-                },
-                {
-                    op: "add",
-                    path: "/fields/System.Description",
-                    value: params.description
-                },
-                {
-                    op: "add",
-                    path: "/relations/-",
-                    value: {
-                        rel: "System.LinkTypes.Hierarchy-Reverse",
-                        url: `undefined/${params.project}/_apis/wit/workItems/${params.parentId}`,
-                    },
-                },
-                {
-                    op: "add",
-                    path: "/fields/System.AreaPath",
-                    value: params.areaPath,
-                },
-                {
-                    op: "add",
-                    path: "/fields/System.IterationPath",
-                    value: params.iterationPath,
-                }
-            ];
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.createWorkItem).toHaveBeenCalledWith(null, document, params.project, params.workItemType);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItem
-            ], null, 2));
-        });
-    });
-    describe("link_work_item_to_pull_request tool", () => {
-        it("should call workItemApi.updateWorkItem API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_link_work_item_to_pull_request");
-            if (!call)
-                throw new Error("ado_link_work_item_to_pull_request tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.updateWorkItem.mockResolvedValue([
-                _mockWorkItem,
-            ]);
-            const params = {
-                project: "Contoso",
-                repositoryId: 12345,
-                pullRequestId: 67890,
-                workItemId: 131489,
-            };
-            const artifactPathValue = `${params.project}/${params.repositoryId}/${params.pullRequestId}`;
-            const vstfsUrl = `vstfs:///Git/PullRequestId/${encodeURIComponent(artifactPathValue)}`;
-            const document = [
-                {
-                    op: "add",
-                    path: "/relations/-",
-                    value: {
-                        rel: "ArtifactLink",
-                        url: vstfsUrl,
-                        attributes: {
-                            name: "Pull Request",
-                        },
-                    },
-                },
-            ];
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.updateWorkItem).toHaveBeenCalledWith({}, document, params.workItemId, params.project);
-            expect(result.content[0].text).toBe(JSON.stringify({
-                workItemId: 131489,
-                pullRequestId: 67890,
-                success: true,
-            }, null, 2));
-        });
-    });
-    describe("get_work_items_for_iteration tool", () => {
-        it("should call workApi.getIterationWorkItems API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_items_for_iteration");
-            if (!call)
-                throw new Error("ado_get_work_items_for_iterationt tool not registered");
-            const [, , , handler] = call;
-            mockWorkApi.getIterationWorkItems.mockResolvedValue([
-                _mockWorkItemsForIteration,
-            ]);
-            const params = {
-                project: "Contoso",
-                team: "Fabrikam",
-                iterationId: "6bfde89e-b22e-422e-814a-e8db432f5a58",
-            };
-            const result = await handler(params);
-            expect(mockWorkApi.getIterationWorkItems).toHaveBeenCalledWith({
-                project: params.project,
-                team: params.team
-            }, params.iterationId);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItemsForIteration,
-            ], null, 2));
-        });
-    });
-    describe("update_work_item tool", () => {
-        it("should call workItemApi.updateWorkItem API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_update_work_item");
-            if (!call)
-                throw new Error("ado_update_work_item tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.updateWorkItem.mockResolvedValue([
-                _mockWorkItem,
-            ]);
-            const params = {
-                id: 131489,
-                updates: [
-                    {
-                        op: "add",
-                        path: "/fields/System.Title",
-                        value: "Updated Sample Task"
-                    }
-                ]
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.updateWorkItem).toHaveBeenCalledWith(null, params.updates, params.id);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItem
-            ], null, 2));
-        });
-    });
-    describe("get_work_item_type tool", () => {
-        it("should call workItemApi.getWorkItemType API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_work_item_type");
-            if (!call)
-                throw new Error("ado_get_work_item_type tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.getWorkItemType.mockResolvedValue([
-                _mockWorkItemType,
-            ]);
-            const params = {
-                project: "Contoso",
-                workItemType: "Bug",
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.getWorkItemType).toHaveBeenCalledWith(params.project, params.workItemType);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItemType
-            ], null, 2));
-        });
-    });
-    describe("create_work_item tool", () => {
-        it("should call workItemApi.createWorkItem API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_create_work_item");
-            if (!call)
-                throw new Error("ado_create_work_item tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.createWorkItem.mockResolvedValue([
-                _mockWorkItem,
-            ]);
-            const params = {
-                project: "Contoso",
-                workItemType: "Task",
-                fields: [
-                    "System.Title", "Hello World!",
-                    "System.Description", "This is a sample task",
-                    "System.AreaPath", "Contoso\\Development",
-                ]
-            };
-            const document = Object.entries(params.fields).map(([key, value]) => ({
-                op: "add",
-                path: `/fields/${key}`,
-                value,
-            }));
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.createWorkItem).toHaveBeenCalledWith(null, document, params.project, params.workItemType);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockWorkItem
-            ], null, 2));
-        });
-    });
-    describe("get_query tool", () => {
-        it("should call workItemApi.getQuery API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_query");
-            if (!call)
-                throw new Error("ado_get_query tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.getQuery.mockResolvedValue([
-                _mockQuery,
-            ]);
-            const params = {
-                project: "Contoso",
-                query: "342f0f44-4069-46b1-a940-3d0468979ceb",
-                expand: "none",
-                depth: 1,
-                includeDeleted: false,
-                useIsoDateFormat: false,
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.getQuery).toHaveBeenCalledWith(params.project, params.query, params.expand, params.depth, params.includeDeleted, params.useIsoDateFormat);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockQuery,
-            ], null, 2));
-        });
-    });
-    describe("get_query_results_by_id tool", () => {
-        it("should call workItemApi.getQueryById API with the correct parameters and return the expected result", async () => {
-            configureWorkItemTools(server, tokenProvider, connectionProvider);
-            const call = server.tool.mock.calls.find(([toolName]) => toolName === "ado_get_query_results_by_id");
-            if (!call)
-                throw new Error("ado_get_query_results_by_id tool not registered");
-            const [, , , handler] = call;
-            mockWorkItemTrackingApi.queryById.mockResolvedValue([
-                _mockQueryResults,
-            ]);
-            const params = {
-                id: "342f0f44-4069-46b1-a940-3d0468979ceb",
-                project: "Contoso",
-                team: "Fabrikam",
-                timePrecision: false,
-                top: 50,
-            };
-            const result = await handler(params);
-            expect(mockWorkItemTrackingApi.queryById).toHaveBeenCalledWith(params.id, { project: params.project, team: params.team }, params.timePrecision, params.top);
-            expect(result.content[0].text).toBe(JSON.stringify([
-                _mockQueryResults,
-            ], null, 2));
-        });
-    });
-});