@smartbear/mcp 0.15.0 → 0.16.0

package/dist/bugsnag/tool/performance/get-span-group.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  spanGroupId: toolInputParameters.spanGroupId,
+  filters: toolInputParameters.performanceFilters
+});
+class GetSpanGroup extends Tool {
+  specification = {
+    title: "Get Span Group",
+    summary: "Get detailed performance metrics for a specific span group",
+    purpose: "Analyze performance characteristics of a specific operation",
+    useCases: [
+      "View detailed statistics (p50, p75, p90, p95, p99) for an operation",
+      "Check if performance targets are configured",
+      "Monitor span count to understand operation volume"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get details for an API endpoint span group",
+        parameters: { spanGroupId: "[HttpClient]GET-api.example.com" },
+        expectedOutput: "Statistics, category, and performance target info"
+      },
+      {
+        description: "Get span group details with device filtering",
+        parameters: {
+          spanGroupId: "[HttpClient]GET-api.example.com",
+          filters: {
+            "device.browser_name": [{ type: "eq", value: "Chrome" }]
+          }
+        },
+        expectedOutput: "Statistics filtered for Chrome browser only"
+      }
+    ],
+    hints: [
+      "Use List Span Groups first to discover available span group IDs",
+      "IDs are automatically URL-encoded - provide the raw ID",
+      "Statistics include p50, p75, p90, p95, p99 percentiles"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const spanGroupResults = await this.client.projectApi.getProjectSpanGroup(
+      project.id,
+      params.spanGroupId,
+      params.filters
+    );
+    const spanGroupTimelineResult = await this.client.projectApi.getProjectSpanGroupTimeline(
+      project.id,
+      params.spanGroupId,
+      params.filters
+    );
+    const spanGroupDistributionResult = await this.client.projectApi.getProjectSpanGroupDistribution(
+      project.id,
+      params.spanGroupId,
+      params.filters
+    );
+    const result = {
+      ...spanGroupResults.body,
+      timeline: spanGroupTimelineResult.body,
+      distribution: spanGroupDistributionResult.body
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+  };
+}
+export {
+  GetSpanGroup
+};

package/dist/bugsnag/tool/performance/get-trace.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  traceId: z.string().describe("Trace ID"),
+  from: z.string().describe("Start time (ISO 8601 format)"),
+  to: z.string().describe("End time (ISO 8601 format)"),
+  targetSpanId: z.string().optional().describe("Optional target span ID to focus on"),
+  perPage: toolInputParameters.perPage,
+  nextUrl: toolInputParameters.nextUrl
+});
+class GetTrace extends Tool {
+  specification = {
+    title: "Get Trace",
+    summary: "Get all spans within a specific trace",
+    purpose: "View the complete trace of operations for a request/transaction",
+    useCases: [
+      "Debug slow requests by viewing all operations in the trace",
+      "Understand the flow of a request through the system",
+      "Identify bottlenecks in distributed systems"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get all spans for a trace",
+        parameters: {
+          traceId: "abc123",
+          from: "2024-01-01T00:00:00Z",
+          to: "2024-01-01T23:59:59Z"
+        },
+        expectedOutput: "Array of all spans in the trace with timing and hierarchy"
+      },
+      {
+        description: "Get spans for a trace with pagination and target span",
+        parameters: {
+          traceId: "def456",
+          from: "2024-01-01T00:00:00Z",
+          to: "2024-01-01T23:59:59Z",
+          targetSpanId: "span-789",
+          perPage: 50
+        },
+        expectedOutput: "Array of up to 50 spans focused around the target span"
+      }
+    ],
+    hints: [
+      "Traces show the complete execution path of a request",
+      "Use from/to parameters to narrow the time window",
+      "targetSpanId can be used to focus on a specific span in the trace"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    if (!params.traceId || !params.from || !params.to) {
+      throw new ToolError("traceId, from, and to are required");
+    }
+    const result = await this.client.projectApi.listSpansByTraceId(
+      project.id,
+      params.traceId,
+      params.from,
+      params.to,
+      params.targetSpanId,
+      params.perPage,
+      params.nextUrl
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            data: result.body,
+            next_url: result.nextUrl,
+            count: result.body?.length
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  GetTrace
+};

package/dist/bugsnag/tool/performance/list-span-groups.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  sort: z.enum([
+    "total_spans",
+    "last_seen",
+    "name",
+    "display_name",
+    "network_http_method",
+    "rendering_slow_frame_span_percentage",
+    "rendering_frozen_frame_span_percentage",
+    "duration_p50",
+    "duration_p75",
+    "duration_p90",
+    "duration_p95",
+    "duration_p99",
+    "system_metrics_cpu_total_mean_p50",
+    "system_metrics_cpu_total_mean_p75",
+    "system_metrics_cpu_total_mean_p90",
+    "system_metrics_cpu_total_mean_p95",
+    "system_metrics_cpu_total_mean_p99",
+    "system_metrics_memory_device_mean_p50",
+    "system_metrics_memory_device_mean_p75",
+    "system_metrics_memory_device_mean_p90",
+    "system_metrics_memory_device_mean_p95",
+    "system_metrics_memory_device_mean_p99",
+    "rendering_metrics_fps_mean_p50",
+    "rendering_metrics_fps_mean_p75",
+    "rendering_metrics_fps_mean_p90",
+    "rendering_metrics_fps_mean_p95",
+    "rendering_metrics_fps_mean_p99",
+    "http_response_4xx_percentage",
+    "http_response_5xx_percentage"
+  ]).optional().describe("Field to sort by"),
+  direction: toolInputParameters.direction,
+  perPage: toolInputParameters.perPage,
+  starredOnly: z.boolean().optional().describe("Show only starred span groups"),
+  nextUrl: toolInputParameters.nextUrl,
+  filters: toolInputParameters.performanceFilters
+});
+class ListSpanGroups extends Tool {
+  specification = {
+    title: "List Span Groups",
+    summary: "List span groups (operations) tracked for performance monitoring",
+    purpose: "Discover and analyze different operations being monitored",
+    useCases: [
+      "View all operations being tracked for performance",
+      "Find slow operations by sorting by duration metrics",
+      "Filter to starred/important span groups"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "List slowest operations",
+        parameters: {
+          sort: "duration_p95",
+          direction: "desc",
+          perPage: 10
+        },
+        expectedOutput: "Array of span groups sorted by 95th percentile duration"
+      },
+      {
+        description: "List starred span groups with filtering",
+        parameters: {
+          starredOnly: true,
+          filters: {
+            "span_group.category": [{ type: "eq", value: "full_page_load" }]
+          }
+        },
+        expectedOutput: "Array of starred span groups filtered by category"
+      }
+    ],
+    hints: [
+      "Span groups represent different operation types (page loads, API calls, etc.)",
+      "Use sort by duration_p95 or duration_p99 to find the slowest operations",
+      "Star important span groups for quick access",
+      "Use nextUrl for pagination"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const result = await this.client.projectApi.listProjectSpanGroups(
+      project.id,
+      params.sort,
+      params.direction,
+      params.perPage,
+      void 0,
+      params.filters,
+      params.starredOnly,
+      params.nextUrl
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            data: result.body,
+            next_url: result.nextUrl,
+            count: result.body?.length
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  ListSpanGroups
+};

package/dist/bugsnag/tool/performance/list-spans.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  spanGroupId: toolInputParameters.spanGroupId,
+  sort: z.enum([
+    "duration",
+    "timestamp",
+    "full_page_load_lcp",
+    "full_page_load_fid",
+    "full_page_load_cls",
+    "full_page_load_ttfb",
+    "full_page_load_fcp",
+    "rendering_slow_frame_percentage",
+    "rendering_frozen_frame_percentage",
+    "system_metrics_cpu_total_mean",
+    "system_metrics_memory_device_mean",
+    "rendering_metrics_fps_mean",
+    "rendering_metrics_fps_minimum",
+    "rendering_metrics_fps_maximum",
+    "http_response_code"
+  ]).optional().describe("Field to sort by"),
+  direction: toolInputParameters.direction,
+  perPage: toolInputParameters.perPage,
+  nextUrl: toolInputParameters.nextUrl,
+  filters: toolInputParameters.performanceFilters
+});
+class ListSpans extends Tool {
+  specification = {
+    title: "List Spans",
+    summary: "Get individual spans belonging to a span group",
+    purpose: "Examine individual operation instances within a span group",
+    useCases: [
+      "Analyze individual slow operations",
+      "Debug performance issues by examining specific traces",
+      "Find patterns in operation attributes"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get slowest spans for an operation",
+        parameters: {
+          spanGroupId: "[HttpClient]GET-api.example.com",
+          sort: "duration",
+          direction: "desc",
+          perPage: 10
+        },
+        expectedOutput: "Array of the 10 slowest span instances"
+      },
+      {
+        description: "Get spans filtered by OS with pagination",
+        parameters: {
+          spanGroupId: "[HttpClient]GET-api.example.com",
+          sort: "timestamp",
+          filters: {
+            "os.name": [{ type: "eq", value: "iOS" }]
+          },
+          nextUrl: "/projects/123/spans?offset=30&per_page=30"
+        },
+        expectedOutput: "Array of spans from iOS devices with next page navigation"
+      }
+    ],
+    hints: [
+      "Sort by duration descending to find the slowest instances",
+      "Each span includes trace ID for further investigation"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const result = await this.client.projectApi.listSpansBySpanGroupId(
+      project.id,
+      params.spanGroupId,
+      params.filters,
+      params.sort,
+      params.direction,
+      params.perPage,
+      params.nextUrl
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            data: result.body,
+            next_url: result.nextUrl,
+            count: result.body?.length
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  ListSpans
+};

package/dist/bugsnag/tool/performance/list-trace-fields.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId
+});
+class ListTraceFields extends Tool {
+  specification = {
+    title: "List Trace Fields",
+    summary: "Get available trace fields/attributes for filtering",
+    purpose: "Discover what custom attributes are available for filtering",
+    useCases: [
+      "Find available custom attributes for performance filtering",
+      "Understand what metadata is attached to traces",
+      "Build dynamic filters based on available fields"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get all trace fields",
+        parameters: {},
+        expectedOutput: "Array of field names and types available for filtering"
+      }
+    ],
+    hints: [
+      "Trace fields are custom attributes added to spans",
+      "Use these fields for filtering other performance queries"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const traceFields = await this.client.getProjectTraceFields(project);
+    return {
+      content: [{ type: "text", text: JSON.stringify(traceFields) }]
+    };
+  };
+}
+export {
+  ListTraceFields
+};

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

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  endpoints: z.array(z.string()).describe(
+    "Array of URL patterns by which network spans are grouped. Endpoints follow OpenAPI path templating syntax (https://swagger.io/specification/#path-templating) where path parameters use curly braces (e.g., /users/{id}). If you encounter colon-prefixed parameters (e.g., :userId from Express/React Router), convert them to curly braces (e.g., {userId}). Wildcards (*) can be used in domains (e.g., https://*.example.com) to match multiple subdomains."
+  )
+});
+class SetNetworkEndpointGroupings extends Tool {
+  specification = {
+    title: "Set Network Endpoint Groupings",
+    summary: "Set the network endpoint grouping rules for a project",
+    purpose: "Configure URL patterns to control how network spans are grouped in performance monitoring",
+    useCases: [
+      "Consolidate similar API endpoints into single span groups",
+      "Group dynamic URLs using path parameters (e.g., /api/users/{userId} groups /api/users/123, /api/users/456)",
+      "Match multiple subdomains using wildcards (e.g., https://*.example.com groups api.example.com, cdn.example.com)",
+      "Simplify performance monitoring by reducing span group clutter"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Group API endpoints with path parameters",
+        parameters: {
+          endpoints: [
+            "/api/users/{userId}",
+            "/api/products/{productId}",
+            "/api/orders/{orderId}/items/{itemId}"
+          ]
+        },
+        expectedOutput: "Success response confirming the update"
+      },
+      {
+        description: "Group endpoints with domain wildcards and path parameters",
+        parameters: {
+          endpoints: [
+            "https://*.example.com/api/v1/{resourceId}",
+            "https://api.example.com/v2/users/{userId}",
+            "/graphql"
+          ]
+        },
+        expectedOutput: "Success response confirming the update"
+      },
+      {
+        description: "Convert colon-prefixed parameters to curly braces (e.g., from Express/React Router)",
+        parameters: {
+          endpoints: [
+            "/{organizationSlug}/{projectSlug}/performance/view-load",
+            "/api/{version}/items/{itemId}"
+          ]
+        },
+        expectedOutput: "Success response confirming the update"
+      }
+    ],
+    hints: [
+      "Use Get Network Grouping first to see current patterns",
+      "Use OpenAPI path templating with curly braces for path parameters: /users/{userId}, /orders/{orderId}/items/{itemId}",
+      "Convert colon-prefixed parameters to curly braces: :organizationSlug becomes {organizationSlug}, :projectSlug becomes {projectSlug}",
+      "Wildcards (*) can be used in domains to match subdomains: https://*.example.com/api",
+      "This replaces all existing patterns - include all patterns you want to keep",
+      "Well-designed patterns reduce noise in performance monitoring"
+    ],
+    readOnly: false,
+    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.updateProjectNetworkGroupingRuleset(
+      project.id,
+      params.endpoints
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: result.status === 200 || result.status === 204,
+            projectId: project.id,
+            endpoints: params.endpoints
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  SetNetworkEndpointGroupings
+};

package/dist/bugsnag/tool/project/get-current-project.js

@@ -0,0 +1,31 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+class GetCurrentProject extends Tool {
+  specification = {
+    title: "Get Current Project",
+    summary: "Retrieve the 'current' project on which tools should operate by default. This allows BugSnag tools to be called with no projectId parameter.",
+    purpose: "Gets information about the 'current' BugSnag project, including ID and API key",
+    useCases: ["Understand if a current project has been set"],
+    inputSchema: toolInputParameters.empty,
+    hints: [
+      "If a project is returned, it can be assumed that the user expects interactions with BugSnag tools to refer to this project",
+      "If this tool returns no current project then other BugSnag tools will require an explicit project ID parameter",
+      "Call the List Projects tool to see all projects that the user has access to. Get the project ID from this list either by asking the user for the project name or slug",
+      "You might find a BugSnag API key in the user's code where they configure the BugSnag SDK that can be matched to a project 'apiKey' field from the project list"
+    ]
+  };
+  handle = async (_args, _extra) => {
+    const project = await this.client.getCurrentProject();
+    if (!project) {
+      throw new ToolError(
+        "No current project is configured in the MCP server - use List Projects to see the available projects and use the project ID as a parameter to other BugSnag tools. You can ask the user to select the project based on the name or slug, or use the apiKey field and see if there's a BugSnag API key set in the user's code when they configure the BugSnag SDK"
+      );
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(project) }]
+    };
+  };
+}
+export {
+  GetCurrentProject
+};

package/dist/bugsnag/tool/project/list-project-event-filters.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId
+});
+class ListProjectEventFilters extends Tool {
+  specification = {
+    title: "List Project Event Filters",
+    summary: "Get available event filter fields for a project",
+    purpose: "Discover valid filter field names and options that can be used with the List Errors or Get Error tools",
+    useCases: [
+      "Discover what filter fields are available before searching for errors",
+      "Find the correct field names for filtering by user, environment, or custom metadata",
+      "Understand filter options and data types for building complex queries"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get all available filter fields",
+        parameters: {},
+        expectedOutput: "JSON array of EventField objects containing display_id, custom flag, and filter/pivot options"
+      }
+    ],
+    hints: [
+      "Use this tool before the List Errors or Get Error tools to understand available filters",
+      "Look for display_id field in the response - these are the field names to use in filters"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const eventFilters = await this.client.getProjectEventFields(
+      await this.client.getInputProject(params.projectId)
+    );
+    return {
+      content: [{ type: "text", text: JSON.stringify(eventFilters) }]
+    };
+  };
+}
+export {
+  ListProjectEventFilters
+};

package/dist/bugsnag/tool/project/list-projects.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  apiKey: z.string().optional().describe("The API key of the BugSnag project, if known.")
+});
+class ListProjects extends Tool {
+  specification = {
+    title: "List Projects",
+    summary: "List all projects in the organization that the current user has access to, or find a project matching an API key.",
+    purpose: "Retrieve available projects for browsing and selecting which project to analyze.",
+    useCases: [
+      "Get an overview of all projects in the organization",
+      "Locate a project by its API key if known from the user's code"
+    ],
+    inputSchema,
+    hints: [
+      "Project IDs from this list can be used with other tools when no project API key is configured"
+    ]
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    let projects = await this.client.getProjects();
+    if (!projects || projects.length === 0) {
+      throw new ToolError("No BugSnag projects found for the current user.");
+    }
+    if (params.apiKey) {
+      const matchedProject = projects.find(
+        (p) => p.api_key === params.apiKey
+      );
+      projects = matchedProject ? [matchedProject] : [];
+    }
+    const content = {
+      data: projects,
+      count: projects.length
+    };
+    return {
+      content: [{ type: "text", text: JSON.stringify(content) }]
+    };
+  };
+}
+export {
+  ListProjects
+};

package/dist/bugsnag/tool/release/get-build.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  buildId: toolInputParameters.buildId
+});
+class GetBuild extends Tool {
+  specification = {
+    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"
+    ],
+    inputSchema,
+    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,
+    outputDescription: "JSON object containing build details along with stability metrics such as user and session stability, and whether it meets project targets"
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const response = await this.client.projectApi.getProjectReleaseById(
+      project.id,
+      params.buildId
+    );
+    if (!response.body)
+      throw new ToolError(`No build for ${params.buildId} found.`);
+    const build = this.client.addStabilityData(response.body, project);
+    return {
+      content: [{ type: "text", text: JSON.stringify(build) }]
+    };
+  };
+}
+export {
+  GetBuild
+};