@smartbear/mcp 0.7.0 → 0.9.0

package/dist/bugsnag/client.js

@@ -1,10 +1,9 @@
 import NodeCache from "node-cache";
 import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
-import { getNextUrlPathFromHeader } from "./client/api/base.js";
-import { FilterObjectSchema, toQueryString, } from "./client/api/filters.js";
-import { ProjectAPI, } from "./client/api/Project.js";
-import { Configuration, CurrentUserAPI, ErrorAPI } from "./client/index.js";
+import { ToolError, } from "../common/types.js";
+import { Configuration, CurrentUserAPI, ErrorAPI, ProjectAPI, } from "./client/api/index.js";
+import { FilterObjectSchema, toUrlSearchParams, } from "./client/filters.js";
 const HUB_PREFIX = "00000";
 const DEFAULT_DOMAIN = "bugsnag.com";
 const HUB_DOMAIN = "bugsnag.smartbear.com";
@@ -13,9 +12,6 @@ const cacheKeys = {
     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([
@@ -43,7 +39,7 @@ export class BugsnagClient {
         this.apiEndpoint = this.getEndpoint("api", projectApiKey, endpoint);
         this.appEndpoint = this.getEndpoint("app", projectApiKey, endpoint);
         const config = new Configuration({
-            authToken: token,
+            apiKey: `token ${token}`,
             headers: {
                 "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
                 "Content-Type": "application/json",
@@ -125,15 +121,15 @@ export class BugsnagClient {
     async getDashboardUrl(project) {
         return `${this.appEndpoint}/${(await this.getOrganization()).slug}/${project.slug}`;
     }
-    async getErrorUrl(project, errorId, queryString = "") {
+    async getErrorUrl(project, errorId, queryString) {
         const dashboardUrl = await this.getDashboardUrl(project);
-        return `${dashboardUrl}/errors/${errorId}${queryString}`;
+        return `${dashboardUrl}/errors/${errorId}${queryString ? `?${queryString}` : ""}`;
     }
     async getOrganization() {
         let org = this.cache.get(cacheKeys.ORG);
         if (!org) {
             const response = await this.currentUserApi.listUserOrganizations();
-            const orgs = response.body || [];
+            const orgs = response.body;
             if (!orgs || orgs.length === 0) {
                 throw new Error("No organizations found for the current user.");
             }
@@ -151,7 +147,7 @@ export class BugsnagClient {
         if (!projects) {
             const org = await this.getOrganization();
             const response = await this.currentUserApi.getOrganizationProjects(org.id);
-            projects = response.body || [];
+            projects = response.body;
             this.cache.set(cacheKeys.PROJECTS, projects);
         }
         return projects;
@@ -164,9 +160,10 @@ export class BugsnagClient {
         let project = this.cache.get(cacheKeys.CURRENT_PROJECT) ?? null;
         if (!project && this.projectApiKey) {
             const projects = await this.getProjects();
-            project = projects.find((p) => p.api_key === this.projectApiKey) ?? null;
+            project =
+                projects.find((p) => p.apiKey === this.projectApiKey) ?? null;
             if (!project) {
-                throw new Error("Unable to find project with the configured API key.");
+                throw new ToolError("Unable to find project with the configured API key.");
             }
             this.cache.set(cacheKeys.CURRENT_PROJECT, project);
             if (project) {
@@ -178,9 +175,9 @@ export class BugsnagClient {
     async getProjectEventFilters(project) {
         let filtersResponse = (await this.projectApi.listProjectEventFields(project.id)).body;
         if (!filtersResponse || filtersResponse.length === 0) {
-            throw new Error(`No event fields found for project ${project.name}.`);
+            throw new ToolError(`No event fields found for project ${project.name}.`);
         }
-        filtersResponse = filtersResponse.filter((field) => !EXCLUDED_EVENT_FIELDS.has(field.display_id));
+        filtersResponse = filtersResponse.filter((field) => field.displayId && !EXCLUDED_EVENT_FIELDS.has(field.displayId));
         return filtersResponse;
     }
     async getEvent(eventId, projectId) {
@@ -190,108 +187,48 @@ export class BugsnagClient {
         const projectEvents = await Promise.all(projectIds.map((projectId) => this.errorsApi.viewEventById(projectId, eventId).catch((_e) => null)));
         return projectEvents.find((event) => event && !!event.body)?.body || null;
     }
-    async updateError(projectId, errorId, operation, options) {
-        const errorUpdateRequest = {
-            operation: operation,
-            ...options,
-        };
-        const response = await this.errorsApi.updateErrorOnProject(projectId, errorId, errorUpdateRequest);
-        return response.status === 200 || response.status === 204;
-    }
     async getInputProject(projectId) {
         if (typeof projectId === "string") {
             const maybeProject = await this.getProject(projectId);
             if (!maybeProject) {
-                throw new Error(`Project with ID ${projectId} not found.`);
+                throw new ToolError(`Project with ID ${projectId} not found.`);
             }
             return maybeProject;
         }
         else {
             const currentProject = await this.getCurrentProject();
             if (!currentProject) {
-                throw new Error("No current project found. Please provide a projectId or configure a project API key.");
+                throw new ToolError("No current project found. Please provide a projectId or configure a project API key.");
             }
             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
+    addStabilityData(source, project) {
+        const accumulativeDailyUsersSeen = source.accumulativeDailyUsersSeen || 0;
+        const accumulativeDailyUsersWithUnhandled = source.accumulativeDailyUsersWithUnhandled || 0;
+        const userStability = accumulativeDailyUsersSeen === 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
+            : (accumulativeDailyUsersSeen - accumulativeDailyUsersWithUnhandled) /
+                accumulativeDailyUsersSeen;
+        const totalSessionsCount = source.totalSessionsCount || 0;
+        const unhandledSessionsCount = source.unhandledSessionsCount || 0;
+        const sessionStability = totalSessionsCount === 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;
+            : (totalSessionsCount - unhandledSessionsCount) / totalSessionsCount;
+        const stabilityMetric = project.stabilityTargetType === "user" ? userStability : sessionStability;
+        const targetStability = project.targetStability?.value || 0;
+        const criticalStability = project.criticalStability?.value || 0;
+        const meetsTargetStability = stabilityMetric >= targetStability;
+        const meetsCriticalStability = stabilityMetric >= criticalStability;
         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,
+            userStability,
+            sessionStability,
+            stabilityTargetType: project.stabilityTargetType || "user",
+            targetStability,
+            criticalStability,
+            meetsTargetStability,
+            meetsCriticalStability,
         };
     }
     registerTools(register, getInput) {
@@ -307,7 +244,7 @@ export class BugsnagClient {
                 ],
                 parameters: [
                     {
-                        name: "page_size",
+                        name: "pageSize",
                         type: z.number(),
                         description: "Number of projects to return per page for pagination",
                         required: false,
@@ -325,7 +262,7 @@ export class BugsnagClient {
                     {
                         description: "Get first 10 projects",
                         parameters: {
-                            page_size: 10,
+                            pageSize: 10,
                             page: 1,
                         },
                         expectedOutput: "JSON array of project objects with IDs, names, and metadata",
@@ -347,8 +284,8 @@ export class BugsnagClient {
                         content: [{ type: "text", text: "No projects found." }],
                     };
                 }
-                if (args.page_size || args.page) {
-                    const pageSize = args.page_size || 10;
+                if (args.pageSize || args.page) {
+                    const pageSize = args.pageSize || 10;
                     const page = args.page || 1;
                     projects = projects.slice((page - 1) * pageSize, page * pageSize);
                 }
@@ -430,30 +367,22 @@ export class BugsnagClient {
         }, async (args, _extra) => {
             const project = await this.getInputProject(args.projectId);
             if (!args.errorId)
-                throw new Error("Both projectId and errorId arguments are required");
+                throw new ToolError("Both projectId and errorId arguments are required");
             const errorDetails = (await this.errorsApi.viewErrorOnProject(project.id, args.errorId)).body;
             if (!errorDetails) {
-                throw new Error(`Error with ID ${args.errorId} not found in project ${project.id}.`);
+                throw new ToolError(`Error with ID ${args.errorId} not found in project ${project.id}.`);
             }
-            // Build query parameters
-            const params = new URLSearchParams();
-            // Add sorting and pagination parameters to get the latest event
-            params.append("sort", "timestamp");
-            params.append("direction", "desc");
-            params.append("per_page", "1");
-            params.append("full_reports", "true");
             const filters = {
                 error: [{ type: "eq", value: args.errorId }],
                 ...args.filters,
             };
-            const filtersQueryString = toQueryString(filters);
-            const listEventsQueryString = `?${params}&${filtersQueryString}`;
             // Get the latest event for this error using the events endpoint with filters
             let latestEvent = null;
             try {
-                const eventsResponse = await this.errorsApi.listEventsOnProject(project.id, listEventsQueryString);
-                const events = eventsResponse.body || [];
-                latestEvent = events[0] || null;
+                const latestEvents = (await this.errorsApi.listEventsOnProject(project.id, null, "timestamp", "desc", 1, filters, true)).body;
+                if (latestEvents && latestEvents.length > 0) {
+                    latestEvent = latestEvents[0];
+                }
             }
             catch (e) {
                 console.warn("Failed to fetch latest event:", e);
@@ -462,9 +391,8 @@ export class BugsnagClient {
             const content = {
                 error_details: errorDetails,
                 latest_event: latestEvent,
-                pivots: (await this.errorsApi.listErrorPivots(project.id, args.errorId))
-                    .body || [],
-                url: await this.getErrorUrl(project, args.errorId, `?${filtersQueryString}`),
+                pivots: (await this.errorsApi.getPivotValuesOnAnError(project.id, args.errorId, filters, 5)).body || [],
+                url: await this.getErrorUrl(project, args.errorId, toUrlSearchParams(filters).toString()),
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(content) }],
@@ -508,17 +436,17 @@ export class BugsnagClient {
             ],
         }, async (args, _extra) => {
             if (!args.link)
-                throw new Error("link argument is required");
+                throw new ToolError("link argument is required");
             const url = new URL(args.link);
             const eventId = url.searchParams.get("event_id");
             const projectSlug = url.pathname.split("/")[2];
             if (!projectSlug || !eventId)
-                throw new Error("Both projectSlug and eventId must be present in the link");
+                throw new ToolError("Both projectSlug and eventId must be present in the link");
             // get the project id from list of projects
             const projects = await this.getProjects();
             const projectId = projects.find((p) => p.slug === projectSlug)?.id;
             if (!projectId) {
-                throw new Error("Project with the specified slug not found.");
+                throw new ToolError("Project with the specified slug not found.");
             }
             const response = await this.getEvent(eventId, projectId);
             return {
@@ -573,15 +501,15 @@ export class BugsnagClient {
                     examples: ["desc"],
                 },
                 {
-                    name: "per_page",
+                    name: "perPage",
                     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(),
+                    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.",
                     required: false,
                     examples: [
@@ -622,17 +550,17 @@ export class BugsnagClient {
                         },
                         sort: "users",
                         direction: "desc",
-                        per_page: 10,
+                        perPage: 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,
+                        nextUrl: "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",
+                        perPage: 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",
+                    expectedOutput: "JSON object with a list of errors, with a URL to the next page if more results are available and a total count of all errors matched",
                 },
             ],
             hints: [
@@ -642,8 +570,8 @@ export class BugsnagClient {
                 "Common time filters: event.since (from this time), event.before (until this time)",
                 "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.",
+                "This tool returns paged results. The 'page_error_count' field indicates the number of results returned in the current page, and the 'total_error_count' field indicates the total number of results across all pages.",
+                "If the output contains a 'next_url' 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) => {
@@ -651,37 +579,24 @@ export class BugsnagClient {
             // 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));
+                const validKeys = new Set(eventFields.map((f) => f.displayId));
                 for (const key of Object.keys(args.filters)) {
                     if (!validKeys.has(key)) {
-                        throw new Error(`Invalid filter key: ${key}`);
+                        throw new ToolError(`Invalid filter key: ${key}`);
                     }
                 }
             }
-            const defaultFilters = {
+            const filters = {
                 "event.since": [{ type: "eq", value: "30d" }],
                 "error.status": [{ type: "eq", value: "open" }],
+                ...args.filters,
             };
-            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 response = await this.errorsApi.listProjectErrors(project.id, null, args.sort || "last_seen", args.direction || "desc", args.perPage || 30, filters, args.nextUrl);
             const result = {
-                data: errors,
-                count: errors.length,
-                total: totalCount ? parseInt(totalCount, 10) : undefined,
-                next: linkHeader?.match(/<([^>]+)>/)?.[1],
+                data: response.body,
+                next_url: response.nextUrl ?? undefined,
+                data_count: response.body?.length,
+                total_count: response.totalCount ?? undefined,
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(result) }],
@@ -711,7 +626,7 @@ export class BugsnagClient {
         }, async (_args, _extra) => {
             const projectFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS);
             if (!projectFields)
-                throw new Error("No event filters found in cache.");
+                throw new ToolError("No event filters found in cache.");
             return {
                 content: [{ type: "text", text: JSON.stringify(projectFields) }],
             };
@@ -790,146 +705,24 @@ export class BugsnagClient {
                     severity = result.content.severity;
                 }
             }
-            const result = await this.updateError(project.id, errorId, operation, {
-                severity,
-            });
-            return {
-                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,
+            const result = await this.errorsApi.updateErrorOnProject(project.id, errorId, {
+                operation: operation,
+                severity: severity,
             });
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            builds,
-                            next: nextUrl,
+                            success: result.status === 200 || result.status === 204,
                         }),
                     },
                 ],
             };
         });
-        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",
+            summary: "List releases for a project",
             purpose: "Retrieve a list of release summaries to analyze deployment history and associated errors",
             useCases: [
                 "View recent releases to correlate with error spikes",
@@ -948,18 +741,25 @@ export class BugsnagClient {
                     ]),
                 {
                     name: "releaseStage",
-                    type: z.string(),
-                    description: "Filter releases by this stage (e.g. production, staging)",
+                    type: z.string().default("production"),
+                    description: "Filter releases by this stage (e.g. production, staging), defaults to 'production'",
                     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,
+                    type: z.boolean().default(false),
+                    description: "Whether to only include releases that are marked as visible in the dashboard, defaults to false",
+                    required: false,
                     examples: ["true", "false"],
                 },
+                {
+                    name: "perPage",
+                    type: z.number().min(1).max(100).default(30),
+                    description: "How many results to return per page.",
+                    required: false,
+                    examples: ["30", "50", "100"],
+                },
                 {
                     name: "nextUrl",
                     type: z.string(),
@@ -972,16 +772,16 @@ export class BugsnagClient {
             ],
             examples: [
                 {
-                    description: "List all releases for a project",
+                    description: "List production releases for a project",
                     parameters: {},
-                    expectedOutput: "JSON array of release objects with metadata",
+                    expectedOutput: "JSON array of release objects in the production stage",
                 },
                 {
-                    description: "List production releases for a project",
+                    description: "List staging releases for a project",
                     parameters: {
-                        releaseStage: "production",
+                        releaseStage: "staging",
                     },
-                    expectedOutput: "JSON array of release objects in the production stage",
+                    expectedOutput: "JSON array of release objects in the staging stage",
                 },
                 {
                     description: "Get the next page of results",
@@ -991,23 +791,31 @@ export class BugsnagClient {
                     expectedOutput: "JSON array of release objects with metadata from the next page",
                 },
             ],
-            hints: ["For more detailed results use the Get Release tool"],
+            hints: [
+                "Use the Get Release tool to get more details on a specific release, including the builds it contains",
+                "The release stage defaults to 'production' if not specified",
+                "Use visibleOnly to filter out releases that have been marked as hidden in the dashboard",
+            ],
             readOnly: true,
             idempotent: true,
-            outputFormat: "JSON array of release summary objects with metadata",
+            outputFormat: "JSON array of release summary objects with metadata, with a URL to the next page if more results are available",
         }, 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,
-            });
+            const project = await this.getInputProject(args.projectId);
+            const response = await this.projectApi.listProjectReleaseGroups(project.id, args.releaseStage || "production", false, // Not top-only
+            args.visibleOnly || false, args.perPage || 30, args.nextUrl);
+            let releases = [];
+            if (response.body) {
+                releases = response.body.map((r) => this.addStabilityData(r, project));
+            }
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            releases,
-                            next: nextUrl ?? null,
+                            data: releases,
+                            next_url: response.nextUrl ?? undefined,
+                            data_count: releases.length,
+                            total_count: response.totalCount ?? undefined,
                         }),
                     },
                 ],
@@ -1015,12 +823,12 @@ export class BugsnagClient {
         });
         register({
             title: "Get Release",
-            summary: "Get more details for a specific release by its ID",
+            summary: "Get more details for a specific release by its ID, including source control information and associated builds",
             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",
+                "Analyze the stability data and targets for a release",
+                "See the builds that make up the release",
             ],
             parameters: [
                 ...(this.projectApiKey
@@ -1056,19 +864,39 @@ export class BugsnagClient {
             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);
+                throw new ToolError("releaseId argument is required");
+            const project = await this.getInputProject(args.projectId);
+            const releaseResponse = await this.projectApi.getReleaseGroup(args.releaseId);
+            if (!releaseResponse.body)
+                throw new ToolError(`No release for ${args.releaseId} found.`);
+            const release = this.addStabilityData(releaseResponse.body, project);
+            let builds = [];
+            if (releaseResponse.body) {
+                const buildsResponse = await this.projectApi.listBuildsInRelease(args.releaseId);
+                if (buildsResponse.body) {
+                    builds = buildsResponse.body.map((b) => this.addStabilityData(b, project));
+                }
+            }
             return {
-                content: [{ type: "text", text: JSON.stringify(release) }],
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            release: release,
+                            builds: builds,
+                        }),
+                    },
+                ],
             };
         });
         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",
+            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 builds within a release to correlate with error spikes",
-                "Analyze the composition of a release by examining its builds",
+                "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
@@ -1077,37 +905,41 @@ export class BugsnagClient {
                         {
                             name: "projectId",
                             type: z.string(),
-                            description: "ID of the project containing the release",
+                            description: "ID of the project containing the build",
                             required: true,
                         },
                     ]),
                 {
-                    name: "releaseId",
+                    name: "buildId",
                     type: z.string(),
-                    description: "ID of the release to list builds for",
+                    description: "ID of the build to retrieve",
                     required: true,
                     examples: ["5f8d0d55c9e77c0017a1b2c3"],
                 },
             ],
             examples: [
                 {
-                    description: "List all builds in a specific release",
+                    description: "Get details for a specific build",
                     parameters: {
-                        releaseId: "5f8d0d55c9e77c0017a1b2c3",
+                        buildId: "5f8d0d55c9e77c0017a1b2c3",
                     },
-                    expectedOutput: "JSON array of build objects with metadata",
+                    expectedOutput: "JSON object with build details including version, source control info, error counts and stability data.",
                 },
             ],
-            hints: ["Release IDs can be found using the List releases tool"],
+            hints: ["Build IDs can be found using the List builds tool"],
             readOnly: true,
             idempotent: true,
-            outputFormat: "JSON array of build summary objects with metadata",
+            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.releaseId)
-                throw new Error("releaseId argument is required");
-            const builds = await this.listBuildsInRelease(args.releaseId);
+            if (!args.buildId)
+                throw new ToolError("buildId argument is required");
+            const project = await this.getInputProject(args.projectId);
+            const response = await this.projectApi.getProjectReleaseById(project.id, args.buildId);
+            if (!response.body)
+                throw new ToolError(`No build for ${args.buildId} found.`);
+            const build = this.addStabilityData(response.body, project);
             return {
-                content: [{ type: "text", text: JSON.stringify(builds) }],
+                content: [{ type: "text", text: JSON.stringify(build) }],
             };
         });
     }