@azure-devops/mcp 2.4.0 → 2.5.0

package/README.md

@@ -1,5 +1,10 @@
 # ⭐ Azure DevOps MCP Server
 
+> [!IMPORTANT]
+> The Azure DevOps Remote MCP Server is now available in public preview for all organizations. We recommend migrating to the [Remote MCP Server](https://learn.microsoft.com/en-us/azure/devops/mcp-server/remote-mcp-server) going forward.
+>
+> [Learn more](#-remote-mcp-server)
+
 Easily install the Azure DevOps MCP Server for VS Code or VS Code Insiders:
 
 [![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-Install_AzureDevops_MCP_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ado&config=%7B%20%22type%22%3A%20%22stdio%22%2C%20%22command%22%3A%20%22npx%22%2C%20%22args%22%3A%20%5B%22-y%22%2C%20%22%40azure-devops%2Fmcp%22%2C%20%22%24%7Binput%3Aado_org%7D%22%5D%7D&inputs=%5B%7B%22id%22%3A%20%22ado_org%22%2C%20%22type%22%3A%20%22promptString%22%2C%20%22description%22%3A%20%22Azure%20DevOps%20organization%20name%20%20%28e.g.%20%27contoso%27%29%22%7D%5D)
@@ -11,13 +16,14 @@ This TypeScript project provides a **local** MCP server for Azure DevOps, enabli
 
 1. [📺 Overview](#-overview)
 2. [🏆 Expectations](#-expectations)
-3. [⚙️ Supported Tools](#️-supported-tools)
-4. [🔌 Installation & Getting Started](#-installation--getting-started)
-5. [🌏 Using Domains](#-using-domains)
-6. [📝 Troubleshooting](#-troubleshooting)
-7. [🎩 Examples & Best Practices](#-examples--best-practices)
-8. [🙋‍♀️ Frequently Asked Questions](#️-frequently-asked-questions)
-9. [📌 Contributing](#-contributing)
+3. [🚀 Remote MCP Server](#-remote-mcp-server)
+4. [⚙️ Supported Tools](#️-supported-tools)
+5. [🔌 Installation & Getting Started](#-installation--getting-started)
+6. [🌏 Using Domains](#-using-domains)
+7. [📝 Troubleshooting](#-troubleshooting)
+8. [🎩 Examples & Best Practices](#-examples--best-practices)
+9. [🙋‍♀️ Frequently Asked Questions](#️-frequently-asked-questions)
+10. [📌 Contributing](#-contributing)
 
 ## 📺 Overview
 
@@ -40,13 +46,28 @@ The Azure DevOps MCP Server brings Azure DevOps context to your agents. Try prom
 
 The Azure DevOps MCP Server is built from tools that are concise, simple, focused, and easy to use—each designed for a specific scenario. We intentionally avoid complex tools that try to do too much. The goal is to provide a thin abstraction layer over the REST APIs, making data access straightforward and letting the language model handle complex reasoning.
 
+## 🚀 Remote MCP Server
+
+The Azure DevOps **Remote MCP Server** is now available in [public preview](https://devblogs.microsoft.com/devops/azure-devops-remote-mcp-server-public-preview).
+
+Over time, the Remote MCP Server will replace this local MCP Server. We will continue to support the local server for now, but future investments will primarily focus on the remote experience.
+
+We encourage all users of the local MCP Server to begin migrating to the Remote MCP Server.
+
+If you encounter issues with tools, need support, or have a feature request, you can report an issue using the [Remote MCP Server issue template](https://github.com/microsoft/azure-devops-mcp/issues/new?template=remote-mcp-server-issue.md). During the preview period, we will track Remote MCP Server issues through this repository.
+
+> [!WARNING]
+> Internal Microsoft users of the Remote MCP Server should **not** create issues in this repository. Please use the dedicated Teams channel instead.
+
+For instructions on how to get started with the Remote MCP Server, see the [onboarding documentation](https://learn.microsoft.com/en-us/azure/devops/mcp-server/remote-mcp-server).
+
 ## ⚙️ Supported Tools
 
 See [TOOLSET.md](./docs/TOOLSET.md) for a comprehensive list.
 
 ## 🔌 Installation & Getting Started
 
-For the best experience, use Visual Studio Code and GitHub Copilot. 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.
+For the best experience, use Visual Studio Code and GitHub Copilot. See the [getting started documentation](./docs/GETTINGSTARTED.md) to use our MCP Server with other tools such as Visual Studio 2022, Claude Code, Cursor, Opencode, and Kilocode.
 
 ### Prerequisites
 

package/dist/shared/elicitations.js

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export async function elicitProject(server, connection, message) {
+    const coreApi = await connection.getCoreApi();
+    const projects = await coreApi.getProjects("wellFormed", 100, 0, undefined, false);
+    if (!projects || projects.length === 0) {
+        return { response: { content: [{ type: "text", text: "No projects found to select from." }], isError: true } };
+    }
+    const result = await server.server.elicitInput({
+        mode: "form",
+        message: message ?? "Select the Azure DevOps project.",
+        requestedSchema: {
+            type: "object",
+            properties: {
+                project: {
+                    type: "string",
+                    title: "Project",
+                    description: "The Azure DevOps project.",
+                    oneOf: projects.map((p) => ({
+                        const: p.name ?? p.id ?? "",
+                        title: p.name ?? p.id ?? "Unknown project",
+                    })),
+                },
+            },
+            required: ["project"],
+        },
+    });
+    if (result.action !== "accept" || !result.content?.project) {
+        return { response: { content: [{ type: "text", text: "Project selection cancelled." }] } };
+    }
+    return { resolved: String(result.content.project) };
+}
+export async function elicitTeam(server, connection, project, message) {
+    const coreApi = await connection.getCoreApi();
+    const teams = await coreApi.getTeams(project, undefined, undefined, undefined, false);
+    if (!teams || teams.length === 0) {
+        return { response: { content: [{ type: "text", text: "No teams found to select from." }], isError: true } };
+    }
+    const result = await server.server.elicitInput({
+        mode: "form",
+        message: message ?? "Select the team.",
+        requestedSchema: {
+            type: "object",
+            properties: {
+                team: {
+                    type: "string",
+                    title: "Team",
+                    description: "The team from a specific Azure DevOps project.",
+                    oneOf: teams.map((t) => ({
+                        const: t.name ?? t.id ?? "",
+                        title: t.name ?? t.id ?? "Unknown team",
+                    })),
+                },
+            },
+            required: ["team"],
+        },
+    });
+    if (result.action !== "accept" || !result.content?.team) {
+        return { response: { content: [{ type: "text", text: "Team selection cancelled." }] } };
+    }
+    return { resolved: String(result.content.team) };
+}

package/dist/tools/core.js

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 import { z } from "zod";
 import { searchIdentities } from "./auth.js";
+import { elicitProject } from "../shared/elicitations.js";
 const CORE_TOOLS = {
     list_project_teams: "core_list_project_teams",
     list_projects: "core_list_projects",
@@ -12,8 +13,8 @@ function filterProjectsByName(projects, projectNameFilter) {
     return projects.filter((project) => project.name?.toLowerCase().includes(lowerCaseFilter));
 }
 function configureCoreTools(server, tokenProvider, connectionProvider, userAgentProvider) {
-    server.tool(CORE_TOOLS.list_project_teams, "Retrieve a list of teams for the specified Azure DevOps project.", {
-        project: z.string().describe("The name or ID of the Azure DevOps project."),
+    server.tool(CORE_TOOLS.list_project_teams, "Retrieve a list of teams for an Azure DevOps project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
         mine: z.boolean().optional().describe("If true, only return teams that the authenticated user is a member of."),
         top: z.number().optional().describe("The maximum number of teams to return. Defaults to 100."),
         skip: z.number().optional().describe("The number of teams to skip for pagination. Defaults to 0."),
@@ -21,7 +22,14 @@ function configureCoreTools(server, tokenProvider, connectionProvider, userAgent
         try {
             const connection = await connectionProvider();
             const coreApi = await connection.getCoreApi();
-            const teams = await coreApi.getTeams(project, mine, top, skip, false);
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to list teams for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            const teams = await coreApi.getTeams(resolvedProject, mine, top, skip, false);
             if (!teams) {
                 return { content: [{ type: "text", text: "No teams found" }], isError: true };
             }

package/dist/tools/pipelines.js

@@ -5,6 +5,8 @@ import { BuildQueryOrder, DefinitionQueryOrder } from "azure-devops-node-api/int
 import { z } from "zod";
 import { StageUpdateType } from "azure-devops-node-api/interfaces/BuildInterfaces.js";
 import { ConfigurationType, RepositoryType } from "azure-devops-node-api/interfaces/PipelinesInterfaces.js";
+import { mkdirSync, createWriteStream } from "fs";
+import { join, resolve } from "path";
 const PIPELINE_TOOLS = {
     pipelines_get_builds: "pipelines_get_builds",
     pipelines_get_build_changes: "pipelines_get_build_changes",
@@ -18,6 +20,8 @@ const PIPELINE_TOOLS = {
     pipelines_get_run: "pipelines_get_run",
     pipelines_list_runs: "pipelines_list_runs",
     pipelines_run_pipeline: "pipelines_run_pipeline",
+    pipelines_list_artifacts: "pipelines_list_artifacts",
+    pipelines_download_artifact: "pipelines_download_artifact",
 };
 function configurePipelineTools(server, tokenProvider, connectionProvider, userAgentProvider) {
     server.tool(PIPELINE_TOOLS.pipelines_get_build_definitions, "Retrieves a list of build definitions for a given project.", {
@@ -315,5 +319,68 @@ function configurePipelineTools(server, tokenProvider, connectionProvider, userA
             content: [{ type: "text", text: JSON.stringify(updatedBuild, null, 2) }],
         };
     });
+    server.tool(PIPELINE_TOOLS.pipelines_list_artifacts, "Lists artifacts for a given build.", {
+        project: z.string().describe("The name or ID of the project."),
+        buildId: z.number().describe("The ID of the build."),
+    }, async ({ project, buildId }) => {
+        const connection = await connectionProvider();
+        const buildApi = await connection.getBuildApi();
+        const artifacts = await buildApi.getArtifacts(project, buildId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(artifacts, null, 2) }],
+        };
+    });
+    server.tool(PIPELINE_TOOLS.pipelines_download_artifact, "Downloads a pipeline artifact.", {
+        project: z.string().describe("The name or ID of the project."),
+        buildId: z.number().describe("The ID of the build."),
+        artifactName: z.string().describe("The name of the artifact to download."),
+        destinationPath: z.string().optional().describe("The local path to download the artifact to. If not provided, returns binary content as base64."),
+    }, async ({ project, buildId, artifactName, destinationPath }) => {
+        const connection = await connectionProvider();
+        const buildApi = await connection.getBuildApi();
+        const artifact = await buildApi.getArtifact(project, buildId, artifactName);
+        if (!artifact) {
+            return {
+                content: [{ type: "text", text: `Artifact ${artifactName} not found in build ${buildId}.` }],
+            };
+        }
+        const fileStream = await buildApi.getArtifactContentZip(project, buildId, artifactName);
+        // If destinationPath is provided, save to disk
+        if (destinationPath) {
+            const fullDestinationPath = resolve(destinationPath);
+            mkdirSync(fullDestinationPath, { recursive: true });
+            const fileDestinationPath = join(fullDestinationPath, `${artifactName}.zip`);
+            const writeStream = createWriteStream(fileDestinationPath);
+            await new Promise((resolve, reject) => {
+                fileStream.pipe(writeStream);
+                fileStream.on("end", () => resolve());
+                fileStream.on("error", (err) => reject(err));
+            });
+            return {
+                content: [{ type: "text", text: `Artifact ${artifactName} downloaded to ${destinationPath}.` }],
+            };
+        }
+        // Otherwise, return binary content as base64
+        const chunks = [];
+        await new Promise((resolve, reject) => {
+            fileStream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+            fileStream.on("end", () => resolve());
+            fileStream.on("error", (err) => reject(err));
+        });
+        const buffer = Buffer.concat(chunks);
+        const base64Data = buffer.toString("base64");
+        return {
+            content: [
+                {
+                    type: "resource",
+                    resource: {
+                        uri: `data:application/zip;base64,${base64Data}`,
+                        mimeType: "application/zip",
+                        text: base64Data,
+                    },
+                },
+            ],
+        };
+    });
 }
 export { PIPELINE_TOOLS, configurePipelineTools };

package/dist/tools/repositories.js

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { PullRequestStatus, GitVersionType, GitPullRequestQueryType, CommentThreadStatus, GitPullRequestMergeStrategy, } from "azure-devops-node-api/interfaces/GitInterfaces.js";
+import { PullRequestStatus, GitVersionType, GitPullRequestQueryType, CommentThreadStatus, GitPullRequestMergeStrategy, VersionControlRecursionType, } from "azure-devops-node-api/interfaces/GitInterfaces.js";
 import { z } from "zod";
 import { getCurrentUserDetails, getUserIdFromEmail } from "./auth.js";
 import { getEnumKeys } from "../utils.js";
@@ -23,6 +23,8 @@ const REPO_TOOLS = {
     update_pull_request_thread: "repo_update_pull_request_thread",
     search_commits: "repo_search_commits",
     list_pull_requests_by_commits: "repo_list_pull_requests_by_commits",
+    vote_pull_request: "repo_vote_pull_request",
+    list_directory: "repo_list_directory",
 };
 function branchesFilterOutIrrelevantProperties(branches, top) {
     return branches
@@ -103,6 +105,21 @@ function trimPullRequest(pr, includeDescription = false) {
         project: pr.repository?.project?.name,
     };
 }
+// Helper function to build a version descriptor from branch or commit
+function buildVersionDescriptor(version, versionType) {
+    if (!version) {
+        return undefined;
+    }
+    const versionTypeMap = {
+        Branch: GitVersionType.Branch,
+        Commit: GitVersionType.Commit,
+        Tag: GitVersionType.Tag,
+    };
+    return {
+        version: version,
+        versionType: versionTypeMap[versionType || "Branch"] ?? GitVersionType.Branch,
+    };
+}
 function configureRepoTools(server, tokenProvider, connectionProvider, userAgentProvider) {
     server.tool(REPO_TOOLS.create_pull_request, "Create a new pull request.", {
         repositoryId: z.string().describe("The ID of the repository where the pull request will be created."),
@@ -127,7 +144,7 @@ function configureRepoTools(server, tokenProvider, connectionProvider, userAgent
                 }
                 : undefined;
             const labelDefinitions = labels ? labels.map((label) => ({ name: label })) : undefined;
-            const pullRequest = await gitApi.createPullRequest({
+            let pullRequest = await gitApi.createPullRequest({
                 sourceRefName,
                 targetRefName,
                 title,
@@ -136,7 +153,19 @@ function configureRepoTools(server, tokenProvider, connectionProvider, userAgent
                 workItemRefs: workItemRefs,
                 forkSource,
                 labels: labelDefinitions,
+                supportsIterations: true,
             }, repositoryId);
+            if (!pullRequest) {
+                const prs = await gitApi.getPullRequests(repositoryId, { sourceRefName, targetRefName, status: PullRequestStatus.Active }, undefined, undefined, 0, 1);
+                if (prs && prs.length > 0) {
+                    pullRequest = prs[0];
+                }
+                else {
+                    return {
+                        content: [{ type: "text", text: "Pull request created but API returned no data." }],
+                    };
+                }
+            }
             const trimmedPullRequest = trimPullRequest(pullRequest, true);
             return {
                 content: [{ type: "text", text: JSON.stringify(trimmedPullRequest, null, 2) }],
@@ -738,15 +767,18 @@ function configureRepoTools(server, tokenProvider, connectionProvider, userAgent
         }
     });
     server.tool(REPO_TOOLS.get_pull_request_by_id, "Get a pull request by its ID.", {
-        repositoryId: z.string().describe("The ID of the repository where the pull request is located."),
+        repositoryId: z
+            .string()
+            .describe("The ID or name of the repository where the pull request is located. When using a repository name instead of a GUID, the project parameter must also be provided."),
         pullRequestId: z.number().describe("The ID of the pull request to retrieve."),
+        project: z.string().optional().describe("Project ID or project name. Required when repositoryId is a repository name instead of a GUID."),
         includeWorkItemRefs: z.boolean().optional().default(false).describe("Whether to reference work items associated with the pull request."),
         includeLabels: z.boolean().optional().default(false).describe("Whether to include a summary of labels in the response."),
-    }, async ({ repositoryId, pullRequestId, includeWorkItemRefs, includeLabels }) => {
+    }, async ({ repositoryId, pullRequestId, project, includeWorkItemRefs, includeLabels }) => {
         try {
             const connection = await connectionProvider();
             const gitApi = await connection.getGitApi();
-            const pullRequest = await gitApi.getPullRequest(repositoryId, pullRequestId, undefined, undefined, undefined, undefined, undefined, includeWorkItemRefs);
+            const pullRequest = await gitApi.getPullRequest(repositoryId, pullRequestId, project, undefined, undefined, undefined, undefined, includeWorkItemRefs);
             if (includeLabels) {
                 try {
                     const projectId = pullRequest.repository?.project?.id;
@@ -1149,5 +1181,100 @@ function configureRepoTools(server, tokenProvider, connectionProvider, userAgent
             };
         }
     });
+    server.tool(REPO_TOOLS.vote_pull_request, "Cast a vote on a pull request. Automatically adds the current user as a reviewer if they are not already one.", {
+        repositoryId: z.string().describe("The ID of the repository."),
+        pullRequestId: z.number().describe("The ID of the pull request."),
+        vote: z.enum(["Approved", "ApprovedWithSuggestions", "NoVote", "WaitingForAuthor", "Rejected"]).describe("The vote to cast: Approved(10), Suggestions(5), None(0), Waiting(-5), Rejected(-10)."),
+    }, async ({ repositoryId, pullRequestId, vote }) => {
+        const connection = await connectionProvider();
+        const gitApi = await connection.getGitApi();
+        const userDetails = await getCurrentUserDetails(tokenProvider, connectionProvider, userAgentProvider);
+        const userId = userDetails.authenticatedUser.id;
+        if (!userId) {
+            throw new Error("Could not determine authenticated user ID.");
+        }
+        const voteMap = {
+            Approved: 10,
+            ApprovedWithSuggestions: 5,
+            NoVote: 0,
+            WaitingForAuthor: -5,
+            Rejected: -10,
+        };
+        await gitApi.createPullRequestReviewer({ vote: voteMap[vote], id: userId }, repositoryId, pullRequestId, userId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Successfully cast vote '${vote}' on PR #${pullRequestId}.`,
+                },
+            ],
+        };
+    });
+    server.tool(REPO_TOOLS.list_directory, "List files and folders in a directory within a repository. Useful for exploring the structure of a codebase or finding related files.", {
+        repositoryId: z.string().describe("The ID or name of the repository."),
+        path: z.string().optional().default("/").describe("The directory path to list (e.g., '/src' or '/src/components'). Defaults to repository root."),
+        project: z.string().optional().describe("Project ID or name. Required if repositoryId is a name rather than a GUID."),
+        version: z.string().optional().describe("The version identifier - branch name (e.g., 'main'), tag name, or commit SHA. Defaults to the repository's default branch."),
+        versionType: z.enum(["Branch", "Commit", "Tag"]).optional().default("Branch").describe("The type of version identifier: 'Branch', 'Commit', or 'Tag'. Defaults to 'Branch'."),
+        recursive: z.boolean().optional().default(false).describe("Whether to list items recursively. Defaults to false."),
+        recursionDepth: z.number().optional().default(1).describe("Maximum depth for recursive listing (1-10). Only applies when recursive is true. Defaults to 1."),
+    }, async ({ repositoryId, path, project, version, versionType, recursive, recursionDepth }) => {
+        try {
+            const connection = await connectionProvider();
+            const gitApi = await connection.getGitApi();
+            const versionDescriptor = buildVersionDescriptor(version, versionType);
+            const clampedDepth = Math.min(Math.max(recursionDepth || 1, 1), 10);
+            let recursionType = VersionControlRecursionType.OneLevel;
+            if (recursive) {
+                recursionType = VersionControlRecursionType.Full;
+            }
+            const items = await gitApi.getItems(repositoryId, project, path, recursionType, true, false, false, false, versionDescriptor);
+            if (!items || items.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No items found at path: ${path}` }],
+                };
+            }
+            let filteredItems = items;
+            if (recursive && clampedDepth < 10) {
+                const basePath = path === "/" ? "" : path;
+                const baseDepth = basePath.split("/").filter((p) => p).length;
+                filteredItems = items.filter((item) => {
+                    if (!item.path)
+                        return false;
+                    const itemDepth = item.path.split("/").filter((p) => p).length;
+                    return itemDepth <= baseDepth + clampedDepth;
+                });
+            }
+            const formattedItems = filteredItems.map((item) => ({
+                path: item.path,
+                isFolder: item.isFolder,
+                gitObjectType: item.gitObjectType,
+                commitId: item.commitId,
+                contentMetadata: item.contentMetadata
+                    ? {
+                        contentType: item.contentMetadata.contentType,
+                        fileName: item.contentMetadata.fileName,
+                    }
+                    : undefined,
+            }));
+            const response = {
+                count: formattedItems.length,
+                path: path,
+                recursive: recursive,
+                recursionDepth: recursive ? clampedDepth : undefined,
+                items: formattedItems,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing directory: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
 }
 export { REPO_TOOLS, configureRepoTools };

package/dist/tools/test-plans.js

@@ -76,29 +76,47 @@ 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 }) => {
-        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,
-            };
+        const maxRetries = 5;
+        const baseDelay = 500; // milliseconds
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            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";
+                // Check if it's a concurrency conflict error
+                const isConcurrencyError = errorMessage.includes("TF26071") || errorMessage.includes("got update") || errorMessage.includes("changed by someone else");
+                // If it's a concurrency error and we have retries left, wait and retry
+                if (isConcurrencyError && attempt < maxRetries) {
+                    const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 200; // Exponential backoff with jitter
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue; // Retry
+                }
+                // If not a concurrency error or out of retries, return error
+                return {
+                    content: [{ type: "text", text: `Error creating test suite: ${errorMessage}` }],
+                    isError: true,
+                };
+            }
         }
+        // This should never be reached, but TypeScript requires a return value
+        return {
+            content: [{ type: "text", text: "Error creating test suite: Maximum retries exceeded" }],
+            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."),
@@ -257,16 +275,48 @@ function configureTestPlanTools(server, _, connectionProvider) {
             };
         }
     });
-    server.tool(Test_Plan_Tools.test_results_from_build_id, "Gets a list of test results for a given project and build ID.", {
+    server.tool(Test_Plan_Tools.test_results_from_build_id, "Gets a list of test results for a given project and build ID. Can filter by test outcome (e.g. Failed, Passed, Aborted). Returns test case titles, error messages, stack traces, and outcomes. Efficiently handles builds with large numbers of test runs.", {
         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 }) => {
+        outcomes: z.array(z.string()).optional().describe("Filter results by test outcome, e.g. ['Failed', 'Passed', 'Aborted']."),
+    }, async ({ project, buildid, outcomes }) => {
         try {
             const connection = await connectionProvider();
-            const coreApi = await connection.getTestResultsApi();
-            const testResults = await coreApi.getTestResultDetailsForBuild(project, buildid);
+            const testResultsApi = await connection.getTestResultsApi();
+            // Build filter expression for outcomes if specified
+            const outcomeFilter = outcomes?.map((o) => `Outcome eq '${o}'`).join(" or ");
+            // Fetch test result details for the build in a single API call
+            // This is more efficient than getTestRuns + getTestResults per run,
+            // especially for builds with many test runs (e.g., cloud testing with one run per test case)
+            const testResultDetails = await testResultsApi.getTestResultDetailsForBuild(project, buildid, undefined, // publishContext
+            undefined, // groupBy
+            outcomeFilter, // filter by outcome
+            undefined, // orderby
+            true // shouldIncludeResults - get individual test results, not just aggregates
+            );
+            // Extract individual test results from the grouped response
+            const allResults = [];
+            if (testResultDetails.resultsForGroup) {
+                for (const group of testResultDetails.resultsForGroup) {
+                    if (group.results) {
+                        allResults.push(...group.results);
+                    }
+                }
+            }
+            // Format results to extract useful fields
+            const formattedResults = allResults.map((r) => ({
+                id: r.id,
+                testCaseTitle: r.testCaseTitle,
+                outcome: r.outcome,
+                errorMessage: r.errorMessage,
+                stackTrace: r.stackTrace,
+                automatedTestName: r.automatedTestName,
+                automatedTestStorage: r.automatedTestStorage,
+                durationInMs: r.durationInMs,
+                runId: r.testRun?.id,
+            }));
             return {
-                content: [{ type: "text", text: JSON.stringify(testResults, null, 2) }],
+                content: [{ type: "text", text: JSON.stringify(formattedResults, null, 2) }],
             };
         }
         catch (error) {

package/dist/tools/work-items.js

@@ -16,6 +16,7 @@ const WORKITEM_TOOLS = {
     list_work_item_revisions: "wit_list_work_item_revisions",
     get_work_items_for_iteration: "wit_get_work_items_for_iteration",
     add_work_item_comment: "wit_add_work_item_comment",
+    update_work_item_comment: "wit_update_work_item_comment",
     add_child_work_items: "wit_add_child_work_items",
     link_work_item_to_pull_request: "wit_link_work_item_to_pull_request",
     get_work_item_type: "wit_get_work_item_type",
@@ -259,6 +260,44 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             };
         }
     });
+    server.tool(WORKITEM_TOOLS.update_work_item_comment, "Update an existing comment on a work item by ID.", {
+        project: z.string().describe("The name or ID of the Azure DevOps project."),
+        workItemId: z.number().describe("The ID of the work item."),
+        commentId: z.number().describe("The ID of the comment to update."),
+        text: z.string().describe("The updated comment text."),
+        format: z.enum(["markdown", "html"]).optional().default("html"),
+    }, async ({ project, workItemId, commentId, text, format }) => {
+        try {
+            const connection = await connectionProvider();
+            const orgUrl = connection.serverUrl;
+            const accessToken = await tokenProvider();
+            const body = { text };
+            const formatParameter = format === "markdown" ? 0 : 1;
+            const response = await fetch(`${orgUrl}/${project}/_apis/wit/workItems/${workItemId}/comments/${commentId}?format=${formatParameter}&api-version=${markdownCommentsApiVersion}`, {
+                method: "PATCH",
+                headers: {
+                    "Authorization": `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                    "User-Agent": userAgentProvider(),
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to update work item comment: ${response.statusText}`);
+            }
+            const updatedComment = await response.text();
+            return {
+                content: [{ type: "text", text: updatedComment }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error updating work item comment: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
     server.tool(WORKITEM_TOOLS.list_work_item_revisions, "Retrieve list of revisions for a work item by ID.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
         workItemId: z.number().describe("The ID of the work item to retrieve revisions for."),

package/dist/tools/work.js

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 import { z } from "zod";
 import { TreeStructureGroup, TreeNodeStructureType } from "azure-devops-node-api/interfaces/WorkItemTrackingInterfaces.js";
+import { elicitProject, elicitTeam } from "../shared/elicitations.js";
 const WORK_TOOLS = {
     list_team_iterations: "work_list_team_iterations",
     list_iterations: "work_list_iterations",
@@ -10,22 +11,40 @@ const WORK_TOOLS = {
     get_team_capacity: "work_get_team_capacity",
     update_team_capacity: "work_update_team_capacity",
     get_iteration_capacities: "work_get_iteration_capacities",
+    get_team_settings: "work_get_team_settings",
 };
 function configureWorkTools(server, _, connectionProvider) {
-    server.tool(WORK_TOOLS.list_team_iterations, "Retrieve a list of iterations for a specific team in a project.", {
-        project: z.string().describe("The name or ID of the Azure DevOps project."),
-        team: z.string().describe("The name or ID of the Azure DevOps team."),
+    server.tool(WORK_TOOLS.list_team_iterations, "Retrieve a list of iterations for a specific team in a project. If a project or team is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        team: z.string().optional().describe("The name or ID of the Azure DevOps team. Reuse from prior context if already known. If not provided, a team selection prompt will be shown."),
         timeframe: z.enum(["current"]).optional().describe("The timeframe for which to retrieve iterations. Currently, only 'current' is supported."),
     }, async ({ project, team, timeframe }) => {
         try {
             const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to list team iterations for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            let resolvedTeam = team;
+            if (!resolvedTeam) {
+                const result = await elicitTeam(server, connection, resolvedProject, "Select the Azure DevOps team to list iterations for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedTeam = result.resolved;
+            }
             const workApi = await connection.getWorkApi();
-            const iterations = await workApi.getTeamIterations({ project, team }, timeframe);
+            const iterations = await workApi.getTeamIterations({ project: resolvedProject, team: resolvedTeam }, timeframe);
             if (!iterations) {
                 return { content: [{ type: "text", text: "No iterations found" }], isError: true };
             }
             return {
-                content: [{ type: "text", text: JSON.stringify(iterations, null, 2) }],
+                content: [
+                    { type: "text", text: `Project: ${resolvedProject}, Team: ${resolvedTeam}` },
+                    { type: "text", text: JSON.stringify(iterations, null, 2) },
+                ],
             };
         }
         catch (error) {
@@ -78,19 +97,26 @@ function configureWorkTools(server, _, connectionProvider) {
             };
         }
     });
-    server.tool(WORK_TOOLS.list_iterations, "List all iterations in a specified Azure DevOps project.", {
-        project: z.string().describe("The name or ID of the Azure DevOps project."),
+    server.tool(WORK_TOOLS.list_iterations, "List all iterations in a specified Azure DevOps project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
         depth: z.number().default(2).describe("Depth of children to fetch."),
         excludedIds: z.array(z.number()).optional().describe("An optional array of iteration IDs, and thier children, that should not be returned."),
     }, async ({ project, depth, excludedIds: ids }) => {
         try {
             const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to list iterations for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
             const workItemTrackingApi = await connection.getWorkItemTrackingApi();
             let results = [];
             if (depth === undefined) {
                 depth = 1;
             }
-            results = await workItemTrackingApi.getClassificationNodes(project, [], depth);
+            results = await workItemTrackingApi.getClassificationNodes(resolvedProject, [], depth);
             // Handle null or undefined results
             if (!results) {
                 return { content: [{ type: "text", text: "No iterations were found" }], isError: true };
@@ -165,15 +191,22 @@ function configureWorkTools(server, _, connectionProvider) {
             };
         }
     });
-    server.tool(WORK_TOOLS.get_team_capacity, "Get the team capacity of a specific team and iteration in a project.", {
-        project: z.string().describe("The name or Id of the Azure DevOps project."),
-        team: z.string().describe("The name or Id of the Azure DevOps team."),
+    server.tool(WORK_TOOLS.get_team_capacity, "Get the team capacity of a specific team and iteration in a project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or Id of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        team: z.string().describe("The name or Id of the Azure DevOps team. Reuse from prior context if already known."),
         iterationId: z.string().describe("The Iteration Id to get capacity for."),
     }, async ({ project, team, iterationId }) => {
         try {
             const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to get team capacity for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
             const workApi = await connection.getWorkApi();
-            const teamContext = { project, team };
+            const teamContext = { project: resolvedProject, team };
             const rawResults = await workApi.getCapacitiesWithIdentityRefAndTotals(teamContext, iterationId);
             if (!rawResults || rawResults.teamMembers?.length === 0) {
                 return { content: [{ type: "text", text: "No team capacity assigned to the team" }], isError: true };
@@ -271,14 +304,21 @@ function configureWorkTools(server, _, connectionProvider) {
             };
         }
     });
-    server.tool(WORK_TOOLS.get_iteration_capacities, "Get an iteration's capacity for all teams in iteration and project.", {
-        project: z.string().describe("The name or Id of the Azure DevOps project."),
+    server.tool(WORK_TOOLS.get_iteration_capacities, "Get an iteration's capacity for all teams in iteration and project. If a project is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or Id of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
         iterationId: z.string().describe("The Iteration Id to get capacity for."),
     }, async ({ project, iterationId }) => {
         try {
             const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to get iteration capacities for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
             const workApi = await connection.getWorkApi();
-            const rawResults = await workApi.getTotalIterationCapacities(project, iterationId);
+            const rawResults = await workApi.getTotalIterationCapacities(resolvedProject, iterationId);
             if (!rawResults || !rawResults.teams || rawResults.teams.length === 0) {
                 return { content: [{ type: "text", text: "No iteration capacity assigned to the teams" }], isError: true };
             }
@@ -294,5 +334,58 @@ function configureWorkTools(server, _, connectionProvider) {
             };
         }
     });
+    server.tool(WORK_TOOLS.get_team_settings, "Get team settings including default iteration, backlog iteration, and default area path for a team. If a project or team is not specified, you will be prompted to select one.", {
+        project: z.string().optional().describe("The name or ID of the Azure DevOps project. Reuse from prior context if already known. If not provided, a project selection prompt will be shown."),
+        team: z.string().optional().describe("The name or ID of the Azure DevOps team. Reuse from prior context if already known. If not provided, a team selection prompt will be shown."),
+    }, async ({ project, team }) => {
+        try {
+            const connection = await connectionProvider();
+            let resolvedProject = project;
+            if (!resolvedProject) {
+                const result = await elicitProject(server, connection, "Select the Azure DevOps project to get team settings for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedProject = result.resolved;
+            }
+            let resolvedTeam = team;
+            if (!resolvedTeam) {
+                const result = await elicitTeam(server, connection, resolvedProject, "Select the Azure DevOps team to get settings for.");
+                if ("response" in result)
+                    return result.response;
+                resolvedTeam = result.resolved;
+            }
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project: resolvedProject, team: resolvedTeam };
+            const teamSettings = await workApi.getTeamSettings(teamContext);
+            if (!teamSettings) {
+                return { content: [{ type: "text", text: "No team settings found" }], isError: true };
+            }
+            const teamFieldValues = await workApi.getTeamFieldValues(teamContext);
+            const result = {
+                backlogIteration: teamSettings.backlogIteration,
+                defaultIteration: teamSettings.defaultIteration,
+                defaultIterationMacro: teamSettings.defaultIterationMacro,
+                backlogVisibilities: teamSettings.backlogVisibilities,
+                bugsBehavior: teamSettings.bugsBehavior,
+                workingDays: teamSettings.workingDays,
+                defaultAreaPath: teamFieldValues?.defaultValue,
+                areaPathField: teamFieldValues?.field,
+                areaPaths: teamFieldValues?.values,
+            };
+            return {
+                content: [
+                    { type: "text", text: `Project: ${resolvedProject}, Team: ${resolvedTeam}` },
+                    { 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 fetching team settings: ${errorMessage}` }],
+                isError: true,
+            };
+        }
+    });
 }
 export { WORK_TOOLS, configureWorkTools };

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "2.4.0";
+export const packageVersion = "2.5.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-devops/mcp",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "mcpName": "microsoft.com/azure-devops",
   "description": "MCP server for interacting with Azure DevOps",
   "license": "MIT",
@@ -28,7 +28,7 @@
     "build": "tsc && shx chmod +x dist/*.js",
     "prepare": "npm run build && husky",
     "watch": "tsc --watch",
-    "inspect": "ALLOWED_ORIGINS=http://127.0.0.1:6274 npx @modelcontextprotocol/inspector node dist/index.js",
+    "inspect": "ALLOWED_ORIGINS=http://127.0.0.1:6274 npx @modelcontextprotocol/inspector@0.21.0 node dist/index.js",
     "start": "node -r tsconfig-paths/register dist/index.js",
     "eslint": "eslint",
     "eslint-fix": "eslint --fix",
@@ -39,8 +39,8 @@
   },
   "dependencies": {
     "@azure/identity": "^4.10.0",
-    "@azure/msal-node": "^3.6.0",
-    "@modelcontextprotocol/sdk": "1.25.2",
+    "@azure/msal-node": "^5.0.6",
+    "@modelcontextprotocol/sdk": "1.27.1",
     "azure-devops-extension-api": "^4.264.0",
     "azure-devops-extension-sdk": "^4.0.2",
     "azure-devops-node-api": "^15.1.2",
@@ -50,7 +50,6 @@
     "zod-to-json-schema": "^3.24.5"
   },
   "devDependencies": {
-    "@modelcontextprotocol/inspector": "^0.17.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.19.1",
     "eslint-config-prettier": "10.1.8",
@@ -60,12 +59,12 @@
     "jest": "^30.0.2",
     "jest-extended": "^7.0.0",
     "lint-staged": "^16.2.7",
-    "prettier": "3.7.3",
+    "prettier": "3.8.1",
     "shx": "^0.4.0",
     "ts-jest": "^29.4.6",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.0"
+    "typescript-eslint": "^8.54.0"
   },
   "lint-staged": {
     "**/*.(js|ts|jsx|tsx|json|css|md)": [

package/dist/tools/builds.js

@@ -1,271 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { apiVersion, getEnumKeys, safeEnumConvert } from "../utils.js";
-import { BuildQueryOrder, DefinitionQueryOrder } from "azure-devops-node-api/interfaces/BuildInterfaces.js";
-import { z } from "zod";
-import { StageUpdateType } from "azure-devops-node-api/interfaces/BuildInterfaces.js";
-const BUILD_TOOLS = {
-    get_builds: "build_get_builds",
-    get_changes: "build_get_changes",
-    get_definitions: "build_get_definitions",
-    get_definition_revisions: "build_get_definition_revisions",
-    get_log: "build_get_log",
-    get_log_by_id: "build_get_log_by_id",
-    get_status: "build_get_status",
-    pipelines_get_run: "pipelines_get_run",
-    pipelines_list_runs: "pipelines_list_runs",
-    pipelines_run_pipeline: "pipelines_run_pipeline",
-    update_build_stage: "build_update_build_stage",
-};
-function configureBuildTools(server, tokenProvider, connectionProvider, userAgentProvider) {
-    server.tool(BUILD_TOOLS.get_definitions, "Retrieves a list of build definitions for a given project.", {
-        project: z.string().describe("Project ID or name to get build definitions for"),
-        repositoryId: z.string().optional().describe("Repository ID to filter build definitions"),
-        repositoryType: z.enum(["TfsGit", "GitHub", "BitbucketCloud"]).optional().describe("Type of repository to filter build definitions"),
-        name: z.string().optional().describe("Name of the build definition to filter"),
-        path: z.string().optional().describe("Path of the build definition to filter"),
-        queryOrder: z
-            .enum(getEnumKeys(DefinitionQueryOrder))
-            .optional()
-            .describe("Order in which build definitions are returned"),
-        top: z.number().optional().describe("Maximum number of build definitions to return"),
-        continuationToken: z.string().optional().describe("Token for continuing paged results"),
-        minMetricsTime: z.coerce.date().optional().describe("Minimum metrics time to filter build definitions"),
-        definitionIds: z.array(z.number()).optional().describe("Array of build definition IDs to filter"),
-        builtAfter: z.coerce.date().optional().describe("Return definitions that have builds after this date"),
-        notBuiltAfter: z.coerce.date().optional().describe("Return definitions that do not have builds after this date"),
-        includeAllProperties: z.boolean().optional().describe("Whether to include all properties in the results"),
-        includeLatestBuilds: z.boolean().optional().describe("Whether to include the latest builds for each definition"),
-        taskIdFilter: z.string().optional().describe("Task ID to filter build definitions"),
-        processType: z.number().optional().describe("Process type to filter build definitions"),
-        yamlFilename: z.string().optional().describe("YAML filename to filter build definitions"),
-    }, async ({ project, repositoryId, repositoryType, name, path, queryOrder, top, continuationToken, minMetricsTime, definitionIds, builtAfter, notBuiltAfter, includeAllProperties, includeLatestBuilds, taskIdFilter, processType, yamlFilename, }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const buildDefinitions = await buildApi.getDefinitions(project, name, repositoryId, repositoryType, safeEnumConvert(DefinitionQueryOrder, queryOrder), top, continuationToken, minMetricsTime, definitionIds, path, builtAfter, notBuiltAfter, includeAllProperties, includeLatestBuilds, taskIdFilter, processType, yamlFilename);
-        return {
-            content: [{ type: "text", text: JSON.stringify(buildDefinitions, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.get_definition_revisions, "Retrieves a list of revisions for a specific build definition.", {
-        project: z.string().describe("Project ID or name to get the build definition revisions for"),
-        definitionId: z.number().describe("ID of the build definition to get revisions for"),
-    }, async ({ project, definitionId }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const revisions = await buildApi.getDefinitionRevisions(project, definitionId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(revisions, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.get_builds, "Retrieves a list of builds for a given project.", {
-        project: z.string().describe("Project ID or name to get builds for"),
-        definitions: z.array(z.number()).optional().describe("Array of build definition IDs to filter builds"),
-        queues: z.array(z.number()).optional().describe("Array of queue IDs to filter builds"),
-        buildNumber: z.string().optional().describe("Build number to filter builds"),
-        minTime: z.coerce.date().optional().describe("Minimum finish time to filter builds"),
-        maxTime: z.coerce.date().optional().describe("Maximum finish time to filter builds"),
-        requestedFor: z.string().optional().describe("User ID or name who requested the build"),
-        reasonFilter: z.number().optional().describe("Reason filter for the build (see BuildReason enum)"),
-        statusFilter: z.number().optional().describe("Status filter for the build (see BuildStatus enum)"),
-        resultFilter: z.number().optional().describe("Result filter for the build (see BuildResult enum)"),
-        tagFilters: z.array(z.string()).optional().describe("Array of tags to filter builds"),
-        properties: z.array(z.string()).optional().describe("Array of property names to include in the results"),
-        top: z.number().optional().describe("Maximum number of builds to return"),
-        continuationToken: z.string().optional().describe("Token for continuing paged results"),
-        maxBuildsPerDefinition: z.number().optional().describe("Maximum number of builds per definition"),
-        deletedFilter: z.number().optional().describe("Filter for deleted builds (see QueryDeletedOption enum)"),
-        queryOrder: z
-            .enum(getEnumKeys(BuildQueryOrder))
-            .default("QueueTimeDescending")
-            .optional()
-            .describe("Order in which builds are returned"),
-        branchName: z.string().optional().describe("Branch name to filter builds"),
-        buildIds: z.array(z.number()).optional().describe("Array of build IDs to retrieve"),
-        repositoryId: z.string().optional().describe("Repository ID to filter builds"),
-        repositoryType: z.enum(["TfsGit", "GitHub", "BitbucketCloud"]).optional().describe("Type of repository to filter builds"),
-    }, async ({ project, definitions, queues, buildNumber, minTime, maxTime, requestedFor, reasonFilter, statusFilter, resultFilter, tagFilters, properties, top, continuationToken, maxBuildsPerDefinition, deletedFilter, queryOrder, branchName, buildIds, repositoryId, repositoryType, }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const builds = await buildApi.getBuilds(project, definitions, queues, buildNumber, minTime, maxTime, requestedFor, reasonFilter, statusFilter, resultFilter, tagFilters, properties, top, continuationToken, maxBuildsPerDefinition, deletedFilter, safeEnumConvert(BuildQueryOrder, queryOrder), branchName, buildIds, repositoryId, repositoryType);
-        return {
-            content: [{ type: "text", text: JSON.stringify(builds, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.get_log, "Retrieves the logs for a specific build.", {
-        project: z.string().describe("Project ID or name to get the build log for"),
-        buildId: z.number().describe("ID of the build to get the log for"),
-    }, async ({ project, buildId }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const logs = await buildApi.getBuildLogs(project, buildId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(logs, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.get_log_by_id, "Get a specific build log by log ID.", {
-        project: z.string().describe("Project ID or name to get the build log for"),
-        buildId: z.number().describe("ID of the build to get the log for"),
-        logId: z.number().describe("ID of the log to retrieve"),
-        startLine: z.number().optional().describe("Starting line number for the log content, defaults to 0"),
-        endLine: z.number().optional().describe("Ending line number for the log content, defaults to the end of the log"),
-    }, async ({ project, buildId, logId, startLine, endLine }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const logLines = await buildApi.getBuildLogLines(project, buildId, logId, startLine, endLine);
-        return {
-            content: [{ type: "text", text: JSON.stringify(logLines, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.get_changes, "Get the changes associated with a specific build.", {
-        project: z.string().describe("Project ID or name to get the build changes for"),
-        buildId: z.number().describe("ID of the build to get changes for"),
-        continuationToken: z.string().optional().describe("Continuation token for pagination"),
-        top: z.number().default(100).describe("Number of changes to retrieve, defaults to 100"),
-        includeSourceChange: z.boolean().optional().describe("Whether to include source changes in the results, defaults to false"),
-    }, async ({ project, buildId, continuationToken, top, includeSourceChange }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const changes = await buildApi.getBuildChanges(project, buildId, continuationToken, top, includeSourceChange);
-        return {
-            content: [{ type: "text", text: JSON.stringify(changes, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.pipelines_get_run, "Gets a run for a particular pipeline.", {
-        project: z.string().describe("Project ID or name to run the build in"),
-        pipelineId: z.number().describe("ID of the pipeline to run"),
-        runId: z.number().describe("ID of the run to get"),
-    }, async ({ project, pipelineId, runId }) => {
-        const connection = await connectionProvider();
-        const pipelinesApi = await connection.getPipelinesApi();
-        const pipelineRun = await pipelinesApi.getRun(project, pipelineId, runId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(pipelineRun, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.pipelines_list_runs, "Gets top 10000 runs for a particular pipeline.", {
-        project: z.string().describe("Project ID or name to run the build in"),
-        pipelineId: z.number().describe("ID of the pipeline to run"),
-    }, async ({ project, pipelineId }) => {
-        const connection = await connectionProvider();
-        const pipelinesApi = await connection.getPipelinesApi();
-        const pipelineRuns = await pipelinesApi.listRuns(project, pipelineId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(pipelineRuns, null, 2) }],
-        };
-    });
-    const variableSchema = z.object({
-        value: z.string().optional(),
-        isSecret: z.boolean().optional(),
-    });
-    const resourcesSchema = z.object({
-        builds: z
-            .record(z.string().describe("Name of the build resource."), z.object({
-            version: z.string().optional().describe("Version of the build resource."),
-        }))
-            .optional(),
-        containers: z
-            .record(z.string().describe("Name of the container resource."), z.object({
-            version: z.string().optional().describe("Version of the container resource."),
-        }))
-            .optional(),
-        packages: z
-            .record(z.string().describe("Name of the package resource."), z.object({
-            version: z.string().optional().describe("Version of the package resource."),
-        }))
-            .optional(),
-        pipelines: z.record(z.string().describe("Name of the pipeline resource."), z.object({
-            runId: z.number().describe("Id of the source pipeline run that triggered or is referenced by this pipeline run."),
-            version: z.string().optional().describe("Version of the source pipeline run."),
-        })),
-        repositories: z
-            .record(z.string().describe("Name of the repository resource."), z.object({
-            refName: z.string().describe("Reference name, e.g., refs/heads/main."),
-            token: z.string().optional(),
-            tokenType: z.string().optional(),
-            version: z.string().optional().describe("Version of the repository resource, git commit sha."),
-        }))
-            .optional(),
-    });
-    server.tool(BUILD_TOOLS.pipelines_run_pipeline, "Starts a new run of a pipeline.", {
-        project: z.string().describe("Project ID or name to run the build in"),
-        pipelineId: z.number().describe("ID of the pipeline to run"),
-        pipelineVersion: z.number().optional().describe("Version of the pipeline to run. If not provided, the latest version will be used."),
-        previewRun: z.boolean().optional().describe("If true, returns the final YAML document after parsing templates without creating a new run."),
-        resources: resourcesSchema.optional().describe("A dictionary of resources to pass to the pipeline."),
-        stagesToSkip: z.array(z.string()).optional().describe("A list of stages to skip."),
-        templateParameters: z.record(z.string(), z.string()).optional().describe("Custom build parameters as key-value pairs"),
-        variables: z.record(z.string(), variableSchema).optional().describe("A dictionary of variables to pass to the pipeline."),
-        yamlOverride: z.string().optional().describe("YAML override for the pipeline run."),
-    }, async ({ project, pipelineId, pipelineVersion, previewRun, resources, stagesToSkip, templateParameters, variables, yamlOverride }) => {
-        if (!previewRun && yamlOverride) {
-            throw new Error("Parameter 'yamlOverride' can only be specified together with parameter 'previewRun'.");
-        }
-        const connection = await connectionProvider();
-        const pipelinesApi = await connection.getPipelinesApi();
-        const runRequest = {
-            previewRun: previewRun,
-            resources: {
-                ...resources,
-            },
-            stagesToSkip: stagesToSkip,
-            templateParameters: templateParameters,
-            variables: variables,
-            yamlOverride: yamlOverride,
-        };
-        const pipelineRun = await pipelinesApi.runPipeline(runRequest, project, pipelineId, pipelineVersion);
-        const queuedBuild = { id: pipelineRun.id };
-        const buildId = queuedBuild.id;
-        if (buildId === undefined) {
-            throw new Error("Failed to get build ID from pipeline run");
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(pipelineRun, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.get_status, "Fetches the status of a specific build.", {
-        project: z.string().describe("Project ID or name to get the build status for"),
-        buildId: z.number().describe("ID of the build to get the status for"),
-    }, async ({ project, buildId }) => {
-        const connection = await connectionProvider();
-        const buildApi = await connection.getBuildApi();
-        const build = await buildApi.getBuildReport(project, buildId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(build, null, 2) }],
-        };
-    });
-    server.tool(BUILD_TOOLS.update_build_stage, "Updates the stage of a specific build.", {
-        project: z.string().describe("Project ID or name to update the build stage for"),
-        buildId: z.number().describe("ID of the build to update"),
-        stageName: z.string().describe("Name of the stage to update"),
-        status: z.enum(getEnumKeys(StageUpdateType)).describe("New status for the stage"),
-        forceRetryAllJobs: z.boolean().default(false).describe("Whether to force retry all jobs in the stage."),
-    }, async ({ project, buildId, stageName, status, forceRetryAllJobs }) => {
-        const connection = await connectionProvider();
-        const orgUrl = connection.serverUrl;
-        const endpoint = `${orgUrl}/${project}/_apis/build/builds/${buildId}/stages/${stageName}?api-version=${apiVersion}`;
-        const token = await tokenProvider();
-        const body = {
-            forceRetryAllJobs: forceRetryAllJobs,
-            state: safeEnumConvert(StageUpdateType, status),
-        };
-        const response = await fetch(endpoint, {
-            method: "PATCH",
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${token.token}`,
-                "User-Agent": userAgentProvider(),
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(`Failed to update build stage: ${response.status} ${errorText}`);
-        }
-        const updatedBuild = await response.text();
-        return {
-            content: [{ type: "text", text: JSON.stringify(updatedBuild, null, 2) }],
-        };
-    });
-}
-export { BUILD_TOOLS, configureBuildTools };

package/dist/tools/releases.js

@@ -1,97 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-import { ReleaseDefinitionExpands, ReleaseDefinitionQueryOrder, ReleaseExpands, ReleaseStatus, ReleaseQueryOrder } from "azure-devops-node-api/interfaces/ReleaseInterfaces.js";
-import { z } from "zod";
-import { getEnumKeys, safeEnumConvert } from "../utils.js";
-const RELEASE_TOOLS = {
-    get_release_definitions: "release_get_definitions",
-    get_releases: "release_get_releases",
-};
-function configureReleaseTools(server, tokenProvider, connectionProvider) {
-    server.tool(RELEASE_TOOLS.get_release_definitions, "Retrieves list of release definitions for a given project.", {
-        project: z.string().describe("Project ID or name to get release definitions for"),
-        searchText: z.string().optional().describe("Search text to filter release definitions"),
-        expand: z
-            .enum(getEnumKeys(ReleaseDefinitionExpands))
-            .default("None")
-            .describe("Expand options for release definitions"),
-        artifactType: z.string().optional().describe("Filter by artifact type"),
-        artifactSourceId: z.string().optional().describe("Filter by artifact source ID"),
-        top: z.number().optional().describe("Number of results to return (for pagination)"),
-        continuationToken: z.string().optional().describe("Continuation token for pagination"),
-        queryOrder: z
-            .enum(getEnumKeys(ReleaseDefinitionQueryOrder))
-            .default("NameAscending")
-            .describe("Order of the results"),
-        path: z.string().optional().describe("Path to filter release definitions"),
-        isExactNameMatch: z.boolean().optional().default(false).describe("Whether to match the exact name of the release definition. Default is false."),
-        tagFilter: z.array(z.string()).optional().describe("Filter by tags associated with the release definitions"),
-        propertyFilters: z.array(z.string()).optional().describe("Filter by properties associated with the release definitions"),
-        definitionIdFilter: z.array(z.string()).optional().describe("Filter by specific release definition IDs"),
-        isDeleted: z.boolean().default(false).describe("Whether to include deleted release definitions. Default is false."),
-        searchTextContainsFolderName: z.boolean().optional().describe("Whether to include folder names in the search text"),
-    }, async ({ project, searchText, expand, artifactType, artifactSourceId, top, continuationToken, queryOrder, path, isExactNameMatch, tagFilter, propertyFilters, definitionIdFilter, isDeleted, searchTextContainsFolderName, }) => {
-        const connection = await connectionProvider();
-        const releaseApi = await connection.getReleaseApi();
-        const releaseDefinitions = await releaseApi.getReleaseDefinitions(project, searchText, safeEnumConvert(ReleaseDefinitionExpands, expand), artifactType, artifactSourceId, top, continuationToken, safeEnumConvert(ReleaseDefinitionQueryOrder, queryOrder), path, isExactNameMatch, tagFilter, propertyFilters, definitionIdFilter, isDeleted, searchTextContainsFolderName);
-        return {
-            content: [{ type: "text", text: JSON.stringify(releaseDefinitions, null, 2) }],
-        };
-    });
-    server.tool(RELEASE_TOOLS.get_releases, "Retrieves a list of releases for a given project.", {
-        project: z.string().optional().describe("Project ID or name to get releases for"),
-        definitionId: z.number().optional().describe("ID of the release definition to filter releases"),
-        definitionEnvironmentId: z.number().optional().describe("ID of the definition environment to filter releases"),
-        searchText: z.string().optional().describe("Search text to filter releases"),
-        createdBy: z.string().optional().describe("User ID or name who created the release"),
-        statusFilter: z
-            .enum(getEnumKeys(ReleaseStatus))
-            .optional()
-            .default("Active")
-            .describe("Status of the releases to filter (default: Active)"),
-        environmentStatusFilter: z.number().optional().describe("Environment status to filter releases"),
-        minCreatedTime: z.coerce
-            .date()
-            .optional()
-            .default(() => {
-            const sevenDaysAgo = new Date();
-            sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
-            return sevenDaysAgo;
-        })
-            .describe("Minimum created time for releases (default: 7 days ago)"),
-        maxCreatedTime: z.coerce
-            .date()
-            .optional()
-            .default(() => new Date())
-            .describe("Maximum created time for releases (default: now)"),
-        queryOrder: z
-            .enum(getEnumKeys(ReleaseQueryOrder))
-            .optional()
-            .default("Ascending")
-            .describe("Order in which to return releases (default: Ascending)"),
-        top: z.number().optional().describe("Number of releases to return"),
-        continuationToken: z.number().optional().describe("Continuation token for pagination"),
-        expand: z
-            .enum(getEnumKeys(ReleaseExpands))
-            .optional()
-            .default("None")
-            .describe("Expand options for releases"),
-        artifactTypeId: z.string().optional().describe("Filter releases by artifact type ID"),
-        sourceId: z.string().optional().describe("Filter releases by artifact source ID"),
-        artifactVersionId: z.string().optional().describe("Filter releases by artifact version ID"),
-        sourceBranchFilter: z.string().optional().describe("Filter releases by source branch"),
-        isDeleted: z.boolean().optional().default(false).describe("Whether to include deleted releases (default: false)"),
-        tagFilter: z.array(z.string()).optional().describe("Filter releases by tags"),
-        propertyFilters: z.array(z.string()).optional().describe("Filter releases by properties"),
-        releaseIdFilter: z.array(z.number()).optional().describe("Filter by specific release IDs"),
-        path: z.string().optional().describe("Path to filter releases"),
-    }, async ({ project, definitionId, definitionEnvironmentId, searchText, createdBy, statusFilter, environmentStatusFilter, minCreatedTime, maxCreatedTime, queryOrder, top, continuationToken, expand, artifactTypeId, sourceId, artifactVersionId, sourceBranchFilter, isDeleted, tagFilter, propertyFilters, releaseIdFilter, path, }) => {
-        const connection = await connectionProvider();
-        const releaseApi = await connection.getReleaseApi();
-        const releases = await releaseApi.getReleases(project, definitionId, definitionEnvironmentId, searchText, createdBy, safeEnumConvert(ReleaseStatus, statusFilter), environmentStatusFilter, minCreatedTime, maxCreatedTime, safeEnumConvert(ReleaseQueryOrder, queryOrder), top, continuationToken, safeEnumConvert(ReleaseExpands, expand), artifactTypeId, sourceId, artifactVersionId, sourceBranchFilter, isDeleted, tagFilter, propertyFilters, releaseIdFilter, path);
-        return {
-            content: [{ type: "text", text: JSON.stringify(releases, null, 2) }],
-        };
-    });
-}
-export { RELEASE_TOOLS, configureReleaseTools };