@azure-devops/mcp 2.2.2-nightly.20251121 → 2.2.2-nightly.20251126

package/dist/auth.js

@@ -3,6 +3,7 @@
 import { AzureCliCredential, ChainedTokenCredential, DefaultAzureCredential } from "@azure/identity";
 import { PublicClientApplication } from "@azure/msal-node";
 import open from "open";
+import { logger } from "./logger.js";
 const scopes = ["499b84ac-1321-427f-aa17-267ca6975798/.default"];
 class OAuthAuthenticator {
     static clientId = "0d50963b-7bb9-4fe7-94c7-a99af00b5136";
@@ -15,6 +16,10 @@ class OAuthAuthenticator {
         let authority = OAuthAuthenticator.defaultAuthority;
         if (tenantId && tenantId !== OAuthAuthenticator.zeroTenantId) {
             authority = `https://login.microsoftonline.com/${tenantId}`;
+            logger.debug(`OAuthAuthenticator: Using tenant-specific authority for tenantId='${tenantId}'`);
+        }
+        else {
+            logger.debug(`OAuthAuthenticator: Using default common authority`);
         }
         this.publicClientApp = new PublicClientApplication({
             auth: {
@@ -22,49 +27,67 @@ class OAuthAuthenticator {
                 authority,
             },
         });
+        logger.debug(`OAuthAuthenticator: Initialized with clientId='${OAuthAuthenticator.clientId}'`);
     }
     async getToken() {
         let authResult = null;
         if (this.accountId) {
+            logger.debug(`OAuthAuthenticator: Attempting silent token acquisition for cached account`);
             try {
                 authResult = await this.publicClientApp.acquireTokenSilent({
                     scopes,
                     account: this.accountId,
                 });
+                logger.debug(`OAuthAuthenticator: Successfully acquired token silently`);
             }
-            catch {
+            catch (error) {
+                logger.debug(`OAuthAuthenticator: Silent token acquisition failed: ${error instanceof Error ? error.message : String(error)}`);
                 authResult = null;
             }
         }
+        else {
+            logger.debug(`OAuthAuthenticator: No cached account available, interactive auth required`);
+        }
         if (!authResult) {
+            logger.debug(`OAuthAuthenticator: Starting interactive token acquisition`);
             authResult = await this.publicClientApp.acquireTokenInteractive({
                 scopes,
                 openBrowser: async (url) => {
+                    logger.debug(`OAuthAuthenticator: Opening browser for authentication`);
                     open(url);
                 },
             });
             this.accountId = authResult.account;
+            logger.debug(`OAuthAuthenticator: Successfully acquired token interactively, account cached`);
         }
         if (!authResult.accessToken) {
+            logger.error(`OAuthAuthenticator: Authentication result contains no access token`);
             throw new Error("Failed to obtain Azure DevOps OAuth token.");
         }
+        logger.debug(`OAuthAuthenticator: Token obtained successfully`);
         return authResult.accessToken;
     }
 }
 function createAuthenticator(type, tenantId) {
+    logger.debug(`Creating authenticator of type '${type}' with tenantId='${tenantId ?? "undefined"}'`);
     switch (type) {
         case "envvar":
+            logger.debug(`Authenticator: Using environment variable authentication (ADO_MCP_AUTH_TOKEN)`);
             // Read token from fixed environment variable
             return async () => {
+                logger.debug(`${type}: Reading token from ADO_MCP_AUTH_TOKEN environment variable`);
                 const token = process.env["ADO_MCP_AUTH_TOKEN"];
                 if (!token) {
+                    logger.error(`${type}: ADO_MCP_AUTH_TOKEN environment variable is not set or empty`);
                     throw new Error("Environment variable 'ADO_MCP_AUTH_TOKEN' is not set or empty. Please set it with a valid Azure DevOps Personal Access Token.");
                 }
+                logger.debug(`${type}: Successfully retrieved token from environment variable`);
                 return token;
             };
         case "azcli":
         case "env":
             if (type !== "env") {
+                logger.debug(`${type}: Setting AZURE_TOKEN_CREDENTIALS to 'dev' for development credential chain`);
                 process.env.AZURE_TOKEN_CREDENTIALS = "dev";
             }
             let credential = new DefaultAzureCredential(); // CodeQL [SM05138] resolved by explicitly setting AZURE_TOKEN_CREDENTIALS
@@ -76,11 +99,14 @@ function createAuthenticator(type, tenantId) {
             return async () => {
                 const result = await credential.getToken(scopes);
                 if (!result) {
+                    logger.error(`${type}: Failed to obtain token - credential.getToken returned null/undefined`);
                     throw new Error("Failed to obtain Azure DevOps token. Ensure you have Azure CLI logged or use interactive type of authentication.");
                 }
+                logger.debug(`${type}: Successfully obtained Azure DevOps token`);
                 return result.token;
             };
         default:
+            logger.debug(`Authenticator: Using OAuth interactive authentication (default)`);
             const authenticator = new OAuthAuthenticator(tenantId);
             return () => {
                 return authenticator.getToken();

package/dist/index.js

@@ -7,6 +7,7 @@ import { getBearerHandler, WebApi } from "azure-devops-node-api";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { createAuthenticator } from "./auth.js";
+import { logger } from "./logger.js";
 import { getOrgTenant } from "./org-tenants.js";
 //import { configurePrompts } from "./prompts.js";
 import { configureAllTools } from "./tools.js";
@@ -67,6 +68,16 @@ function getAzureDevOpsClient(getAzureDevOpsToken, userAgentComposer) {
     };
 }
 async function main() {
+    logger.info("Starting Azure DevOps MCP Server", {
+        organization: orgName,
+        organizationUrl: orgUrl,
+        authentication: argv.authentication,
+        tenant: argv.tenant,
+        domains: argv.domains,
+        enabledDomains: Array.from(enabledDomains),
+        version: packageVersion,
+        isCodespace: isGitHubCodespaceEnv(),
+    });
     const server = new McpServer({
         name: "Azure DevOps MCP Server",
         version: packageVersion,
@@ -89,6 +100,6 @@ async function main() {
     await server.connect(transport);
 }
 main().catch((error) => {
-    console.error("Fatal error in main():", error);
+    logger.error("Fatal error in main():", error);
     process.exit(1);
 });

package/dist/logger.js

@@ -0,0 +1,34 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import winston from "winston";
+import { setLogLevel } from "@azure/logger";
+const logLevel = process.env.LOG_LEVEL?.toLowerCase();
+if (logLevel && ["verbose", "debug", "info", "warning", "error"].includes(logLevel)) {
+    // Map Winston log levels to Azure log levels
+    const logLevelMap = {
+        verbose: "verbose",
+        debug: "info",
+        info: "info",
+        warning: "warning",
+        error: "error",
+    };
+    const azureLogLevel = logLevelMap[logLevel];
+    setLogLevel(azureLogLevel);
+}
+/**
+ * Logger utility for MCP server
+ *
+ * Since MCP servers use stdio transport for communication on stdout,
+ * we log to stderr to avoid interfering with the MCP protocol.
+ */
+export const logger = winston.createLogger({
+    level: process.env.LOG_LEVEL || "info",
+    format: winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json()),
+    transports: [
+        new winston.transports.Stream({
+            stream: process.stderr,
+        }),
+    ],
+    // Prevent Winston from exiting on error
+    exitOnError: false,
+});

package/dist/org-tenants.js

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import { readFile, writeFile } from "fs/promises";
+import { logger } from "./logger.js";
 import { homedir } from "os";
 import { join } from "path";
 const CACHE_FILE = join(homedir(), ".ado_orgs.cache");
@@ -20,7 +21,7 @@ async function trySavingCache(cache) {
         await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
     }
     catch (error) {
-        console.error("Failed to save org tenants cache:", error);
+        logger.error("Failed to save org tenants cache:", error);
     }
 }
 async function fetchTenantFromApi(orgName) {
@@ -65,11 +66,11 @@ export async function getOrgTenant(orgName) {
     catch (error) {
         // If we have an expired cache entry, return it as fallback
         if (cachedEntry) {
-            console.error(`Failed to fetch fresh tenant for ADO org ${orgName}, using expired cache entry:`, error);
+            logger.error(`Failed to fetch fresh tenant for ADO org ${orgName}, using expired cache entry:`, error);
             return cachedEntry.tenantId;
         }
         // No cache entry available, log and return empty result
-        console.error(`Failed to fetch tenant for ADO org ${orgName}:`, error);
+        logger.error(`Failed to fetch tenant for ADO org ${orgName}:`, error);
         return undefined;
     }
 }

package/dist/shared/domains.js

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import { logger } from "../logger.js";
 /**
  * Available Azure DevOps MCP domains
  */
@@ -68,7 +69,7 @@ export class DomainsManager {
                 this.enableAllDomains();
             }
             else {
-                console.error(`Error: Specified invalid domain '${domain}'. Please specify exactly as available domains: ${Object.values(Domain).join(", ")}`);
+                logger.error(`Error: Specified invalid domain '${domain}'. Please specify exactly as available domains: ${Object.values(Domain).join(", ")}`);
             }
         });
         if (this.enabledDomains.size === 0) {

package/dist/tools/pipelines.js

@@ -65,8 +65,8 @@ function configurePipelineTools(server, tokenProvider, connectionProvider, userA
     }, async ({ project, name, folder, yamlPath, repositoryType, repositoryName, repositoryId, repositoryConnectionId }) => {
         const connection = await connectionProvider();
         const pipelinesApi = await connection.getPipelinesApi();
-        let repositoryTypeEnumValue = safeEnumConvert(RepositoryType, repositoryType);
-        let repositoryPayload = {
+        const repositoryTypeEnumValue = safeEnumConvert(RepositoryType, repositoryType);
+        const repositoryPayload = {
             type: repositoryType,
         };
         if (repositoryTypeEnumValue === RepositoryType.AzureReposGit) {

package/dist/tools/repositories.js

@@ -94,6 +94,7 @@ function trimPullRequest(pr, includeDescription = false) {
             uniqueName: pr.createdBy?.uniqueName,
         },
         creationDate: pr.creationDate,
+        closedDate: pr.closedDate,
         title: pr.title,
         ...(includeDescription ? { description: pr.description ?? "" } : {}),
         isDraft: pr.isDraft,
@@ -472,14 +473,38 @@ function configureRepoTools(server, tokenProvider, connectionProvider, userAgent
         project: z.string().optional().describe("Project ID or project name (optional)"),
         iteration: z.number().optional().describe("The iteration ID for which to retrieve threads. Optional, defaults to the latest iteration."),
         baseIteration: z.number().optional().describe("The base iteration ID for which to retrieve threads. Optional, defaults to the latest base iteration."),
-        top: z.number().default(100).describe("The maximum number of threads to return."),
-        skip: z.number().default(0).describe("The number of threads to skip."),
+        top: z.number().default(100).describe("The maximum number of threads to return after filtering."),
+        skip: z.number().default(0).describe("The number of threads to skip after filtering."),
         fullResponse: z.boolean().optional().default(false).describe("Return full thread JSON response instead of trimmed data."),
-    }, async ({ repositoryId, pullRequestId, project, iteration, baseIteration, top, skip, fullResponse }) => {
+        status: z
+            .enum(getEnumKeys(CommentThreadStatus))
+            .optional()
+            .describe("Filter threads by status. If not specified, returns threads of all statuses."),
+        authorEmail: z.string().optional().describe("Filter threads by the email of the thread author (first comment author)."),
+        authorDisplayName: z.string().optional().describe("Filter threads by the display name of the thread author (first comment author). Case-insensitive partial matching."),
+    }, async ({ repositoryId, pullRequestId, project, iteration, baseIteration, top, skip, fullResponse, status, authorEmail, authorDisplayName }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         const threads = await gitApi.getThreads(repositoryId, pullRequestId, project, iteration, baseIteration);
-        const paginatedThreads = threads?.sort((a, b) => (a.id ?? 0) - (b.id ?? 0)).slice(skip, skip + top);
+        let filteredThreads = threads;
+        if (status !== undefined) {
+            const statusValue = CommentThreadStatus[status];
+            filteredThreads = filteredThreads?.filter((thread) => thread.status === statusValue);
+        }
+        if (authorEmail !== undefined) {
+            filteredThreads = filteredThreads?.filter((thread) => {
+                const firstComment = thread.comments?.[0];
+                return firstComment?.author?.uniqueName?.toLowerCase() === authorEmail.toLowerCase();
+            });
+        }
+        if (authorDisplayName !== undefined) {
+            const lowerAuthorName = authorDisplayName.toLowerCase();
+            filteredThreads = filteredThreads?.filter((thread) => {
+                const firstComment = thread.comments?.[0];
+                return firstComment?.author?.displayName?.toLowerCase().includes(lowerAuthorName);
+            });
+        }
+        const paginatedThreads = filteredThreads?.sort((a, b) => (a.id ?? 0) - (b.id ?? 0)).slice(skip, skip + top);
         if (fullResponse) {
             return {
                 content: [{ type: "text", text: JSON.stringify(paginatedThreads, null, 2) }],
@@ -584,10 +609,40 @@ function configureRepoTools(server, tokenProvider, connectionProvider, userAgent
         repositoryId: z.string().describe("The ID of the repository where the pull request is located."),
         pullRequestId: z.number().describe("The ID of the pull request to retrieve."),
         includeWorkItemRefs: z.boolean().optional().default(false).describe("Whether to reference work items associated with the pull request."),
-    }, async ({ repositoryId, pullRequestId, includeWorkItemRefs }) => {
+        includeLabels: z.boolean().optional().default(false).describe("Whether to include a summary of labels in the response."),
+    }, async ({ repositoryId, pullRequestId, includeWorkItemRefs, includeLabels }) => {
         const connection = await connectionProvider();
         const gitApi = await connection.getGitApi();
         const pullRequest = await gitApi.getPullRequest(repositoryId, pullRequestId, undefined, undefined, undefined, undefined, undefined, includeWorkItemRefs);
+        if (includeLabels) {
+            try {
+                const projectId = pullRequest.repository?.project?.id;
+                const projectName = pullRequest.repository?.project?.name;
+                const labels = await gitApi.getPullRequestLabels(repositoryId, pullRequestId, projectName, projectId);
+                const labelNames = labels.map((label) => label.name).filter((name) => name !== undefined);
+                const enhancedResponse = {
+                    ...pullRequest,
+                    labelSummary: {
+                        labels: labelNames,
+                        labelCount: labelNames.length,
+                    },
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(enhancedResponse, null, 2) }],
+                };
+            }
+            catch (error) {
+                console.warn(`Error fetching PR labels: ${error instanceof Error ? error.message : "Unknown error"}`);
+                // Fall back to the original response without labels
+                const enhancedResponse = {
+                    ...pullRequest,
+                    labelSummary: {},
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(enhancedResponse, null, 2) }],
+                };
+            }
+        }
         return {
             content: [{ type: "text", text: JSON.stringify(pullRequest, null, 2) }],
         };

package/dist/tools/test-plans.js

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import { SuiteExpand } from "azure-devops-node-api/interfaces/TestPlanInterfaces.js";
 import { z } from "zod";
 const Test_Plan_Tools = {
     create_test_plan: "testplan_create_test_plan",
@@ -9,6 +10,7 @@ const Test_Plan_Tools = {
     test_results_from_build_id: "testplan_show_test_results_from_build_id",
     list_test_cases: "testplan_list_test_cases",
     list_test_plans: "testplan_list_test_plans",
+    list_test_suites: "testplan_list_test_suites",
     create_test_suite: "testplan_create_test_suite",
 };
 function configureTestPlanTools(server, _, connectionProvider) {
@@ -18,13 +20,22 @@ function configureTestPlanTools(server, _, connectionProvider) {
         includePlanDetails: z.boolean().default(false).describe("Include detailed information about each test plan."),
         continuationToken: z.string().optional().describe("Token to continue fetching test plans from a previous request."),
     }, async ({ project, filterActivePlans, includePlanDetails, continuationToken }) => {
-        const owner = ""; //making owner an empty string untill we can figure out how to get owner id
-        const connection = await connectionProvider();
-        const testPlanApi = await connection.getTestPlanApi();
-        const testPlans = await testPlanApi.getTestPlans(project, owner, continuationToken, includePlanDetails, filterActivePlans);
-        return {
-            content: [{ type: "text", text: JSON.stringify(testPlans, null, 2) }],
-        };
+        try {
+            const owner = ""; //making owner an empty string untill we can figure out how to get owner id
+            const connection = await connectionProvider();
+            const testPlanApi = await connection.getTestPlanApi();
+            const testPlans = await testPlanApi.getTestPlans(project, owner, continuationToken, includePlanDetails, filterActivePlans);
+            return {
+                content: [{ type: "text", text: JSON.stringify(testPlans, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing test plans: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(Test_Plan_Tools.create_test_plan, "Creates a new test plan in the project.", {
         project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project where the test plan will be created."),
@@ -35,20 +46,29 @@ function configureTestPlanTools(server, _, connectionProvider) {
         endDate: z.string().optional().describe("The end date of the test plan"),
         areaPath: z.string().optional().describe("The area path for the test plan"),
     }, async ({ project, name, iteration, description, startDate, endDate, areaPath }) => {
-        const connection = await connectionProvider();
-        const testPlanApi = await connection.getTestPlanApi();
-        const testPlanToCreate = {
-            name,
-            iteration,
-            description,
-            startDate: startDate ? new Date(startDate) : undefined,
-            endDate: endDate ? new Date(endDate) : undefined,
-            areaPath,
-        };
-        const createdTestPlan = await testPlanApi.createTestPlan(testPlanToCreate, project);
-        return {
-            content: [{ type: "text", text: JSON.stringify(createdTestPlan, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const testPlanApi = await connection.getTestPlanApi();
+            const testPlanToCreate = {
+                name,
+                iteration,
+                description,
+                startDate: startDate ? new Date(startDate) : undefined,
+                endDate: endDate ? new Date(endDate) : undefined,
+                areaPath,
+            };
+            const createdTestPlan = await testPlanApi.createTestPlan(testPlanToCreate, project);
+            return {
+                content: [{ type: "text", text: JSON.stringify(createdTestPlan, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error creating test plan: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(Test_Plan_Tools.create_test_suite, "Creates a new test suite in a test plan.", {
         project: z.string().describe("Project ID or project name"),
@@ -56,20 +76,29 @@ function configureTestPlanTools(server, _, connectionProvider) {
         parentSuiteId: z.number().describe("ID of the parent suite under which the new suite will be created, if not given by user this can be id of a root suite of the test plan"),
         name: z.string().describe("Name of the child test suite"),
     }, async ({ project, planId, parentSuiteId, name }) => {
-        const connection = await connectionProvider();
-        const testPlanApi = await connection.getTestPlanApi();
-        const testSuiteToCreate = {
-            name,
-            parentSuite: {
-                id: parentSuiteId,
-                name: "",
-            },
-            suiteType: 2,
-        };
-        const createdTestSuite = await testPlanApi.createTestSuite(testSuiteToCreate, project, planId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(createdTestSuite, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const testPlanApi = await connection.getTestPlanApi();
+            const testSuiteToCreate = {
+                name,
+                parentSuite: {
+                    id: parentSuiteId,
+                    name: "",
+                },
+                suiteType: 2,
+            };
+            const createdTestSuite = await testPlanApi.createTestSuite(testSuiteToCreate, project, planId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(createdTestSuite, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error creating test suite: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(Test_Plan_Tools.add_test_cases_to_suite, "Adds existing test cases to a test suite.", {
         project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project."),
@@ -77,14 +106,23 @@ function configureTestPlanTools(server, _, connectionProvider) {
         suiteId: z.number().describe("The ID of the test suite."),
         testCaseIds: z.string().or(z.array(z.string())).describe("The ID(s) of the test case(s) to add. "),
     }, async ({ project, planId, suiteId, testCaseIds }) => {
-        const connection = await connectionProvider();
-        const testApi = await connection.getTestApi();
-        // If testCaseIds is an array, convert it to comma-separated string
-        const testCaseIdsString = Array.isArray(testCaseIds) ? testCaseIds.join(",") : testCaseIds;
-        const addedTestCases = await testApi.addTestCasesToSuite(project, planId, suiteId, testCaseIdsString);
-        return {
-            content: [{ type: "text", text: JSON.stringify(addedTestCases, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const testApi = await connection.getTestApi();
+            // If testCaseIds is an array, convert it to comma-separated string
+            const testCaseIdsString = Array.isArray(testCaseIds) ? testCaseIds.join(",") : testCaseIds;
+            const addedTestCases = await testApi.addTestCasesToSuite(project, planId, suiteId, testCaseIdsString);
+            return {
+                content: [{ type: "text", text: JSON.stringify(addedTestCases, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error adding test cases to suite: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(Test_Plan_Tools.create_test_case, "Creates a new test case work item.", {
         project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project."),
@@ -98,61 +136,70 @@ function configureTestPlanTools(server, _, connectionProvider) {
         iterationPath: z.string().optional().describe("The iteration path for the test case."),
         testsWorkItemId: z.number().optional().describe("Optional work item id that will be set as a Microsoft.VSTS.Common.TestedBy-Reverse link to the test case."),
     }, async ({ project, title, steps, priority, areaPath, iterationPath, testsWorkItemId }) => {
-        const connection = await connectionProvider();
-        const witClient = await connection.getWorkItemTrackingApi();
-        let stepsXml;
-        if (steps) {
-            stepsXml = convertStepsToXml(steps);
-        }
-        // Create JSON patch document for work item
-        const patchDocument = [];
-        patchDocument.push({
-            op: "add",
-            path: "/fields/System.Title",
-            value: title,
-        });
-        if (testsWorkItemId) {
+        try {
+            const connection = await connectionProvider();
+            const witClient = await connection.getWorkItemTrackingApi();
+            let stepsXml;
+            if (steps) {
+                stepsXml = convertStepsToXml(steps);
+            }
+            // Create JSON patch document for work item
+            const patchDocument = [];
             patchDocument.push({
                 op: "add",
-                path: "/relations/-",
-                value: {
-                    rel: "Microsoft.VSTS.Common.TestedBy-Reverse",
-                    url: `${connection.serverUrl}/${project}/_apis/wit/workItems/${testsWorkItemId}`,
-                },
+                path: "/fields/System.Title",
+                value: title,
             });
+            if (testsWorkItemId) {
+                patchDocument.push({
+                    op: "add",
+                    path: "/relations/-",
+                    value: {
+                        rel: "Microsoft.VSTS.Common.TestedBy-Reverse",
+                        url: `${connection.serverUrl}/${project}/_apis/wit/workItems/${testsWorkItemId}`,
+                    },
+                });
+            }
+            if (stepsXml) {
+                patchDocument.push({
+                    op: "add",
+                    path: "/fields/Microsoft.VSTS.TCM.Steps",
+                    value: stepsXml,
+                });
+            }
+            if (priority) {
+                patchDocument.push({
+                    op: "add",
+                    path: "/fields/Microsoft.VSTS.Common.Priority",
+                    value: priority,
+                });
+            }
+            if (areaPath) {
+                patchDocument.push({
+                    op: "add",
+                    path: "/fields/System.AreaPath",
+                    value: areaPath,
+                });
+            }
+            if (iterationPath) {
+                patchDocument.push({
+                    op: "add",
+                    path: "/fields/System.IterationPath",
+                    value: iterationPath,
+                });
+            }
+            const workItem = await witClient.createWorkItem({}, patchDocument, project, "Test Case");
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItem, null, 2) }],
+            };
         }
-        if (stepsXml) {
-            patchDocument.push({
-                op: "add",
-                path: "/fields/Microsoft.VSTS.TCM.Steps",
-                value: stepsXml,
-            });
-        }
-        if (priority) {
-            patchDocument.push({
-                op: "add",
-                path: "/fields/Microsoft.VSTS.Common.Priority",
-                value: priority,
-            });
-        }
-        if (areaPath) {
-            patchDocument.push({
-                op: "add",
-                path: "/fields/System.AreaPath",
-                value: areaPath,
-            });
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error creating test case: ${errorMessage}` }],
+                isError: true,
+            };
         }
-        if (iterationPath) {
-            patchDocument.push({
-                op: "add",
-                path: "/fields/System.IterationPath",
-                value: iterationPath,
-            });
-        }
-        const workItem = await witClient.createWorkItem({}, patchDocument, project, "Test Case");
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItem, null, 2) }],
-        };
     });
     server.tool(Test_Plan_Tools.update_test_case_steps, "Update an existing test case work item.", {
         id: z.number().describe("The ID of the test case work item to update."),
@@ -160,48 +207,134 @@ function configureTestPlanTools(server, _, connectionProvider) {
             .string()
             .describe("The steps to reproduce the test case. Make sure to format each step as '1. Step one|Expected result one\n2. Step two|Expected result two. USE '|' as the delimiter between step and expected result. DO NOT use '|' in the description of the step or expected result."),
     }, async ({ id, steps }) => {
-        const connection = await connectionProvider();
-        const witClient = await connection.getWorkItemTrackingApi();
-        let stepsXml;
-        if (steps) {
-            stepsXml = convertStepsToXml(steps);
-        }
-        // Create JSON patch document for work item
-        const patchDocument = [];
-        if (stepsXml) {
-            patchDocument.push({
-                op: "add",
-                path: "/fields/Microsoft.VSTS.TCM.Steps",
-                value: stepsXml,
-            });
+        try {
+            const connection = await connectionProvider();
+            const witClient = await connection.getWorkItemTrackingApi();
+            let stepsXml;
+            if (steps) {
+                stepsXml = convertStepsToXml(steps);
+            }
+            // Create JSON patch document for work item
+            const patchDocument = [];
+            if (stepsXml) {
+                patchDocument.push({
+                    op: "add",
+                    path: "/fields/Microsoft.VSTS.TCM.Steps",
+                    value: stepsXml,
+                });
+            }
+            const workItem = await witClient.updateWorkItem({}, patchDocument, id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItem, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error updating test case steps: ${errorMessage}` }],
+                isError: true,
+            };
         }
-        const workItem = await witClient.updateWorkItem({}, patchDocument, id);
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItem, null, 2) }],
-        };
     });
     server.tool(Test_Plan_Tools.list_test_cases, "Gets a list of test cases in the test plan.", {
         project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project."),
         planid: z.number().describe("The ID of the test plan."),
         suiteid: z.number().describe("The ID of the test suite."),
     }, async ({ project, planid, suiteid }) => {
-        const connection = await connectionProvider();
-        const coreApi = await connection.getTestPlanApi();
-        const testcases = await coreApi.getTestCaseList(project, planid, suiteid);
-        return {
-            content: [{ type: "text", text: JSON.stringify(testcases, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const coreApi = await connection.getTestPlanApi();
+            const testcases = await coreApi.getTestCaseList(project, planid, suiteid);
+            return {
+                content: [{ type: "text", text: JSON.stringify(testcases, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing test cases: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(Test_Plan_Tools.test_results_from_build_id, "Gets a list of test results for a given project and build ID.", {
         project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project."),
         buildid: z.number().describe("The ID of the build."),
     }, async ({ project, buildid }) => {
-        const connection = await connectionProvider();
-        const coreApi = await connection.getTestResultsApi();
-        const testResults = await coreApi.getTestResultDetailsForBuild(project, buildid);
-        return {
-            content: [{ type: "text", text: JSON.stringify(testResults, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const coreApi = await connection.getTestResultsApi();
+            const testResults = await coreApi.getTestResultDetailsForBuild(project, buildid);
+            return {
+                content: [{ type: "text", text: JSON.stringify(testResults, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error fetching test results: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
+    server.tool(Test_Plan_Tools.list_test_suites, "Retrieve a paginated list of test suites from an Azure DevOps project and Test Plan Id.", {
+        project: z.string().describe("The unique identifier (ID or name) of the Azure DevOps project."),
+        planId: z.number().describe("The ID of the test plan."),
+        continuationToken: z.string().optional().describe("Token to continue fetching test plans from a previous request."),
+    }, async ({ project, planId, continuationToken }) => {
+        try {
+            const connection = await connectionProvider();
+            const testPlanApi = await connection.getTestPlanApi();
+            const expand = SuiteExpand.Children;
+            const testSuites = await testPlanApi.getTestSuitesForPlan(project, planId, expand, continuationToken);
+            // The API returns a flat list where the root suite is first, followed by all nested suites
+            // We need to build a proper hierarchy by creating a map and assembling the tree
+            // Create a map of all suites by ID for quick lookup
+            const suiteMap = new Map();
+            testSuites.forEach((suite) => {
+                suiteMap.set(suite.id, {
+                    id: suite.id,
+                    name: suite.name,
+                    parentSuiteId: suite.parentSuite?.id,
+                    children: [],
+                });
+            });
+            // Build the hierarchy by linking children to parents
+            const roots = [];
+            suiteMap.forEach((suite) => {
+                if (suite.parentSuiteId && suiteMap.has(suite.parentSuiteId)) {
+                    // This is a child suite, add it to its parent's children array
+                    const parent = suiteMap.get(suite.parentSuiteId);
+                    parent.children.push(suite);
+                }
+                else {
+                    // This is a root suite (no parent or parent not in map)
+                    roots.push(suite);
+                }
+            });
+            // Clean up the output - remove parentSuiteId and empty children arrays
+            const cleanSuite = (suite) => {
+                const cleaned = {
+                    id: suite.id,
+                    name: suite.name,
+                };
+                if (suite.children && suite.children.length > 0) {
+                    cleaned.children = suite.children.map((child) => cleanSuite(child));
+                }
+                return cleaned;
+            };
+            const result = roots.map((root) => cleanSuite(root));
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing test suites: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
 }
 /*

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "2.2.2-nightly.20251121";
+export const packageVersion = "2.2.2-nightly.20251126";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-devops/mcp",
-  "version": "2.2.2-nightly.20251121",
+  "version": "2.2.2-nightly.20251126",
   "description": "MCP server for interacting with Azure DevOps",
   "license": "MIT",
   "author": "Microsoft Corporation",
@@ -43,6 +43,7 @@
     "azure-devops-extension-api": "^4.252.0",
     "azure-devops-extension-sdk": "^4.0.2",
     "azure-devops-node-api": "^15.1.0",
+    "winston": "^3.18.3",
     "yargs": "^18.0.0",
     "zod": "^3.25.63",
     "zod-to-json-schema": "^3.24.5"
@@ -50,7 +51,7 @@
   "devDependencies": {
     "@modelcontextprotocol/inspector": "^0.17.0",
     "@types/jest": "^30.0.0",
-    "@types/node": "^22",
+    "@types/node": "^22.19.1",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-header": "^3.1.1",
     "glob": "^11.0.3",