@smartbear/mcp 0.14.1 → 0.16.0

package/dist/bugsnag/input-schemas.js

@@ -1,19 +1,19 @@
-import zod__default from "zod";
-const filterValueSchema = zod__default.object({
-  type: zod__default.enum(["eq", "ne", "empty"]),
-  value: zod__default.union([zod__default.string(), zod__default.boolean(), zod__default.number()])
+import { z } from "zod";
+const filterValueSchema = z.object({
+  type: z.enum(["eq", "ne", "empty"]),
+  value: z.union([z.string(), z.boolean(), z.number()])
 });
-const filtersSchema = zod__default.record(zod__default.string(), zod__default.array(filterValueSchema));
+const filtersSchema = z.record(z.string(), z.array(filterValueSchema));
 const toolInputParameters = {
-  empty: zod__default.object({}).describe("No parameters are required for this tool"),
-  buildId: zod__default.string().describe("Unique identifier of the app build"),
-  errorId: zod__default.string().describe("Unique identifier of the error"),
-  eventId: zod__default.string().describe("Unique identifier of the event"),
-  projectId: zod__default.string().optional().describe(
+  empty: z.object({}).describe("No parameters are required for this tool"),
+  buildId: z.string().describe("Unique identifier of the app build"),
+  errorId: z.string().describe("Unique identifier of the error"),
+  eventId: z.string().describe("Unique identifier of the event"),
+  projectId: z.string().optional().describe(
     "Unique identifier of the project. This is optional if a current project is set and is used to set the current project for BugSnag tools."
   ),
-  releaseId: zod__default.string().describe("Unique identifier of the app release"),
-  direction: zod__default.enum(["asc", "desc"]).describe("Sort direction for ordering results").default("desc"),
+  releaseId: z.string().describe("Unique identifier of the app release"),
+  direction: z.enum(["asc", "desc"]).describe("Sort direction for ordering results").default("desc"),
   performanceFilters: filtersSchema.describe(
     "Apply filters to narrow down the span group list. Use the List Trace Fields tool to discover available filter fields. Time filters support extended ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h)."
   ).default({
@@ -25,16 +25,16 @@ const toolInputParameters = {
     "event.since": [{ type: "eq", value: "30d" }],
     "error.status": [{ type: "eq", value: "open" }]
   }),
-  nextUrl: zod__default.string().describe(
+  nextUrl: z.string().describe(
     "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. Only values provided in the output from this tool can be used. Do not attempt to construct it manually."
   ).optional(),
-  page: zod__default.number().describe("Page number to return (starts from 1)").default(1),
-  perPage: zod__default.number().describe("How many results to return per page.").min(1).max(100).default(30),
-  releaseStage: zod__default.string().describe(
+  page: z.number().describe("Page number to return (starts from 1)").default(1),
+  perPage: z.number().describe("How many results to return per page.").min(1).max(100).default(30),
+  releaseStage: z.string().describe(
     "Filter releases by this stage (e.g. production, staging), defaults to 'production'"
   ).default("production"),
-  sort: zod__default.enum(["first_seen", "last_seen", "events", "users", "unsorted"]).describe("Field to sort the errors by").default("last_seen"),
-  spanGroupId: zod__default.string().describe("ID of the span group")
+  sort: z.enum(["first_seen", "last_seen", "events", "users", "unsorted"]).describe("Field to sort the errors by").default("last_seen"),
+  spanGroupId: z.string().describe("ID of the span group")
 };
 export {
   toolInputParameters

package/dist/bugsnag/tool/error/get-error.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { toUrlSearchParams } from "../../client/filters.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  errorId: toolInputParameters.errorId.describe(
+    "Unique identifier of the error to retrieve"
+  ),
+  filters: toolInputParameters.filters.describe(
+    "Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields. Time filters support extended ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h)."
+  )
+});
+class GetError extends Tool {
+  specification = {
+    title: "Get Error",
+    summary: "Get full details on an error, including aggregated and summarized data across all events (occurrences) and details of the latest event (occurrence), such as breadcrumbs, metadata and the stacktrace. Use the filters parameter to narrow down the summaries further.",
+    purpose: "Retrieve all the information required on a specified error to understand who it is affecting and why.",
+    useCases: [
+      "Investigate a specific error found through the List Project Errors tool",
+      "Understand which types of user are affected by the error using summarized event data",
+      "Get error details for debugging and root cause analysis",
+      "Retrieve error metadata for incident reports and documentation"
+    ],
+    inputSchema,
+    outputDescription: "JSON object containing:  - error_details: Aggregated data about the error, including first and last seen occurrence - latest_event: Detailed information about the most recent occurrence of the error, including stacktrace, breadcrumbs, user and context - pivots: List of pivots (summaries) for the error, which can be used to analyze patterns in occurrences - url: A link to the error in the dashboard - this should be shown to the user for them to perform further analysis",
+    examples: [
+      {
+        description: "Get details for a specific error",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411"
+        },
+        expectedOutput: "JSON object with error details including message, stack trace, occurrence count, and metadata"
+      }
+    ],
+    hints: [
+      "Error IDs can be found using the List Project Errors tool",
+      "Use this after filtering errors to get detailed information about specific errors",
+      "Use Get Event Details tool if you need detailed information about a specific event (occurrence) rather than the aggregated error",
+      "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"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const errorDetails = (await this.client.errorsApi.viewErrorOnProject(project.id, params.errorId)).body;
+    if (!errorDetails) {
+      throw new ToolError(
+        `Error with ID ${params.errorId} not found in project ${project.id}.`
+      );
+    }
+    const filters = {
+      error: [{ type: "eq", value: params.errorId }],
+      ...params.filters
+    };
+    await this.client.validateEventFields(project, filters);
+    let latestEvent = null;
+    try {
+      const latestEvents = (await this.client.errorsApi.listEventsOnProject(
+        project.id,
+        null,
+        "timestamp",
+        "desc",
+        1,
+        filters,
+        true
+      )).body;
+      if (latestEvents && latestEvents.length > 0) {
+        latestEvent = latestEvents[0];
+        latestEvent.threads = void 0;
+      }
+    } catch (e) {
+      console.warn("Failed to fetch latest event:", e);
+    }
+    const content = {
+      error_details: errorDetails,
+      latest_event: latestEvent,
+      pivots: (await this.client.errorsApi.getPivotValuesOnAnError(
+        project.id,
+        params.errorId,
+        filters,
+        5
+      )).body || [],
+      url: await this.client.getErrorUrl(
+        project,
+        params.errorId,
+        toUrlSearchParams(filters).toString()
+      )
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(content) }]
+    };
+  };
+}
+export {
+  GetError
+};

package/dist/bugsnag/tool/error/list-project-errors.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  filters: toolInputParameters.filters.describe(
+    "Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields. Time filters support extended ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h)."
+  ),
+  sort: toolInputParameters.sort,
+  direction: toolInputParameters.direction,
+  perPage: toolInputParameters.perPage,
+  nextUrl: toolInputParameters.nextUrl
+});
+class ListProjectErrors extends Tool {
+  specification = {
+    title: "List Project Errors",
+    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",
+      "Generate error reports for stakeholders by filtering specific error types or severity levels",
+      "Monitor error trends over time using date range filters",
+      "Find errors affecting specific users or environments using metadata filters"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Find errors affecting a specific user in the last 24 hours",
+        parameters: {
+          filters: {
+            "user.email": [{ type: "eq", value: "user@example.com" }],
+            "event.since": [{ type: "eq", value: "24h" }]
+          }
+        },
+        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",
+          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: {
+          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, with a URL to the next page if more results are available and a total count of all errors matched"
+      }
+    ],
+    hints: [
+      "Use List Project Event Filters tool first to discover valid filter field names for your project",
+      "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)",
+      "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 '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."
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const filters = {
+      "event.since": [{ type: "eq", value: "30d" }],
+      "error.status": [{ type: "eq", value: "open" }],
+      ...params.filters
+    };
+    await this.client.validateEventFields(project, filters);
+    const response = await this.client.errorsApi.listProjectErrors(
+      project.id,
+      null,
+      params.sort,
+      params.direction,
+      params.perPage,
+      filters,
+      params.nextUrl
+    );
+    const result = {
+      data: response.body,
+      next_url: response.nextUrl ?? void 0,
+      data_count: response.body?.length,
+      total_count: response.totalCount ?? void 0
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  };
+}
+export {
+  ListProjectErrors
+};

package/dist/bugsnag/tool/error/update-error.js

@@ -0,0 +1,256 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { ErrorUpdateRequest } from "../../client/api/api.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const PERMITTED_UPDATE_OPERATIONS = [
+  "override_severity",
+  "open",
+  "fix",
+  "ignore",
+  "discard",
+  "undiscard",
+  "snooze",
+  "link_issue",
+  "unlink_issue"
+];
+const PERMITTED_REOPEN_CONDITIONS = [
+  "occurs_after",
+  "n_occurrences_in_m_hours",
+  "n_additional_occurrences",
+  "n_additional_users"
+];
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  errorId: toolInputParameters.errorId,
+  operation: z.enum(PERMITTED_UPDATE_OPERATIONS).describe("The operation to apply to the error"),
+  issue_url: z.string().optional().describe(
+    "The URL of the issue to link to the error - required when operation is 'link_issue'"
+  ),
+  reopenRules: z.object({
+    reopenIf: z.enum(PERMITTED_REOPEN_CONDITIONS).describe("Condition for when the error should be reopened"),
+    additionalUsers: z.number().min(1).max(1e5).optional().describe(
+      "for n_additional_users reopen rules, the number of additional users to be affected by an Error before the Error is automatically reopened."
+    ),
+    seconds: z.number().min(1).optional().describe(
+      "for occurs_after reopen rules, the number of seconds that the Error should be snoozed for."
+    ),
+    occurrences: z.number().min(1).optional().describe(
+      "for n_occurrences_in_m_hours reopen rules, the number of occurrences to allow in the number of hours indicated by the hours field, before the Error is automatically reopened."
+    ),
+    hours: z.number().min(1).optional().describe(
+      "for n_occurrences_in_m_hours reopen rules, the number of hours."
+    ),
+    additionalOccurrences: z.number().min(1).optional().describe(
+      "or n_additional_occurrences reopen rules, the number of additional occurrences allowed before reopening."
+    )
+  }).optional().describe(
+    "Reopen rules for snooze operation - required when operation is 'snooze'"
+  )
+});
+class UpdateError extends Tool {
+  getInput;
+  specification = {
+    title: "Update Error",
+    summary: "Update the status of an error",
+    purpose: "Change an error's workflow state, such as marking it as resolved or ignored",
+    useCases: [
+      "Mark an error as open, fixed or ignored",
+      "Discard or un-discard an error",
+      "Update the severity of an error",
+      "Snooze an error with defined conditions for when it should be reopened"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Mark an error as fixed",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411",
+          operation: "fix"
+        },
+        expectedOutput: "Success response indicating the error was marked as fixed"
+      },
+      {
+        description: "Snooze an error for 1 hour",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411",
+          operation: "snooze",
+          reopenRules: {
+            reopenIf: "occurs_after",
+            seconds: 3600
+          }
+        },
+        expectedOutput: "Success response indicating the error was snoozed for 1 hour"
+      },
+      {
+        description: "Snooze an error until 5 additional users are affected",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411",
+          operation: "snooze",
+          reopenRules: {
+            reopenIf: "n_additional_users",
+            additionalUsers: 5
+          }
+        },
+        expectedOutput: "Success response indicating the error was snoozed until 5 additional users are affected"
+      },
+      {
+        description: "Snooze an error until 10 occurrences in 24 hours",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411",
+          operation: "snooze",
+          reopenRules: {
+            reopenIf: "n_occurrences_in_m_hours",
+            occurrences: 10,
+            hours: 24
+          }
+        },
+        expectedOutput: "Success response indicating the error was snoozed until 10 occurrences in 24 hours"
+      },
+      {
+        description: "Link a Jira issue to an error",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411",
+          operation: "link_issue",
+          issue_url: "https://smartbear.atlassian.net/browse/PIPE-9547"
+        },
+        expectedOutput: "Success response indicating the Jira issue was linked to the error"
+      },
+      {
+        description: "Unlink a Jira issue from an error",
+        parameters: {
+          errorId: "6863e2af8c857c0a5023b411",
+          operation: "unlink_issue"
+        },
+        expectedOutput: "Success response indicating the Jira issue was unlinked from the error"
+      }
+    ],
+    hints: [
+      "Only use valid operations - BugSnag may reject invalid values",
+      "When using 'snooze' operation, reopenRules parameter is required",
+      "When using 'link_issue' operation, issue_url parameter is required",
+      "Use 'unlink_issue' to remove the link between an error and its issue",
+      "For 'occurs_after' reopen rules, specify 'seconds' parameter",
+      "For 'n_additional_users' reopen rules, specify 'additionalUsers' parameter (max 100,000)",
+      "For 'n_occurrences_in_m_hours' reopen rules, specify both 'occurrences' and 'hours' parameters",
+      "For 'n_additional_occurrences' reopen rules, specify 'additionalOccurrences' parameter",
+      "Snoozing temporarily silences an error until the specified reopen condition is met"
+    ],
+    readOnly: false,
+    idempotent: false
+  };
+  constructor(client, getInput) {
+    super(client);
+    this.getInput = getInput;
+  }
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    if (params.operation === "snooze" && !params.reopenRules) {
+      throw new ToolError(
+        "reopenRules parameter is required when using 'snooze' operation"
+      );
+    }
+    if (params.operation === "link_issue" && !params.issue_url) {
+      throw new ToolError(
+        "'issue_url' parameter is required for 'link_issue' operation"
+      );
+    }
+    if (params.reopenRules) {
+      const { reopenIf } = params.reopenRules;
+      if (reopenIf === "occurs_after" && !params.reopenRules.seconds) {
+        throw new ToolError(
+          "'seconds' parameter is required for 'occurs_after' reopen rules"
+        );
+      }
+      if (reopenIf === "n_additional_users" && !params.reopenRules.additionalUsers) {
+        throw new ToolError(
+          "'additionalUsers' parameter is required for 'n_additional_users' reopen rules"
+        );
+      }
+      if (reopenIf === "n_occurrences_in_m_hours" && (!params.reopenRules.occurrences || !params.reopenRules.hours)) {
+        throw new ToolError(
+          "Both 'occurrences' and 'hours' parameters are required for 'n_occurrences_in_m_hours' reopen rules"
+        );
+      }
+      if (reopenIf === "n_additional_occurrences" && !params.reopenRules.additionalOccurrences) {
+        throw new ToolError(
+          "'additionalOccurrences' parameter is required for 'n_additional_occurrences' reopen rules"
+        );
+      }
+    }
+    let severity;
+    if (params.operation === "override_severity") {
+      const result2 = await this.getInput({
+        message: "Please provide the new severity for the error (e.g. 'info', 'warning', 'error', 'critical')",
+        requestedSchema: {
+          type: "object",
+          properties: {
+            severity: {
+              type: "string",
+              enum: ["info", "warning", "error"],
+              description: "The new severity level for the error"
+            }
+          },
+          required: ["severity"]
+        }
+      });
+      if (result2.action === "accept" && result2.content?.severity) {
+        severity = result2.content.severity;
+      }
+    }
+    let reopenRules;
+    if (params.reopenRules) {
+      reopenRules = {
+        reopen_if: params.reopenRules.reopenIf
+      };
+      if (params.reopenRules.additionalUsers !== void 0) {
+        reopenRules.additional_users = params.reopenRules.additionalUsers;
+      }
+      if (params.reopenRules.seconds !== void 0) {
+        reopenRules.seconds = params.reopenRules.seconds;
+      }
+      if (params.reopenRules.occurrences !== void 0) {
+        reopenRules.occurrences = params.reopenRules.occurrences;
+      }
+      if (params.reopenRules.hours !== void 0) {
+        reopenRules.hours = params.reopenRules.hours;
+      }
+      if (params.reopenRules.additionalOccurrences !== void 0) {
+        reopenRules.additional_occurrences = params.reopenRules.additionalOccurrences;
+      }
+    }
+    const errorUpdateRequestBody = {
+      operation: Object.values(ErrorUpdateRequest.OperationEnum).find(
+        (value) => value === params.operation
+      )
+    };
+    if (severity !== void 0) {
+      errorUpdateRequestBody.severity = severity;
+    }
+    if (reopenRules !== void 0) {
+      errorUpdateRequestBody.reopen_rules = reopenRules;
+    }
+    if (params.operation === "link_issue" && params.issue_url) {
+      errorUpdateRequestBody.issue_url = params.issue_url;
+      errorUpdateRequestBody.verify_issue_url = true;
+    }
+    const result = await this.client.errorsApi.updateErrorOnProject(
+      project.id,
+      params.errorId,
+      errorUpdateRequestBody
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.status === 200 || result.status === 204
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  UpdateError
+};

package/dist/bugsnag/tool/event/get-event-details-from-dashboard-url.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  link: z.string().describe(
+    "Full URL to the event details page in the BugSnag dashboard (web interface), containing project slug and event_id parameter."
+  )
+});
+class GetEventDetailsFromDashboardUrl extends Tool {
+  specification = {
+    title: "Get Event Details From Dashboard URL",
+    summary: "Get detailed information about a specific event using its dashboard URL",
+    purpose: "Retrieve event details directly from a dashboard URL for quick debugging",
+    useCases: [
+      "Get event details when given a dashboard URL from a user or notification",
+      "Extract event information from shared links or browser URLs",
+      "Quick lookup of event details without needing separate project and event IDs"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get event details from a dashboard URL",
+        parameters: {
+          link: "https://app.bugsnag.com/my-org/my-project/errors/6863e2af8c857c0a5023b411?event_id=6863e2af012caf1d5c320000"
+        },
+        expectedOutput: "JSON object with complete event details including stack trace, metadata, and context"
+      }
+    ],
+    hints: [
+      "The URL must contain both project slug in the path and event_id in query parameters",
+      "This is useful when users share BugSnag dashboard URLs and you need to extract the event data"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const url = new URL(params.link);
+    const eventId = url.searchParams.get("event_id");
+    const projectSlug = url.pathname.split("/")[2];
+    if (!projectSlug || !eventId)
+      throw new ToolError(
+        "Both projectSlug and eventId must be present in the link"
+      );
+    const projects = await this.client.getProjects();
+    const projectId = projects.find((p) => p.slug === projectSlug)?.id;
+    if (!projectId) {
+      throw new ToolError("Project with the specified slug not found.");
+    }
+    const response = await this.client.getEvent(eventId, projectId);
+    return {
+      content: [{ type: "text", text: JSON.stringify(response) }]
+    };
+  };
+}
+export {
+  GetEventDetailsFromDashboardUrl
+};

package/dist/bugsnag/tool/event/get-event.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  eventId: toolInputParameters.eventId
+});
+class GetEvent extends Tool {
+  specification = {
+    title: "Get Event",
+    summary: "Get detailed information about a specific event",
+    purpose: "Retrieve event details directly from its ID",
+    useCases: [
+      "Get the full details of an event, including any thread stack traces"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get event details of an event",
+        parameters: {
+          eventId: "6863e2af012caf1d5c320000"
+        },
+        expectedOutput: "JSON object with complete event details including stack trace (error trace and other threads, if present), metadata, and context"
+      }
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const response = await this.client.getEvent(params.eventId, project.id);
+    return {
+      content: [{ type: "text", text: JSON.stringify(response) }]
+    };
+  };
+}
+export {
+  GetEvent
+};

package/dist/bugsnag/tool/performance/get-network-endpoint-groupings.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId
+});
+class GetNetworkEndpointGroupings extends Tool {
+  specification = {
+    title: "Get Network Endpoint Groupings",
+    summary: "Get the network endpoint grouping rules for a project",
+    purpose: "Retrieve the URL patterns used to group network spans for performance monitoring",
+    useCases: [
+      "View current network endpoint grouping configuration",
+      "Understand how network requests are being grouped in performance monitoring",
+      "Check grouping patterns before making updates"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get network grouping rules for a project",
+        parameters: {},
+        expectedOutput: "Array of endpoint URL patterns"
+      }
+    ],
+    hints: [
+      "Network grouping patterns help consolidate similar requests into single span groups",
+      "Patterns use OpenAPI path templating syntax with curly braces for path parameters (e.g., /users/{userId})",
+      "Wildcards (*) can be used in domains to match multiple subdomains (e.g., https://*.example.com)"
+    ],
+    readOnly: true,
+    idempotent: true
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const result = await this.client.projectApi.getProjectNetworkGroupingRuleset(project.id);
+    return {
+      content: [
+        { type: "text", text: JSON.stringify(result.body.endpoints || []) }
+      ]
+    };
+  };
+}
+export {
+  GetNetworkEndpointGroupings
+};