@smartbear/mcp 0.11.0 → 0.12.1

package/dist/bugsnag/client.js

@@ -10,7 +10,8 @@ const HUB_DOMAIN = "bugsnag.smartbear.com";
 const cacheKeys = {
     ORG: "bugsnag_org",
     PROJECTS: "bugsnag_projects",
-    PROJECT_EVENT_FILTERS: "bugsnag_project_event_filters",
+    PROJECT_EVENT_FIELDS: "bugsnag_project_event_fields",
+    PROJECT_TRACE_FIELDS: "bugsnag_project_trace_fields",
     CURRENT_PROJECT: "bugsnag_current_project",
 };
 // Exclude certain event fields from the project event filters to improve agent usage
@@ -101,7 +102,7 @@ export class BugsnagClient {
                 console.error("An error occurred while fetching project information", error);
             }
             if (currentProject) {
-                await this.getProjectEventFilters(currentProject);
+                await this.getProjectEventFields(currentProject);
             }
             else {
                 // Clear the project API key to allow tools to work across all projects
@@ -201,8 +202,8 @@ export class BugsnagClient {
         }
         return project;
     }
-    async getProjectEventFilters(project) {
-        const projectFiltersCache = this.cache?.get(cacheKeys.PROJECT_EVENT_FILTERS) || {};
+    async getProjectEventFields(project) {
+        const projectFiltersCache = this.cache?.get(cacheKeys.PROJECT_EVENT_FIELDS) || {};
         if (!projectFiltersCache[project.id]) {
             let filtersResponse = (await this.projectApi.listProjectEventFields(project.id)).body;
             if (!filtersResponse || filtersResponse.length === 0) {
@@ -210,7 +211,19 @@ export class BugsnagClient {
             }
             filtersResponse = filtersResponse.filter((field) => field.displayId && !EXCLUDED_EVENT_FIELDS.has(field.displayId));
             projectFiltersCache[project.id] = filtersResponse;
-            this.cache?.set(cacheKeys.PROJECT_EVENT_FILTERS, projectFiltersCache);
+            this.cache?.set(cacheKeys.PROJECT_EVENT_FIELDS, projectFiltersCache);
+        }
+        return projectFiltersCache[project.id];
+    }
+    async getProjectTraceFields(project) {
+        const projectFiltersCache = this.cache?.get(cacheKeys.PROJECT_TRACE_FIELDS) || {};
+        if (!projectFiltersCache[project.id]) {
+            const filtersResponse = (await this.projectApi.listProjectTraceFields(project.id)).body;
+            if (!filtersResponse || filtersResponse.length === 0) {
+                throw new ToolError(`No trace fields found for project ${project.name}.`);
+            }
+            projectFiltersCache[project.id] = filtersResponse;
+            this.cache?.set(cacheKeys.PROJECT_TRACE_FIELDS, projectFiltersCache);
         }
         return projectFiltersCache[project.id];
     }
@@ -221,6 +234,17 @@ 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 validateEventFields(project, fields) {
+        if (fields) {
+            const eventFields = await this.getProjectEventFields(project);
+            const validKeys = new Set(eventFields.map((f) => f.displayId));
+            for (const key of Object.keys(fields)) {
+                if (!validKeys.has(key)) {
+                    throw new ToolError(`Invalid filter key: ${key}`);
+                }
+            }
+        }
+    }
     async getInputProject(projectId) {
         if (typeof projectId === "string") {
             const maybeProject = await this.getProject(projectId);
@@ -361,6 +385,7 @@ export class BugsnagClient {
             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",
             ],
@@ -375,12 +400,14 @@ export class BugsnagClient {
                 error: [{ type: "eq", value: params.errorId }],
                 ...args.filters,
             };
+            await this.validateEventFields(project, filters);
             // Get the latest event for this error using the events endpoint with filters
             let latestEvent = null;
             try {
                 const latestEvents = (await this.errorsApi.listEventsOnProject(project.id, null, "timestamp", "desc", 1, filters, true)).body;
                 if (latestEvents && latestEvents.length > 0) {
                     latestEvent = latestEvents[0];
+                    latestEvent.threads = undefined; // Remove threads to reduce payload size
                 }
             }
             catch (e) {
@@ -397,13 +424,42 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify(content) }],
             };
         });
-        const getEventDetailsInputSchema = z.object({
+        const getEventInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+            eventId: toolInputParameters.eventId,
+        });
+        register({
+            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: getEventInputSchema,
+            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",
+                },
+            ],
+        }, async (args, _extra) => {
+            const params = getEventInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const response = await this.getEvent(params.eventId, project.id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        const getEventDetailsFromDashboardUrlInputSchema = 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."),
         });
         register({
-            title: "Get Event Details",
+            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: [
@@ -411,7 +467,7 @@ export class BugsnagClient {
                 "Extract event information from shared links or browser URLs",
                 "Quick lookup of event details without needing separate project and event IDs",
             ],
-            inputSchema: getEventDetailsInputSchema,
+            inputSchema: getEventDetailsFromDashboardUrlInputSchema,
             examples: [
                 {
                     description: "Get event details from a dashboard URL",
@@ -426,7 +482,7 @@ export class BugsnagClient {
                 "This is useful when users share BugSnag dashboard URLs and you need to extract the event data",
             ],
         }, async (args, _extra) => {
-            const params = getEventDetailsInputSchema.parse(args);
+            const params = getEventDetailsFromDashboardUrlInputSchema.parse(args);
             const url = new URL(params.link);
             const eventId = url.searchParams.get("event_id");
             const projectSlug = url.pathname.split("/")[2];
@@ -510,21 +566,13 @@ export class BugsnagClient {
         }, async (args, _extra) => {
             const params = listProjectErrorsInputSchema.parse(args);
             const project = await this.getInputProject(params.projectId);
-            // Validate filter keys against cached event fields
-            if (params.filters) {
-                const eventFields = await this.getProjectEventFilters(project);
-                const validKeys = new Set(eventFields.map((f) => f.displayId));
-                for (const key of Object.keys(params.filters)) {
-                    if (!validKeys.has(key)) {
-                        throw new ToolError(`Invalid filter key: ${key}`);
-                    }
-                }
-            }
             const filters = {
                 "event.since": [{ type: "eq", value: "30d" }],
                 "error.status": [{ type: "eq", value: "open" }],
                 ...params.filters,
             };
+            // Validate filter keys against cached event fields
+            await this.validateEventFields(project, filters);
             const response = await this.errorsApi.listProjectErrors(project.id, null, params.sort, params.direction, params.perPage, filters, params.nextUrl);
             const result = {
                 data: response.body,
@@ -562,7 +610,7 @@ export class BugsnagClient {
             ],
         }, async (args, _extra) => {
             const params = listProjectEventFiltersInputSchema.parse(args);
-            const eventFilters = await this.getProjectEventFilters(await this.getInputProject(params.projectId));
+            const eventFilters = await this.getProjectEventFields(await this.getInputProject(params.projectId));
             return {
                 content: [{ type: "text", text: JSON.stringify(eventFilters) }],
             };
@@ -800,6 +848,465 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify(build) }],
             };
         });
+        // ============================================================
+        // Performance Monitoring Tools
+        // ============================================================
+        const listSpanGroupsInputSchema = 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,
+        });
+        register({
+            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: listSpanGroupsInputSchema,
+            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",
+            ],
+        }, async (args, _extra) => {
+            const params = listSpanGroupsInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const result = await this.projectApi.listProjectSpanGroups(project.id, params.sort, params.direction, params.perPage, undefined, params.filters, params.starredOnly, params.nextUrl);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            data: result.body,
+                            next_url: result.nextUrl,
+                            count: result.body?.length,
+                        }),
+                    },
+                ],
+            };
+        });
+        const getSpanGroupInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+            spanGroupId: toolInputParameters.spanGroupId,
+            filters: toolInputParameters.performanceFilters,
+        });
+        register({
+            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: getSpanGroupInputSchema,
+            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",
+            ],
+        }, async (args, _extra) => {
+            const params = getSpanGroupInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const spanGroupResults = await this.projectApi.getProjectSpanGroup(project.id, params.spanGroupId, params.filters);
+            const spanGroupTimelineResult = await this.projectApi.getProjectSpanGroupTimeline(project.id, params.spanGroupId, params.filters);
+            const spanGroupDistributionResult = await this.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) }],
+            };
+        });
+        const listSpansInputSchema = 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,
+        });
+        register({
+            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: listSpansInputSchema,
+            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",
+            ],
+        }, async (args, _extra) => {
+            const params = listSpansInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const result = await this.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,
+                        }),
+                    },
+                ],
+            };
+        });
+        const getTraceInputSchema = 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,
+        });
+        register({
+            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: getTraceInputSchema,
+            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",
+            ],
+        }, async (args, _extra) => {
+            const params = getTraceInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            if (!params.traceId || !params.from || !params.to) {
+                throw new ToolError("traceId, from, and to are required");
+            }
+            const result = await this.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,
+                        }),
+                    },
+                ],
+            };
+        });
+        const listTraceFieldsInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+        });
+        // Similar to event filters, consider caching
+        register({
+            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: listTraceFieldsInputSchema,
+            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",
+            ],
+        }, async (args, _extra) => {
+            const params = listTraceFieldsInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const traceFields = await this.getProjectTraceFields(project);
+            return {
+                content: [{ type: "text", text: JSON.stringify(traceFields) }],
+            };
+        });
+        const getNetworkGroupingInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+        });
+        register({
+            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: getNetworkGroupingInputSchema,
+            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,
+        }, async (args, _extra) => {
+            const params = getNetworkGroupingInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const result = await this.projectApi.getProjectNetworkGroupingRuleset(project.id);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result.body.endpoints || []) },
+                ],
+            };
+        });
+        const setNetworkGroupingInputSchema = 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."),
+        });
+        register({
+            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: setNetworkGroupingInputSchema,
+            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,
+        }, async (args, _extra) => {
+            const params = setNetworkGroupingInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const result = await this.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,
+                        }),
+                    },
+                ],
+            };
+        });
     }
     registerResources(register) {
         register("event", "{id}", async (uri, variables, _extra) => {