@smartbear/mcp 0.4.0 → 0.6.0

package/dist/{insight-hub → bugsnag}/client.js

@@ -2,16 +2,20 @@ import NodeCache from "node-cache";
 import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
 import { CurrentUserAPI, ErrorAPI, Configuration } from "./client/index.js";
-import { ProjectAPI } from "./client/api/Project.js";
 import { FilterObjectSchema, toQueryString } from "./client/api/filters.js";
+import { ProjectAPI, } from "./client/api/Project.js";
+import { getNextUrlPathFromHeader } from "./client/api/base.js";
 const HUB_PREFIX = "00000";
 const DEFAULT_DOMAIN = "bugsnag.com";
-const HUB_DOMAIN = "insighthub.smartbear.com";
+const HUB_DOMAIN = "bugsnag.smartbear.com";
 const cacheKeys = {
-    ORG: "insight_hub_org",
-    PROJECTS: "insight_hub_projects",
-    CURRENT_PROJECT: "insight_hub_current_project",
-    CURRENT_PROJECT_EVENT_FILTERS: "insight_hub_current_project_event_filters",
+    ORG: "bugsnag_org",
+    PROJECTS: "bugsnag_projects",
+    CURRENT_PROJECT: "bugsnag_current_project",
+    CURRENT_PROJECT_EVENT_FILTERS: "bugsnag_current_project_event_filters",
+    BUILD: "bugsnag_build", // + buildId
+    RELEASE: "bugsnag_release", // + releaseId
+    BUILDS_IN_RELEASE: "bugsnag_builds_in_release" // + releaseId
 };
 // Exclude certain event fields from the project event filters to improve agent usage
 const EXCLUDED_EVENT_FIELDS = new Set([
@@ -25,7 +29,7 @@ const PERMITTED_UPDATE_OPERATIONS = [
     "discard",
     "undiscard"
 ];
-export class InsightHubClient {
+export class BugsnagClient {
     currentUserApi;
     errorsApi;
     cache;
@@ -33,8 +37,8 @@ export class InsightHubClient {
     projectApiKey;
     apiEndpoint;
     appEndpoint;
-    name = "Insight Hub";
-    prefix = "insight_hub";
+    name = "BugSnag";
+    prefix = "bugsnag";
     constructor(token, projectApiKey, endpoint) {
         this.apiEndpoint = this.getEndpoint("api", projectApiKey, endpoint);
         this.appEndpoint = this.getEndpoint("app", projectApiKey, endpoint);
@@ -50,14 +54,32 @@ export class InsightHubClient {
         });
         this.currentUserApi = new CurrentUserAPI(config);
         this.errorsApi = new ErrorAPI(config);
-        this.cache = new NodeCache();
+        this.cache = new NodeCache({
+            stdTTL: 24 * 60 * 60, // default cache TTL of 24 hours
+        });
         this.projectApi = new ProjectAPI(config);
         this.projectApiKey = projectApiKey;
     }
     async initialize() {
         // Trigger caching of org and projects
-        await this.getProjects();
-        await this.getCurrentProject();
+        try {
+            await this.getProjects();
+        }
+        catch (error) {
+            // Swallow auth errors here to allow the tools to be registered for visibility, even if the token is invalid
+            console.error("Unable to connect to BugSnag APIs, the BugSnag tools will not work. Check your configured BugSnag auth token.", error);
+        }
+        if (this.projectApiKey) {
+            try {
+                await this.getCurrentProject();
+            }
+            catch (error) {
+                // Clear the project API key to allow tools to work across all projects
+                this.projectApiKey = undefined;
+                console.error("Unable to find your configured BugSnag project, the BugSnag tools will continue to work across all projects in your organization. " +
+                    "Check your configured BugSnag project API key.", error);
+            }
+        }
     }
     getHost(apiKey, subdomain) {
         if (apiKey && apiKey.startsWith(HUB_PREFIX)) {
@@ -127,10 +149,7 @@ export class InsightHubClient {
         let projects = this.cache.get(cacheKeys.PROJECTS);
         if (!projects) {
             const org = await this.getOrganization();
-            const options = {
-                paginate: true
-            };
-            const response = await this.currentUserApi.getOrganizationProjects(org.id, options);
+            const response = await this.currentUserApi.getOrganizationProjects(org.id);
             projects = response.body || [];
             this.cache.set(cacheKeys.PROJECTS, projects);
         }
@@ -192,6 +211,83 @@ export class InsightHubClient {
             return currentProject;
         }
     }
+    async listBuilds(projectId, opts) {
+        const response = await this.projectApi.listBuilds(projectId, opts);
+        const fetchedBuilds = response.body || [];
+        const nextUrl = getNextUrlPathFromHeader(response.headers, this.apiEndpoint);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedBuilds = fetchedBuilds.map((b) => this.addStabilityData(b, stabilityTargets));
+        return { builds: formattedBuilds, nextUrl };
+    }
+    async getBuild(projectId, buildId) {
+        const cacheKey = `${cacheKeys.BUILD}_${buildId}`;
+        const build = this.cache.get(cacheKey);
+        if (build)
+            return build;
+        const fetchedBuild = (await this.projectApi.getBuild(projectId, buildId)).body;
+        if (!fetchedBuild)
+            throw new Error(`No build for ${buildId} found.`);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedBuild = this.addStabilityData(fetchedBuild, stabilityTargets);
+        this.cache.set(cacheKey, formattedBuild, 5 * 60);
+        return formattedBuild;
+    }
+    async listReleases(projectId, opts) {
+        const response = await this.projectApi.listReleases(projectId, opts);
+        const fetchedReleases = response.body || [];
+        const nextUrl = getNextUrlPathFromHeader(response.headers, this.apiEndpoint);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedReleases = fetchedReleases.map((r) => this.addStabilityData(r, stabilityTargets));
+        return { releases: formattedReleases, nextUrl };
+    }
+    async getRelease(projectId, releaseId) {
+        const cacheKey = `${cacheKeys.RELEASE}_${releaseId}`;
+        const release = this.cache.get(cacheKey);
+        if (release)
+            return release;
+        const fetchedRelease = (await this.projectApi.getRelease(releaseId)).body;
+        if (!fetchedRelease)
+            throw new Error(`No release for ${releaseId} found.`);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedRelease = this.addStabilityData(fetchedRelease, stabilityTargets);
+        this.cache.set(cacheKey, formattedRelease, 5 * 60);
+        return formattedRelease;
+    }
+    async listBuildsInRelease(releaseId) {
+        const cacheKey = `${cacheKeys.BUILDS_IN_RELEASE}_${releaseId}`;
+        const builds = this.cache.get(cacheKey);
+        if (builds)
+            return builds;
+        const fetchedBuilds = (await this.projectApi.listBuildsInRelease(releaseId)).body || [];
+        this.cache.set(cacheKey, fetchedBuilds, 5 * 60);
+        return fetchedBuilds;
+    }
+    async getProjectStabilityTargets(projectId) {
+        return await this.projectApi.getProjectStabilityTargets(projectId);
+    }
+    addStabilityData(source, stabilityTargets) {
+        const { stability_target_type, target_stability, critical_stability } = stabilityTargets;
+        const user_stability = source.accumulative_daily_users_seen === 0 // avoid division by zero
+            ? 0
+            : (source.accumulative_daily_users_seen - source.accumulative_daily_users_with_unhandled) /
+                source.accumulative_daily_users_seen;
+        const session_stability = source.total_sessions_count === 0 // avoid division by zero
+            ? 0
+            : (source.total_sessions_count - source.unhandled_sessions_count) / source.total_sessions_count;
+        const stabilityMetric = stability_target_type === "user" ? user_stability : session_stability;
+        const meets_target_stability = stabilityMetric >= target_stability.value;
+        const meets_critical_stability = stabilityMetric >= critical_stability.value;
+        return {
+            ...source,
+            user_stability,
+            session_stability,
+            stability_target_type,
+            target_stability: target_stability.value,
+            critical_stability: critical_stability.value,
+            meets_target_stability,
+            meets_critical_stability,
+        };
+    }
     registerTools(register, getInput) {
         if (!this.projectApiKey) {
             register({
@@ -318,7 +414,7 @@ export class InsightHubClient {
                 }
             ],
             hints: [
-                "Error IDs can be found using the List Errors tool",
+                "Error IDs can be found using the List Project Errors tool",
                 "Use this after filtering errors to get detailed information about specific errors",
                 "If you used a filter to get this error, you can pass the same filters here to restrict the results or apply further filters",
                 "The URL provided in the response points should be shown to the user in all cases as it allows them to view the error in the dashboard and perform further analysis",
@@ -378,7 +474,7 @@ export class InsightHubClient {
                 {
                     name: "link",
                     type: z.string(),
-                    description: "Full URL to the event details page in the Insight Hub dashboard (web interface)",
+                    description: "Full URL to the event details page in the BugSnag dashboard (web interface)",
                     required: true,
                     examples: [
                         "https://app.bugsnag.com/my-org/my-project/errors/6863e2af8c857c0a5023b411?event_id=6863e2af012caf1d5c320000"
@@ -399,7 +495,7 @@ export class InsightHubClient {
             ],
             hints: [
                 "The URL must contain both project slug in the path and event_id in query parameters",
-                "This is useful when users share Insight Hub dashboard URLs and you need to extract the event data"
+                "This is useful when users share BugSnag dashboard URLs and you need to extract the event data"
             ]
         }, async (args, _extra) => {
             if (!args.link)
@@ -420,10 +516,9 @@ export class InsightHubClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        // Dynamically infer the filters schema from cached project event fields
         register({
             title: "List Project Errors",
-            summary: "List and search errors in a project using customizable filters",
+            summary: "List and search errors in a project using customizable filters and pagination",
             purpose: "Retrieve filtered list of errors from a project for analysis, debugging, and reporting",
             useCases: [
                 "Debug recent application errors by filtering for open errors in the last 7 days",
@@ -434,8 +529,11 @@ export class InsightHubClient {
             parameters: [
                 {
                     name: "filters",
-                    type: FilterObjectSchema,
-                    description: "Apply filters to narrow down the error list. Use the List Errors or Get Error tools to discover available filter fields",
+                    type: FilterObjectSchema.default({
+                        "event.since": [{ type: "eq", value: "30d" }],
+                        "error.status": [{ type: "eq", value: "open" }]
+                    }),
+                    description: "Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields",
                     required: false,
                     examples: [
                         '{"error.status": [{"type": "eq", "value": "open"}]}',
@@ -449,6 +547,35 @@ export class InsightHubClient {
                         "Relative time periods: h (hours), d (days)"
                     ]
                 },
+                {
+                    name: "sort",
+                    type: z.enum(["first_seen", "last_seen", "events", "users", "unsorted"]).default("last_seen"),
+                    description: "Field to sort the errors by",
+                    required: false,
+                    examples: ["last_seen"]
+                },
+                {
+                    name: "direction",
+                    type: z.enum(["asc", "desc"]).default("desc"),
+                    description: "Sort direction for ordering results",
+                    required: false,
+                    examples: ["desc"]
+                },
+                {
+                    name: "per_page",
+                    type: z.number().min(1).max(100).default(30),
+                    description: "How many results to return per page.",
+                    required: false,
+                    examples: ["30", "50", "100"]
+                },
+                {
+                    name: "next",
+                    type: z.string().url(),
+                    description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available.",
+                    required: false,
+                    examples: ["https://api.bugsnag.com/projects/515fb9337c1074f6fd000003/errors?offset=30&per_page=30&sort=last_seen"],
+                    constraints: ["Only values provided in the output from this tool can be used. Do not attempt to construct it manually."]
+                },
                 ...(this.projectApiKey ? [] : [
                     {
                         name: "projectId",
@@ -467,7 +594,28 @@ export class InsightHubClient {
                             "event.since": [{ "type": "eq", "value": "24h" }]
                         }
                     },
-                    expectedOutput: "JSON object with a list of errors in the 'data' field, and an error count in the 'count' field"
+                    expectedOutput: "JSON object with a list of errors in the 'data' field, a count of the current page of results in the 'count' field, and a total count of all results in the 'total' field"
+                },
+                {
+                    description: "Get the 10 open errors with the most users affected in the last 30 days",
+                    parameters: {
+                        filters: {
+                            "event.since": [{ "type": "eq", "value": "30d" }],
+                            "error.status": [{ "type": "eq", "value": "open" }]
+                        },
+                        sort: "users",
+                        direction: "desc",
+                        per_page: 10
+                    },
+                    expectedOutput: "JSON object with a list of errors in the 'data' field, a count of the current page of results in the 'count' field, and a total count of all results in the 'total' field"
+                },
+                {
+                    description: "Get the next 50 results",
+                    parameters: {
+                        next: "https://api.bugsnag.com/projects/515fb9337c1074f6fd000003/errors?base=2025-08-29T13%3A11%3A37Z&direction=desc&filters%5Berror.status%5D%5B%5D%5Btype%5D=eq&filters%5Berror.status%5D%5B%5D%5Bvalue%5D=open&offset=10&per_page=10&sort=users",
+                        per_page: 50
+                    },
+                    expectedOutput: "JSON object with a list of errors in the 'data' field, a count of the current page of results in the 'count' field, and a total count of all results in the 'total' field"
                 }
             ],
             hints: [
@@ -475,13 +623,17 @@ export class InsightHubClient {
                 "Combine multiple filters to narrow results - filters are applied with AND logic",
                 "For time filters: use relative format (7d, 24h) for recent periods or ISO 8601 UTC format (2018-05-20T00:00:00Z) for specific dates",
                 "Common time filters: event.since (from this time), event.before (until this time)",
-                "There may not be any errors matching the filters - this is not a problem with the tool, in fact it might be a good thing that the user's application had no errors"
+                "The 'event.since' filter and 'error.status' filters are always applied and if not specified are set to '30d' and 'open' respectively",
+                "There may not be any errors matching the filters - this is not a problem with the tool, in fact it might be a good thing that the user's application had no errors",
+                "This tool returns paged results. The 'count' field indicates the number of results returned in the current page, and the 'total' field indicates the total number of results across all pages.",
+                "If the output contains a 'next' value, there are more results available - call this tool again supplying the next URL as a parameter to retrieve the next page.",
+                "Do not modify the next URL as this can cause incorrect results. The only other parameter that can be used with 'next' is 'per_page' to control the page size."
             ]
         }, async (args, _extra) => {
             const project = await this.getInputProject(args.projectId);
-            // Optionally, validate filter keys against cached event fields
-            const eventFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS) || [];
+            // Validate filter keys against cached event fields
             if (args.filters) {
+                const eventFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS) || [];
                 const validKeys = new Set(eventFields.map(f => f.display_id));
                 for (const key of Object.keys(args.filters)) {
                     if (!validKeys.has(key)) {
@@ -489,11 +641,30 @@ export class InsightHubClient {
                     }
                 }
             }
-            const response = await this.errorsApi.listProjectErrors(project.id, { filters: args.filters });
+            const defaultFilters = {
+                "event.since": [{ "type": "eq", "value": "30d" }],
+                "error.status": [{ "type": "eq", "value": "open" }]
+            };
+            const options = {
+                filters: { ...defaultFilters, ...args.filters }
+            };
+            if (args.sort !== undefined)
+                options.sort = args.sort;
+            if (args.direction !== undefined)
+                options.direction = args.direction;
+            if (args.per_page !== undefined)
+                options.per_page = args.per_page;
+            if (args.next !== undefined)
+                options.next = args.next;
+            const response = await this.errorsApi.listProjectErrors(project.id, options);
             const errors = response.body || [];
+            const totalCount = response.headers.get('X-Total-Count');
+            const linkHeader = response.headers.get('Link');
             const result = {
                 data: errors,
                 count: errors.length,
+                total: totalCount ? parseInt(totalCount) : undefined,
+                next: linkHeader?.match(/<([^>]+)>/)?.[1],
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(result) }],
@@ -572,7 +743,7 @@ export class InsightHubClient {
                 }
             ],
             hints: [
-                "Only use valid operations - Insight Hub may reject invalid values"
+                "Only use valid operations - BugSnag may reject invalid values"
             ],
             readOnly: false,
             idempotent: false,
@@ -605,6 +776,317 @@ export class InsightHubClient {
                 content: [{ type: "text", text: JSON.stringify({ success: result }) }],
             };
         });
+        register({
+            title: "List Builds",
+            summary: "List builds for a project with optional filtering by release stage",
+            purpose: "Retrieve a list of build summaries to analyze deployment history and associated errors",
+            useCases: [
+                "View recent builds to correlate with error spikes",
+                "Filter builds by stage (e.g. production, staging) for targeted analysis",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project to list builds for",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "releaseStage",
+                    type: z.string(),
+                    description: "Filter builds by this stage (e.g. production, staging)",
+                    required: false,
+                    examples: ["production", "staging"],
+                },
+                {
+                    name: "nextUrl",
+                    type: z.string(),
+                    description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available. If provided, other parameters are ignored.",
+                    required: false,
+                    examples: [
+                        "/projects/515fb9337c1074f6fd000003/builds?offset=30&per_page=30",
+                    ],
+                },
+            ],
+            examples: [
+                {
+                    description: "List all builds for a project",
+                    parameters: {},
+                    expectedOutput: "JSON array of build objects with metadata",
+                },
+                {
+                    description: "List production builds for a project",
+                    parameters: {
+                        releaseStage: "production",
+                    },
+                    expectedOutput: "JSON array of build objects in the production stage",
+                },
+                {
+                    description: "Get the next page of results",
+                    parameters: {
+                        nextUrl: "/projects/515fb9337c1074f6fd000003/builds?offset=30&per_page=30",
+                    },
+                    expectedOutput: "JSON array of build objects with metadata from the next page",
+                }
+            ],
+            hints: ["For more detailed results use the Get Build tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON array of build summary objects with metadata",
+        }, async (args, _extra) => {
+            const project = await this.getInputProject(args.projectId);
+            const { builds, nextUrl } = await this.listBuilds(project.id, {
+                release_stage: args.releaseStage,
+                next_url: args.nextUrl,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            builds,
+                            next: nextUrl,
+                        }),
+                    }
+                ],
+            };
+        });
+        register({
+            title: "Get Build",
+            summary: "Get more details for a specific build by its ID",
+            purpose: "Retrieve detailed information about a build for analysis and debugging",
+            useCases: [
+                "View build metadata such as version, source control info, and error counts",
+                "Analyze a specific build to correlate with error spikes or deployments",
+                "See the stability targets for a project and if the build meets them",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project containing the build",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "buildId",
+                    type: z.string(),
+                    description: "ID of the build to retrieve",
+                    required: true,
+                    examples: ["5f8d0d55c9e77c0017a1b2c3"],
+                },
+            ],
+            examples: [
+                {
+                    description: "Get details for a specific build",
+                    parameters: {
+                        buildId: "5f8d0d55c9e77c0017a1b2c3",
+                    },
+                    expectedOutput: "JSON object with build details including version, source control info, error counts and stability data.",
+                },
+            ],
+            hints: ["Build IDs can be found using the List builds tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON object containing build details along with stability metrics such as user and session stability, and whether it meets project targets",
+        }, async (args, _extra) => {
+            if (!args.buildId)
+                throw new Error("buildId argument is required");
+            const build = await this.getBuild((await this.getInputProject(args.projectId)).id, args.buildId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(build) }],
+            };
+        });
+        register({
+            title: "List Releases",
+            summary: "List releases for a project with optional filtering by release stage",
+            purpose: "Retrieve a list of release summaries to analyze deployment history and associated errors",
+            useCases: [
+                "View recent releases to correlate with error spikes",
+                "Filter releases by stage (e.g. production, staging) for targeted analysis",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project to list releases for",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "releaseStage",
+                    type: z.string(),
+                    description: "Filter releases by this stage (e.g. production, staging)",
+                    required: false,
+                    examples: ["production", "staging"],
+                },
+                {
+                    name: "visibleOnly",
+                    type: z.boolean().default(true),
+                    description: "Whether to only include releases that are marked as visible (default: true)",
+                    required: true,
+                    examples: ["true", "false"],
+                },
+                {
+                    name: "nextUrl",
+                    type: z.string(),
+                    description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available. If provided, other parameters are ignored.",
+                    required: false,
+                    examples: [
+                        "/projects/515fb9337c1074f6fd000003/releases?offset=30&per_page=30",
+                    ],
+                },
+            ],
+            examples: [
+                {
+                    description: "List all releases for a project",
+                    parameters: {},
+                    expectedOutput: "JSON array of release objects with metadata",
+                },
+                {
+                    description: "List production releases for a project",
+                    parameters: {
+                        releaseStage: "production",
+                    },
+                    expectedOutput: "JSON array of release objects in the production stage",
+                },
+                {
+                    description: "Get the next page of results",
+                    parameters: {
+                        nextUrl: "/projects/515fb9337c1074f6fd000003/releases?offset=30&per_page=30",
+                    },
+                    expectedOutput: "JSON array of release objects with metadata from the next page",
+                },
+            ],
+            hints: ["For more detailed results use the Get Release tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON array of release summary objects with metadata",
+        }, async (args, _extra) => {
+            const { releases, nextUrl } = await this.listReleases((await this.getInputProject(args.projectId)).id, {
+                release_stage_name: args.releaseStage ?? "production",
+                visible_only: args.visibleOnly,
+                next_url: args.nextUrl ?? null,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            releases,
+                            next: nextUrl ?? null,
+                        }),
+                    },
+                ],
+            };
+        });
+        register({
+            title: "Get Release",
+            summary: "Get more details for a specific release by its ID",
+            purpose: "Retrieve detailed information about a release for analysis and debugging",
+            useCases: [
+                "View release metadata such as version, source control info, and error counts",
+                "Analyze a specific release to correlate with error spikes or deployments",
+                "See the stability targets for a project and if the release meets them",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project containing the release",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "releaseId",
+                    type: z.string(),
+                    description: "ID of the release to retrieve",
+                    required: true,
+                    examples: ["5f8d0d55c9e77c0017a1b2c3"],
+                },
+            ],
+            examples: [
+                {
+                    description: "Get details for a specific release",
+                    parameters: {
+                        releaseId: "5f8d0d55c9e77c0017a1b2c3",
+                    },
+                    expectedOutput: "JSON object with release details including version, source control info, error counts and stability data.",
+                },
+            ],
+            hints: ["Release IDs can be found using the List releases tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON object containing release details along with stability metrics such as user and session stability, and whether it meets project targets",
+        }, async (args, _extra) => {
+            if (!args.releaseId)
+                throw new Error("releaseId argument is required");
+            const release = await this.getRelease((await this.getInputProject(args.projectId)).id, args.releaseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(release) }],
+            };
+        });
+        register({
+            title: "List Builds in Release",
+            summary: "List builds associated with a specific release",
+            purpose: "Retrieve a list of builds for a given release to analyze deployment history and associated errors",
+            useCases: [
+                "View builds within a release to correlate with error spikes",
+                "Analyze the composition of a release by examining its builds",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project containing the release",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "releaseId",
+                    type: z.string(),
+                    description: "ID of the release to list builds for",
+                    required: true,
+                    examples: ["5f8d0d55c9e77c0017a1b2c3"],
+                },
+            ],
+            examples: [
+                {
+                    description: "List all builds in a specific release",
+                    parameters: {
+                        releaseId: "5f8d0d55c9e77c0017a1b2c3",
+                    },
+                    expectedOutput: "JSON array of build objects with metadata",
+                },
+            ],
+            hints: ["Release IDs can be found using the List releases tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON array of build summary objects with metadata",
+        }, async (args, _extra) => {
+            if (!args.releaseId)
+                throw new Error("releaseId argument is required");
+            const builds = await this.listBuildsInRelease(args.releaseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(builds) }],
+            };
+        });
     }
     registerResources(register) {
         register("event", "{id}", async (uri, variables, _extra) => {