@azure-devops/mcp 2.2.2-nightly.20251112 → 2.2.2-nightly.20251113

package/README.md

@@ -114,6 +114,7 @@ Interact with these Azure DevOps services:
 - **pipelines_get_build_changes**: Get the changes associated with a specific build.
 - **pipelines_get_build_status**: Fetch the status of a specific build.
 - **pipelines_update_build_stage**: Update the stage of a specific build.
+- **pipelines_create_pipeline**: Creates a pipeline definition with YAML configuration for a given project.
 - **pipelines_get_run**: Gets a run for a particular pipeline.
 - **pipelines_list_runs**: Gets top 10000 runs for a particular pipeline.
 - **pipelines_run_pipeline**: Starts a new run of a pipeline.

package/dist/tools/pipelines.js

@@ -4,6 +4,7 @@ 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";
+import { ConfigurationType, RepositoryType } from "azure-devops-node-api/interfaces/PipelinesInterfaces.js";
 const PIPELINE_TOOLS = {
     pipelines_get_builds: "pipelines_get_builds",
     pipelines_get_build_changes: "pipelines_get_build_changes",
@@ -13,6 +14,7 @@ const PIPELINE_TOOLS = {
     pipelines_get_build_log_by_id: "pipelines_get_build_log_by_id",
     pipelines_get_build_status: "pipelines_get_build_status",
     pipelines_update_build_stage: "pipelines_update_build_stage",
+    pipelines_create_pipeline: "pipelines_create_pipeline",
     pipelines_get_run: "pipelines_get_run",
     pipelines_list_runs: "pipelines_list_runs",
     pipelines_run_pipeline: "pipelines_run_pipeline",
@@ -47,6 +49,56 @@ function configurePipelineTools(server, tokenProvider, connectionProvider, userA
             content: [{ type: "text", text: JSON.stringify(buildDefinitions, null, 2) }],
         };
     });
+    const variableSchema = z.object({
+        value: z.string().optional(),
+        isSecret: z.boolean().optional(),
+    });
+    server.tool(PIPELINE_TOOLS.pipelines_create_pipeline, "Creates a pipeline definition with YAML configuration for a given project.", {
+        project: z.string().describe("Project ID or name to run the build in."),
+        name: z.string().describe("Name of the new pipeline."),
+        folder: z.string().optional().describe("Folder path for the new pipeline. Defaults to '\\' if not specified."),
+        yamlPath: z.string().describe("The path to the pipeline's YAML file in the repository"),
+        repositoryType: z.enum(getEnumKeys(RepositoryType)).describe("The type of repository where the pipeline's YAML file is located."),
+        repositoryName: z.string().describe("The name of the repository. In case of GitHub repository, this is the full name (:owner/:repo) - e.g. octocat/Hello-World."),
+        repositoryId: z.string().optional().describe("The ID of the repository."),
+        repositoryConnectionId: z.string().optional().describe("The service connection ID for GitHub repositories. Not required for Azure Repos Git."),
+    }, 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 = {
+            type: repositoryType,
+        };
+        if (repositoryTypeEnumValue === RepositoryType.AzureReposGit) {
+            repositoryPayload.id = repositoryId;
+            repositoryPayload.name = repositoryName;
+        }
+        else if (repositoryTypeEnumValue === RepositoryType.GitHub) {
+            if (!repositoryConnectionId) {
+                throw new Error("Parameter 'repositoryConnectionId' is required for GitHub repositories.");
+            }
+            repositoryPayload.connection = { id: repositoryConnectionId };
+            repositoryPayload.fullname = repositoryName;
+        }
+        else {
+            throw new Error("Unsupported repository type");
+        }
+        const yamlConfigurationType = getEnumKeys(ConfigurationType).find((k) => ConfigurationType[k] === ConfigurationType.Yaml);
+        const createPipelineParams = {
+            name: name,
+            folder: folder || "\\",
+            configuration: {
+                type: yamlConfigurationType,
+                path: yamlPath,
+                repository: repositoryPayload,
+                variables: undefined,
+            },
+        };
+        const newPipeline = await pipelinesApi.createPipeline(createPipelineParams, project);
+        return {
+            content: [{ type: "text", text: JSON.stringify(newPipeline, null, 2) }],
+        };
+    });
     server.tool(PIPELINE_TOOLS.pipelines_get_build_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"),
@@ -154,10 +206,6 @@ function configurePipelineTools(server, tokenProvider, connectionProvider, userA
             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({

package/dist/tools/work-items.js

@@ -61,26 +61,44 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         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."),
     }, async ({ project, team }) => {
-        const connection = await connectionProvider();
-        const workApi = await connection.getWorkApi();
-        const teamContext = { project, team };
-        const backlogs = await workApi.getBacklogs(teamContext);
-        return {
-            content: [{ type: "text", text: JSON.stringify(backlogs, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project, team };
+            const backlogs = await workApi.getBacklogs(teamContext);
+            return {
+                content: [{ type: "text", text: JSON.stringify(backlogs, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing backlogs: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.list_backlog_work_items, "Retrieve a list of backlogs of for a given project, team, and backlog category", {
         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."),
         backlogId: z.string().describe("The ID of the backlog category to retrieve work items from."),
     }, async ({ project, team, backlogId }) => {
-        const connection = await connectionProvider();
-        const workApi = await connection.getWorkApi();
-        const teamContext = { project, team };
-        const workItems = await workApi.getBacklogLevelWorkItems(teamContext, backlogId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            const teamContext = { project, team };
+            const workItems = await workApi.getBacklogLevelWorkItems(teamContext, backlogId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing backlog work items: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.my_work_items, "Retrieve a list of work items relevent to the authenticated user.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
@@ -88,53 +106,71 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         top: z.number().default(50).describe("The maximum number of work items to return. Defaults to 50."),
         includeCompleted: z.boolean().default(false).describe("Whether to include completed work items. Defaults to false."),
     }, async ({ project, type, top, includeCompleted }) => {
-        const connection = await connectionProvider();
-        const workApi = await connection.getWorkApi();
-        const workItems = await workApi.getPredefinedQueryResults(project, type, top, includeCompleted);
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            const workItems = await workApi.getPredefinedQueryResults(project, type, top, includeCompleted);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error retrieving work items: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.get_work_items_batch_by_ids, "Retrieve list of work items by IDs in batch.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
         ids: z.array(z.number()).describe("The IDs of the work items to retrieve."),
         fields: z.array(z.string()).optional().describe("Optional list of fields to include in the response. If not provided, a hardcoded default set of fields will be used."),
     }, async ({ project, ids, fields }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const defaultFields = ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags", "Microsoft.VSTS.Common.StackRank", "System.AssignedTo"];
-        // If no fields are provided, use the default set of fields
-        const fieldsToUse = !fields || fields.length === 0 ? defaultFields : fields;
-        const workitems = await workItemApi.getWorkItemsBatch({ ids, fields: fieldsToUse }, project);
-        // List of identity fields that need to be transformed from objects to formatted strings
-        const identityFields = [
-            "System.AssignedTo",
-            "System.CreatedBy",
-            "System.ChangedBy",
-            "System.AuthorizedAs",
-            "Microsoft.VSTS.Common.ActivatedBy",
-            "Microsoft.VSTS.Common.ResolvedBy",
-            "Microsoft.VSTS.Common.ClosedBy",
-        ];
-        // Format identity fields to include displayName and uniqueName
-        // Removing the identity object as the response. It's too much and not needed
-        if (workitems && Array.isArray(workitems)) {
-            workitems.forEach((item) => {
-                if (item.fields) {
-                    identityFields.forEach((fieldName) => {
-                        if (item.fields && item.fields[fieldName] && typeof item.fields[fieldName] === "object") {
-                            const identityField = item.fields[fieldName];
-                            const name = identityField.displayName || "";
-                            const email = identityField.uniqueName || "";
-                            item.fields[fieldName] = `${name} <${email}>`.trim();
-                        }
-                    });
-                }
-            });
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const defaultFields = ["System.Id", "System.WorkItemType", "System.Title", "System.State", "System.Parent", "System.Tags", "Microsoft.VSTS.Common.StackRank", "System.AssignedTo"];
+            // If no fields are provided, use the default set of fields
+            const fieldsToUse = !fields || fields.length === 0 ? defaultFields : fields;
+            const workitems = await workItemApi.getWorkItemsBatch({ ids, fields: fieldsToUse }, project);
+            // List of identity fields that need to be transformed from objects to formatted strings
+            const identityFields = [
+                "System.AssignedTo",
+                "System.CreatedBy",
+                "System.ChangedBy",
+                "System.AuthorizedAs",
+                "Microsoft.VSTS.Common.ActivatedBy",
+                "Microsoft.VSTS.Common.ResolvedBy",
+                "Microsoft.VSTS.Common.ClosedBy",
+            ];
+            // Format identity fields to include displayName and uniqueName
+            // Removing the identity object as the response. It's too much and not needed
+            if (workitems && Array.isArray(workitems)) {
+                workitems.forEach((item) => {
+                    if (item.fields) {
+                        identityFields.forEach((fieldName) => {
+                            if (item.fields && item.fields[fieldName] && typeof item.fields[fieldName] === "object") {
+                                const identityField = item.fields[fieldName];
+                                const name = identityField.displayName || "";
+                                const email = identityField.uniqueName || "";
+                                item.fields[fieldName] = `${name} <${email}>`.trim();
+                            }
+                        });
+                    }
+                });
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(workitems, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error retrieving work items batch: ${errorMessage}` }],
+                isError: true,
+            };
         }
-        return {
-            content: [{ type: "text", text: JSON.stringify(workitems, null, 2) }],
-        };
     });
     server.tool(WORKITEM_TOOLS.get_work_item, "Get a single work item by ID.", {
         id: z.number().describe("The ID of the work item to retrieve."),
@@ -147,24 +183,42 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             .optional()
             .describe("Expand options include 'all', 'fields', 'links', 'none', and 'relations'. Relations can be used to get child workitems. Defaults to 'none'."),
     }, async ({ id, project, fields, asOf, expand }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const workItem = await workItemApi.getWorkItem(id, fields, asOf, expand, project);
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItem, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const workItem = await workItemApi.getWorkItem(id, fields, asOf, expand, project);
+            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 retrieving work item: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.list_work_item_comments, "Retrieve list of comments 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 comments for."),
         top: z.number().default(50).describe("Optional number of comments to retrieve. Defaults to all comments."),
     }, async ({ project, workItemId, top }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const comments = await workItemApi.getComments(project, workItemId, top);
-        return {
-            content: [{ type: "text", text: JSON.stringify(comments, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const comments = await workItemApi.getComments(project, workItemId, top);
+            return {
+                content: [{ type: "text", text: JSON.stringify(comments, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing work item comments: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.add_work_item_comment, "Add comment to a work item by ID.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
@@ -172,29 +226,38 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         comment: z.string().describe("The text of the comment to add to the work item."),
         format: z.enum(["markdown", "html"]).optional().default("html"),
     }, async ({ project, workItemId, comment, format }) => {
-        const connection = await connectionProvider();
-        const orgUrl = connection.serverUrl;
-        const accessToken = await tokenProvider();
-        const body = {
-            text: comment,
-        };
-        const formatParameter = format === "markdown" ? 0 : 1;
-        const response = await fetch(`${orgUrl}/${project}/_apis/wit/workItems/${workItemId}/comments?format=${formatParameter}&api-version=${markdownCommentsApiVersion}`, {
-            method: "POST",
-            headers: {
-                "Authorization": `Bearer ${accessToken}`,
-                "Content-Type": "application/json",
-                "User-Agent": userAgentProvider(),
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to add a work item comment: ${response.statusText}}`);
-        }
-        const comments = await response.text();
-        return {
-            content: [{ type: "text", text: comments }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const orgUrl = connection.serverUrl;
+            const accessToken = await tokenProvider();
+            const body = {
+                text: comment,
+            };
+            const formatParameter = format === "markdown" ? 0 : 1;
+            const response = await fetch(`${orgUrl}/${project}/_apis/wit/workItems/${workItemId}/comments?format=${formatParameter}&api-version=${markdownCommentsApiVersion}`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                    "User-Agent": userAgentProvider(),
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to add a work item comment: ${response.statusText}}`);
+            }
+            const comments = await response.text();
+            return {
+                content: [{ type: "text", text: comments }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error adding 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."),
@@ -207,37 +270,46 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
             .optional()
             .describe("Optional expand parameter to include additional details. Defaults to 'None'."),
     }, async ({ project, workItemId, top, skip, expand }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const revisions = await workItemApi.getRevisions(workItemId, top, skip, safeEnumConvert(WorkItemExpand, expand), project);
-        // Dynamically clean up identity objects in revision fields
-        // Identity objects typically have properties like displayName, url, _links, id, uniqueName, imageUrl, descriptor
-        if (revisions && Array.isArray(revisions)) {
-            revisions.forEach((revision) => {
-                if (revision.fields) {
-                    Object.keys(revision.fields).forEach((fieldName) => {
-                        const fieldValue = revision.fields ? revision.fields[fieldName] : undefined;
-                        // Check if this is an identity object by looking for common identity properties
-                        if (fieldValue &&
-                            typeof fieldValue === "object" &&
-                            !Array.isArray(fieldValue) &&
-                            "displayName" in fieldValue &&
-                            ("url" in fieldValue || "_links" in fieldValue || "uniqueName" in fieldValue)) {
-                            // Remove unwanted properties from identity objects
-                            delete fieldValue.url;
-                            delete fieldValue._links;
-                            delete fieldValue.id;
-                            delete fieldValue.uniqueName;
-                            delete fieldValue.imageUrl;
-                            delete fieldValue.descriptor;
-                        }
-                    });
-                }
-            });
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const revisions = await workItemApi.getRevisions(workItemId, top, skip, safeEnumConvert(WorkItemExpand, expand), project);
+            // Dynamically clean up identity objects in revision fields
+            // Identity objects typically have properties like displayName, url, _links, id, uniqueName, imageUrl, descriptor
+            if (revisions && Array.isArray(revisions)) {
+                revisions.forEach((revision) => {
+                    if (revision.fields) {
+                        Object.keys(revision.fields).forEach((fieldName) => {
+                            const fieldValue = revision.fields ? revision.fields[fieldName] : undefined;
+                            // Check if this is an identity object by looking for common identity properties
+                            if (fieldValue &&
+                                typeof fieldValue === "object" &&
+                                !Array.isArray(fieldValue) &&
+                                "displayName" in fieldValue &&
+                                ("url" in fieldValue || "_links" in fieldValue || "uniqueName" in fieldValue)) {
+                                // Remove unwanted properties from identity objects
+                                delete fieldValue.url;
+                                delete fieldValue._links;
+                                delete fieldValue.id;
+                                delete fieldValue.uniqueName;
+                                delete fieldValue.imageUrl;
+                                delete fieldValue.descriptor;
+                            }
+                        });
+                    }
+                });
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(revisions, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error listing work item revisions: ${errorMessage}` }],
+                isError: true,
+            };
         }
-        return {
-            content: [{ type: "text", text: JSON.stringify(revisions, null, 2) }],
-        };
     });
     server.tool(WORKITEM_TOOLS.add_child_work_items, "Create one or many child work items from a parent by work item type and parent id.", {
         parentId: z.number().describe("The ID of the parent work item to create a child work item under."),
@@ -413,13 +485,22 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         team: z.string().optional().describe("The name or ID of the Azure DevOps team. If not provided, the default team will be used."),
         iterationId: z.string().describe("The ID of the iteration to retrieve work items for."),
     }, async ({ project, team, iterationId }) => {
-        const connection = await connectionProvider();
-        const workApi = await connection.getWorkApi();
-        //get the work items for the current iteration
-        const workItems = await workApi.getIterationWorkItems({ project, team }, iterationId);
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workApi = await connection.getWorkApi();
+            //get the work items for the current iteration
+            const workItems = await workApi.getIterationWorkItems({ project, team }, iterationId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItems, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error retrieving work items for iteration: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.update_work_item, "Update a work item by ID with specified fields.", {
         id: z.number().describe("The ID of the work item to update."),
@@ -436,28 +517,46 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         }))
             .describe("An array of field updates to apply to the work item."),
     }, async ({ id, updates }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        // Convert operation names to lowercase for API
-        const apiUpdates = updates.map((update) => ({
-            ...update,
-            op: update.op,
-        }));
-        const updatedWorkItem = await workItemApi.updateWorkItem(null, apiUpdates, id);
-        return {
-            content: [{ type: "text", text: JSON.stringify(updatedWorkItem, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            // Convert operation names to lowercase for API
+            const apiUpdates = updates.map((update) => ({
+                ...update,
+                op: update.op,
+            }));
+            const updatedWorkItem = await workItemApi.updateWorkItem(null, apiUpdates, id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(updatedWorkItem, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error updating work item: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.get_work_item_type, "Get a specific work item type.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
         workItemType: z.string().describe("The name of the work item type to retrieve."),
     }, async ({ project, workItemType }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const workItemTypeInfo = await workItemApi.getWorkItemType(project, workItemType);
-        return {
-            content: [{ type: "text", text: JSON.stringify(workItemTypeInfo, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const workItemTypeInfo = await workItemApi.getWorkItemType(project, workItemType);
+            return {
+                content: [{ type: "text", text: JSON.stringify(workItemTypeInfo, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error retrieving work item type: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.create_work_item, "Create a new work item in a specified project and work item type.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
@@ -517,12 +616,21 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         includeDeleted: z.boolean().default(false).describe("Whether to include deleted items in the query results. Defaults to false."),
         useIsoDateFormat: z.boolean().default(false).describe("Whether to use ISO date format in the response. Defaults to false."),
     }, async ({ project, query, expand, depth, includeDeleted, useIsoDateFormat }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const queryDetails = await workItemApi.getQuery(project, query, safeEnumConvert(QueryExpand, expand), depth, includeDeleted, useIsoDateFormat);
-        return {
-            content: [{ type: "text", text: JSON.stringify(queryDetails, null, 2) }],
-        };
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const queryDetails = await workItemApi.getQuery(project, query, safeEnumConvert(QueryExpand, expand), depth, includeDeleted, useIsoDateFormat);
+            return {
+                content: [{ type: "text", text: JSON.stringify(queryDetails, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error retrieving query: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.get_query_results_by_id, "Retrieve the results of a work item query given the query ID. Supports full or IDs-only response types.", {
         id: z.string().describe("The ID of the query to retrieve results for."),
@@ -532,21 +640,30 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         top: z.number().default(50).describe("The maximum number of results to return. Defaults to 50."),
         responseType: z.enum(["full", "ids"]).default("full").describe("Response type: 'full' returns complete query results (default), 'ids' returns only work item IDs for reduced payload size."),
     }, async ({ id, project, team, timePrecision, top, responseType }) => {
-        const connection = await connectionProvider();
-        const workItemApi = await connection.getWorkItemTrackingApi();
-        const teamContext = { project, team };
-        const queryResult = await workItemApi.queryById(id, teamContext, timePrecision, top);
-        // If ids mode, extract and return only the IDs
-        if (responseType === "ids") {
-            const ids = queryResult.workItems?.map((workItem) => workItem.id).filter((id) => id !== undefined) || [];
+        try {
+            const connection = await connectionProvider();
+            const workItemApi = await connection.getWorkItemTrackingApi();
+            const teamContext = { project, team };
+            const queryResult = await workItemApi.queryById(id, teamContext, timePrecision, top);
+            // If ids mode, extract and return only the IDs
+            if (responseType === "ids") {
+                const ids = queryResult.workItems?.map((workItem) => workItem.id).filter((id) => id !== undefined) || [];
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ ids, count: ids.length }, null, 2) }],
+                };
+            }
+            // Default: return full query results
             return {
-                content: [{ type: "text", text: JSON.stringify({ ids, count: ids.length }, null, 2) }],
+                content: [{ type: "text", text: JSON.stringify(queryResult, null, 2) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                content: [{ type: "text", text: `Error retrieving query results: ${errorMessage}` }],
+                isError: true,
             };
         }
-        // Default: return full query results
-        return {
-            content: [{ type: "text", text: JSON.stringify(queryResult, null, 2) }],
-        };
     });
     server.tool(WORKITEM_TOOLS.update_work_items_batch, "Update work items in batch", {
         updates: z
@@ -559,53 +676,62 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         }))
             .describe("An array of updates to apply to work items. Each update should include the operation (op), work item ID (id), field path (path), and new value (value)."),
     }, async ({ updates }) => {
-        const connection = await connectionProvider();
-        const orgUrl = connection.serverUrl;
-        const accessToken = await tokenProvider();
-        // Extract unique IDs from the updates array
-        const uniqueIds = Array.from(new Set(updates.map((update) => update.id)));
-        const body = uniqueIds.map((id) => {
-            const workItemUpdates = updates.filter((update) => update.id === id);
-            const operations = workItemUpdates.map(({ op, path, value, format }) => ({
-                op: op,
-                path: path,
-                value: encodeFormattedValue(value, format),
-            }));
-            // Add format operations for Markdown fields
-            workItemUpdates.forEach(({ path, value, format }) => {
-                if (format === "Markdown" && value && value.length > 50) {
-                    operations.push({
-                        op: "Add",
-                        path: `/multilineFieldsFormat${path.replace("/fields", "")}`,
-                        value: "Markdown",
-                    });
-                }
+        try {
+            const connection = await connectionProvider();
+            const orgUrl = connection.serverUrl;
+            const accessToken = await tokenProvider();
+            // Extract unique IDs from the updates array
+            const uniqueIds = Array.from(new Set(updates.map((update) => update.id)));
+            const body = uniqueIds.map((id) => {
+                const workItemUpdates = updates.filter((update) => update.id === id);
+                const operations = workItemUpdates.map(({ op, path, value, format }) => ({
+                    op: op,
+                    path: path,
+                    value: encodeFormattedValue(value, format),
+                }));
+                // Add format operations for Markdown fields
+                workItemUpdates.forEach(({ path, value, format }) => {
+                    if (format === "Markdown" && value && value.length > 50) {
+                        operations.push({
+                            op: "Add",
+                            path: `/multilineFieldsFormat${path.replace("/fields", "")}`,
+                            value: "Markdown",
+                        });
+                    }
+                });
+                return {
+                    method: "PATCH",
+                    uri: `/_apis/wit/workitems/${id}?api-version=${batchApiVersion}`,
+                    headers: {
+                        "Content-Type": "application/json-patch+json",
+                    },
+                    body: operations,
+                };
             });
-            return {
+            const response = await fetch(`${orgUrl}/_apis/wit/$batch?api-version=${batchApiVersion}`, {
                 method: "PATCH",
-                uri: `/_apis/wit/workitems/${id}?api-version=${batchApiVersion}`,
                 headers: {
-                    "Content-Type": "application/json-patch+json",
+                    "Authorization": `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                    "User-Agent": userAgentProvider(),
                 },
-                body: operations,
-            };
-        });
-        const response = await fetch(`${orgUrl}/_apis/wit/$batch?api-version=${batchApiVersion}`, {
-            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 items in batch: ${response.statusText}`);
-        }
-        const result = await response.json();
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to update work items in batch: ${response.statusText}`);
+            }
+            const result = await response.json();
+            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 updating work items in batch: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.work_items_link, "Link work items together in batch.", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),
@@ -621,47 +747,56 @@ function configureWorkItemTools(server, tokenProvider, connectionProvider, userA
         }))
             .describe(""),
     }, async ({ project, updates }) => {
-        const connection = await connectionProvider();
-        const orgUrl = connection.serverUrl;
-        const accessToken = await tokenProvider();
-        // Extract unique IDs from the updates array
-        const uniqueIds = Array.from(new Set(updates.map((update) => update.id)));
-        const body = uniqueIds.map((id) => ({
-            method: "PATCH",
-            uri: `/_apis/wit/workitems/${id}?api-version=${batchApiVersion}`,
-            headers: {
-                "Content-Type": "application/json-patch+json",
-            },
-            body: updates
-                .filter((update) => update.id === id)
-                .map(({ linkToId, type, comment }) => ({
-                op: "add",
-                path: "/relations/-",
-                value: {
-                    rel: `${getLinkTypeFromName(type)}`,
-                    url: `${orgUrl}/${project}/_apis/wit/workItems/${linkToId}`,
-                    attributes: {
-                        comment: comment || "",
+        try {
+            const connection = await connectionProvider();
+            const orgUrl = connection.serverUrl;
+            const accessToken = await tokenProvider();
+            // Extract unique IDs from the updates array
+            const uniqueIds = Array.from(new Set(updates.map((update) => update.id)));
+            const body = uniqueIds.map((id) => ({
+                method: "PATCH",
+                uri: `/_apis/wit/workitems/${id}?api-version=${batchApiVersion}`,
+                headers: {
+                    "Content-Type": "application/json-patch+json",
+                },
+                body: updates
+                    .filter((update) => update.id === id)
+                    .map(({ linkToId, type, comment }) => ({
+                    op: "add",
+                    path: "/relations/-",
+                    value: {
+                        rel: `${getLinkTypeFromName(type)}`,
+                        url: `${orgUrl}/${project}/_apis/wit/workItems/${linkToId}`,
+                        attributes: {
+                            comment: comment || "",
+                        },
                     },
+                })),
+            }));
+            const response = await fetch(`${orgUrl}/_apis/wit/$batch?api-version=${batchApiVersion}`, {
+                method: "PATCH",
+                headers: {
+                    "Authorization": `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                    "User-Agent": userAgentProvider(),
                 },
-            })),
-        }));
-        const response = await fetch(`${orgUrl}/_apis/wit/$batch?api-version=${batchApiVersion}`, {
-            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 items in batch: ${response.statusText}`);
-        }
-        const result = await response.json();
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to update work items in batch: ${response.statusText}`);
+            }
+            const result = await response.json();
+            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 linking work items: ${errorMessage}` }],
+                isError: true,
+            };
+        }
     });
     server.tool(WORKITEM_TOOLS.work_item_unlink, "Remove one or many links from a single work item", {
         project: z.string().describe("The name or ID of the Azure DevOps project."),

package/dist/version.js

@@ -1 +1 @@
-export const packageVersion = "2.2.2-nightly.20251112";
+export const packageVersion = "2.2.2-nightly.20251113";

package/package.json

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