@smartbear/mcp 0.10.0 → 0.11.0

package/dist/bugsnag/client.js

@@ -1,17 +1,17 @@
-import NodeCache from "node-cache";
 import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
 import { ToolError, } from "../common/types.js";
-import { Configuration, CurrentUserAPI, ErrorAPI, ProjectAPI, } from "./client/api/index.js";
-import { FilterObjectSchema, toUrlSearchParams, } from "./client/filters.js";
+import { Configuration, CurrentUserAPI, ErrorAPI, ErrorUpdateRequest, ProjectAPI, } from "./client/api/index.js";
+import { toUrlSearchParams } from "./client/filters.js";
+import { toolInputParameters } from "./input-schemas.js";
 const HUB_PREFIX = "00000";
 const DEFAULT_DOMAIN = "bugsnag.com";
 const HUB_DOMAIN = "bugsnag.smartbear.com";
 const cacheKeys = {
     ORG: "bugsnag_org",
     PROJECTS: "bugsnag_projects",
+    PROJECT_EVENT_FILTERS: "bugsnag_project_event_filters",
     CURRENT_PROJECT: "bugsnag_current_project",
-    CURRENT_PROJECT_EVENT_FILTERS: "bugsnag_current_project_event_filters",
 };
 // Exclude certain event fields from the project event filters to improve agent usage
 const EXCLUDED_EVENT_FIELDS = new Set([
@@ -25,57 +25,92 @@ const PERMITTED_UPDATE_OPERATIONS = [
     "discard",
     "undiscard",
 ];
+const ConfigurationSchema = z.object({
+    auth_token: z.string().describe("BugSnag personal authentication token"),
+    project_api_key: z.string().describe("BugSnag project API key").optional(),
+    endpoint: z.string().url().describe("BugSnag endpoint URL").optional(),
+});
 export class BugsnagClient {
-    currentUserApi;
-    errorsApi;
     cache;
-    projectApi;
     projectApiKey;
-    apiEndpoint;
-    appEndpoint;
+    configuredProjectApiKey;
+    _currentUserApi;
+    _errorsApi;
+    _projectApi;
+    _appEndpoint;
+    get currentUserApi() {
+        if (!this._currentUserApi)
+            throw new Error("Client not configured");
+        return this._currentUserApi;
+    }
+    get errorsApi() {
+        if (!this._errorsApi)
+            throw new Error("Client not configured");
+        return this._errorsApi;
+    }
+    get projectApi() {
+        if (!this._projectApi)
+            throw new Error("Client not configured");
+        return this._projectApi;
+    }
+    get appEndpoint() {
+        if (!this._appEndpoint)
+            throw new Error("Client not configured");
+        return this._appEndpoint;
+    }
     name = "BugSnag";
-    prefix = "bugsnag";
-    constructor(token, projectApiKey, endpoint) {
-        this.apiEndpoint = this.getEndpoint("api", projectApiKey, endpoint);
-        this.appEndpoint = this.getEndpoint("app", projectApiKey, endpoint);
-        const config = new Configuration({
-            apiKey: `token ${token}`,
+    toolPrefix = "bugsnag";
+    configPrefix = "Bugsnag";
+    config = ConfigurationSchema;
+    async configure(server, config) {
+        this.cache = server.getCache();
+        this._appEndpoint = this.getEndpoint("app", config.project_api_key, config.endpoint);
+        const apiConfig = new Configuration({
+            apiKey: `token ${config.auth_token}`,
             headers: {
                 "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
                 "Content-Type": "application/json",
                 "X-Bugsnag-API": "true",
                 "X-Version": "2",
             },
-            basePath: this.apiEndpoint,
+            basePath: this.getEndpoint("api", config.project_api_key, config.endpoint),
         });
-        this.currentUserApi = new CurrentUserAPI(config);
-        this.errorsApi = new ErrorAPI(config);
-        this.cache = new NodeCache({
-            stdTTL: 24 * 60 * 60, // default cache TTL of 24 hours
-        });
-        this.projectApi = new ProjectAPI(config);
-        this.projectApiKey = projectApiKey;
-    }
-    async initialize() {
+        this._currentUserApi = new CurrentUserAPI(apiConfig);
+        this._errorsApi = new ErrorAPI(apiConfig);
+        this._projectApi = new ProjectAPI(apiConfig);
+        this.projectApiKey = config.project_api_key;
         // Trigger caching of org and projects
         try {
-            await this.getProjects();
+            const projects = await this.getProjects();
+            // If there's just one project, make this the current project
+            if (projects.length === 1 && !this.projectApiKey) {
+                this.projectApiKey = projects[0].apiKey;
+            }
         }
         catch (error) {
             // Swallow auth errors here to allow the tools to be registered for visibility, even if the token is invalid
             console.error("Unable to connect to BugSnag APIs, the BugSnag tools will not work. Check your configured BugSnag auth token.", error);
         }
         if (this.projectApiKey) {
+            this.configuredProjectApiKey = this.projectApiKey; // Store the originally configured API key
+            let currentProject = null;
             try {
-                await this.getCurrentProject();
+                currentProject = await this.getCurrentProject();
             }
             catch (error) {
+                console.error("An error occurred while fetching project information", error);
+            }
+            if (currentProject) {
+                await this.getProjectEventFilters(currentProject);
+            }
+            else {
                 // Clear the project API key to allow tools to work across all projects
                 this.projectApiKey = undefined;
                 console.error("Unable to find your configured BugSnag project, the BugSnag tools will continue to work across all projects in your organization. " +
-                    "Check your configured BugSnag project API key.", error);
+                    "Check your configured BugSnag project API key.");
             }
         }
+        return true;
     }
     getHost(apiKey, subdomain) {
         if (apiKey?.startsWith(HUB_PREFIX)) {
@@ -126,7 +161,7 @@ export class BugsnagClient {
         return `${dashboardUrl}/errors/${errorId}${queryString ? `?${queryString}` : ""}`;
     }
     async getOrganization() {
-        let org = this.cache.get(cacheKeys.ORG);
+        let org = this.cache?.get(cacheKeys.ORG);
         if (!org) {
             const response = await this.currentUserApi.listUserOrganizations();
             const orgs = response.body;
@@ -134,7 +169,7 @@ export class BugsnagClient {
                 throw new Error("No organizations found for the current user.");
             }
             org = orgs[0];
-            this.cache.set(cacheKeys.ORG, org);
+            this.cache?.set(cacheKeys.ORG, org);
         }
         return org;
     }
@@ -143,12 +178,12 @@ export class BugsnagClient {
     // stores them in the cache for future use.
     // It throws an error if no organizations are found in the cache.
     async getProjects() {
-        let projects = this.cache.get(cacheKeys.PROJECTS);
+        let projects = this.cache?.get(cacheKeys.PROJECTS);
         if (!projects) {
             const org = await this.getOrganization();
             const response = await this.currentUserApi.getOrganizationProjects(org.id);
             projects = response.body;
-            this.cache.set(cacheKeys.PROJECTS, projects);
+            this.cache?.set(cacheKeys.PROJECTS, projects);
         }
         return projects;
     }
@@ -157,28 +192,27 @@ export class BugsnagClient {
         return projects.find((p) => p.id === projectId) || null;
     }
     async getCurrentProject() {
-        let project = this.cache.get(cacheKeys.CURRENT_PROJECT) ?? null;
+        let project = this.cache?.get(cacheKeys.CURRENT_PROJECT) ?? null;
         if (!project && this.projectApiKey) {
             const projects = await this.getProjects();
             project =
                 projects.find((p) => p.apiKey === this.projectApiKey) ?? null;
-            if (!project) {
-                throw new ToolError("Unable to find project with the configured API key.");
-            }
-            this.cache.set(cacheKeys.CURRENT_PROJECT, project);
-            if (project) {
-                this.cache.set(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS, await this.getProjectEventFilters(project));
-            }
+            this.cache?.set(cacheKeys.CURRENT_PROJECT, project);
         }
         return project;
     }
     async getProjectEventFilters(project) {
-        let filtersResponse = (await this.projectApi.listProjectEventFields(project.id)).body;
-        if (!filtersResponse || filtersResponse.length === 0) {
-            throw new ToolError(`No event fields found for project ${project.name}.`);
+        const projectFiltersCache = this.cache?.get(cacheKeys.PROJECT_EVENT_FILTERS) || {};
+        if (!projectFiltersCache[project.id]) {
+            let filtersResponse = (await this.projectApi.listProjectEventFields(project.id)).body;
+            if (!filtersResponse || filtersResponse.length === 0) {
+                throw new ToolError(`No event fields found for project ${project.name}.`);
+            }
+            filtersResponse = filtersResponse.filter((field) => field.displayId && !EXCLUDED_EVENT_FIELDS.has(field.displayId));
+            projectFiltersCache[project.id] = filtersResponse;
+            this.cache?.set(cacheKeys.PROJECT_EVENT_FILTERS, projectFiltersCache);
         }
-        filtersResponse = filtersResponse.filter((field) => field.displayId && !EXCLUDED_EVENT_FIELDS.has(field.displayId));
-        return filtersResponse;
+        return projectFiltersCache[project.id];
     }
     async getEvent(eventId, projectId) {
         const projectIds = projectId
@@ -193,6 +227,10 @@ export class BugsnagClient {
             if (!maybeProject) {
                 throw new ToolError(`Project with ID ${projectId} not found.`);
             }
+            // If this hasn't been configured at startup, set this to the current project for future tool calls
+            if (!this.configuredProjectApiKey) {
+                this.cache?.set(cacheKeys.CURRENT_PROJECT, maybeProject);
+            }
             return maybeProject;
         }
         else {
@@ -232,72 +270,69 @@ export class BugsnagClient {
         };
     }
     registerTools(register, getInput) {
-        if (!this.projectApiKey) {
-            register({
-                title: "List Projects",
-                summary: "List all projects in the organization with optional pagination",
-                purpose: "Retrieve available projects for browsing and selecting which project to analyze",
-                useCases: [
-                    "Browse available projects when no specific project API key is configured",
-                    "Find project IDs needed for other tools",
-                    "Get an overview of all projects in the organization",
-                ],
-                parameters: [
-                    {
-                        name: "pageSize",
-                        type: z.number(),
-                        description: "Number of projects to return per page for pagination",
-                        required: false,
-                        examples: ["10", "25", "50"],
-                    },
-                    {
-                        name: "page",
-                        type: z.number(),
-                        description: "Page number to return (starts from 1)",
-                        required: false,
-                        examples: ["1", "2", "3"],
-                    },
-                ],
-                examples: [
-                    {
-                        description: "Get first 10 projects",
-                        parameters: {
-                            pageSize: 10,
-                            page: 1,
-                        },
-                        expectedOutput: "JSON array of project objects with IDs, names, and metadata",
-                    },
-                    {
-                        description: "Get all projects (no pagination)",
-                        parameters: {},
-                        expectedOutput: "JSON array of all available projects",
-                    },
-                ],
-                hints: [
-                    "Use pagination for organizations with many projects to avoid large responses",
-                    "Project IDs from this list can be used with other tools when no project API key is configured",
-                ],
-            }, async (args, _extra) => {
-                let projects = await this.getProjects();
-                if (!projects || projects.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "No projects found." }],
-                    };
-                }
-                if (args.pageSize || args.page) {
-                    const pageSize = args.pageSize || 10;
-                    const page = args.page || 1;
-                    projects = projects.slice((page - 1) * pageSize, page * pageSize);
-                }
-                const result = {
-                    data: projects,
-                    count: projects.length,
-                };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result) }],
-                };
-            });
-        }
+        register({
+            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",
+            ],
+        }, async (_args, _extra) => {
+            const project = await this.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) }],
+            };
+        });
+        const listProjectsInputSchema = z.object({
+            apiKey: z
+                .string()
+                .optional()
+                .describe("The API key of the BugSnag project, if known."),
+        });
+        register({
+            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: listProjectsInputSchema,
+            hints: [
+                "Project IDs from this list can be used with other tools when no project API key is configured",
+            ],
+        }, async (args, _extra) => {
+            const params = listProjectsInputSchema.parse(args);
+            let projects = await this.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.apiKey === params.apiKey);
+                projects = matchedProject ? [matchedProject] : [];
+            }
+            const content = {
+                data: projects,
+                count: projects.length,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(content) }],
+            };
+        });
+        const getErrorInputSchema = 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)."),
+        });
         register({
             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.",
@@ -308,42 +343,7 @@ export class BugsnagClient {
                 "Get error details for debugging and root cause analysis",
                 "Retrieve error metadata for incident reports and documentation",
             ],
-            parameters: [
-                {
-                    name: "errorId",
-                    type: z.string(),
-                    required: true,
-                    description: "Unique identifier of the error to retrieve",
-                    examples: ["6863e2af8c857c0a5023b411"],
-                },
-                ...(this.projectApiKey
-                    ? []
-                    : [
-                        {
-                            name: "projectId",
-                            type: z.string(),
-                            required: true,
-                            description: "ID of the project containing the error",
-                        },
-                    ]),
-                {
-                    name: "filters",
-                    type: FilterObjectSchema,
-                    required: false,
-                    description: "Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields",
-                    examples: [
-                        '{"error.status": [{"type": "eq", "value": "open"}]}',
-                        '{"event.since": [{"type": "eq", "value": "7d"}]} // Relative time: last 7 days',
-                        '{"event.since": [{"type": "eq", "value": "2018-05-20T00:00:00Z"}]} // ISO 8601 UTC format',
-                        '{"user.email": [{"type": "eq", "value": "user@example.com"}]}',
-                    ],
-                    constraints: [
-                        "Time filters support ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h)",
-                        "ISO 8601 times must be in UTC and use extended format",
-                        "Relative time periods: h (hours), d (days)",
-                    ],
-                },
-            ],
+            inputSchema: getErrorInputSchema,
             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" +
@@ -365,15 +365,14 @@ export class BugsnagClient {
                 "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",
             ],
         }, async (args, _extra) => {
-            const project = await this.getInputProject(args.projectId);
-            if (!args.errorId)
-                throw new ToolError("Both projectId and errorId arguments are required");
-            const errorDetails = (await this.errorsApi.viewErrorOnProject(project.id, args.errorId)).body;
+            const params = getErrorInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const errorDetails = (await this.errorsApi.viewErrorOnProject(project.id, params.errorId)).body;
             if (!errorDetails) {
-                throw new ToolError(`Error with ID ${args.errorId} not found in project ${project.id}.`);
+                throw new ToolError(`Error with ID ${params.errorId} not found in project ${project.id}.`);
             }
             const filters = {
-                error: [{ type: "eq", value: args.errorId }],
+                error: [{ type: "eq", value: params.errorId }],
                 ...args.filters,
             };
             // Get the latest event for this error using the events endpoint with filters
@@ -398,6 +397,11 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify(content) }],
             };
         });
+        const getEventDetailsInputSchema = 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",
             summary: "Get detailed information about a specific event using its dashboard URL",
@@ -407,20 +411,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",
             ],
-            parameters: [
-                {
-                    name: "link",
-                    type: z.string(),
-                    description: "Full URL to the event details page in the BugSnag dashboard (web interface)",
-                    required: true,
-                    examples: [
-                        "https://app.bugsnag.com/my-org/my-project/errors/6863e2af8c857c0a5023b411?event_id=6863e2af012caf1d5c320000",
-                    ],
-                    constraints: [
-                        "Must be a valid dashboard URL containing project slug and event_id parameter",
-                    ],
-                },
-            ],
+            inputSchema: getEventDetailsInputSchema,
             examples: [
                 {
                     description: "Get event details from a dashboard URL",
@@ -435,9 +426,8 @@ export class BugsnagClient {
                 "This is useful when users share BugSnag dashboard URLs and you need to extract the event data",
             ],
         }, async (args, _extra) => {
-            if (!args.link)
-                throw new ToolError("link argument is required");
-            const url = new URL(args.link);
+            const params = getEventDetailsInputSchema.parse(args);
+            const url = new URL(params.link);
             const eventId = url.searchParams.get("event_id");
             const projectSlug = url.pathname.split("/")[2];
             if (!projectSlug || !eventId)
@@ -453,6 +443,15 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
+        const listProjectErrorsInputSchema = 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,
+        });
         register({
             title: "List Project Errors",
             summary: "List and search errors in a project using customizable filters and pagination",
@@ -463,73 +462,7 @@ export class BugsnagClient {
                 "Monitor error trends over time using date range filters",
                 "Find errors affecting specific users or environments using metadata filters",
             ],
-            parameters: [
-                {
-                    name: "filters",
-                    type: FilterObjectSchema.default({
-                        "event.since": [{ type: "eq", value: "30d" }],
-                        "error.status": [{ type: "eq", value: "open" }],
-                    }),
-                    description: "Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields",
-                    required: false,
-                    examples: [
-                        '{"error.status": [{"type": "eq", "value": "open"}]}',
-                        '{"event.since": [{"type": "eq", "value": "7d"}]} // Relative time: last 7 days',
-                        '{"event.since": [{"type": "eq", "value": "2018-05-20T00:00:00Z"}]} // ISO 8601 UTC format',
-                        '{"user.email": [{"type": "eq", "value": "user@example.com"}]}',
-                    ],
-                    constraints: [
-                        "Time filters support ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h)",
-                        "ISO 8601 times must be in UTC and use extended format",
-                        "Relative time periods: h (hours), d (days)",
-                    ],
-                },
-                {
-                    name: "sort",
-                    type: z
-                        .enum(["first_seen", "last_seen", "events", "users", "unsorted"])
-                        .default("last_seen"),
-                    description: "Field to sort the errors by",
-                    required: false,
-                    examples: ["last_seen"],
-                },
-                {
-                    name: "direction",
-                    type: z.enum(["asc", "desc"]).default("desc"),
-                    description: "Sort direction for ordering results",
-                    required: false,
-                    examples: ["desc"],
-                },
-                {
-                    name: "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(),
-                    description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available.",
-                    required: false,
-                    examples: [
-                        "https://api.bugsnag.com/projects/515fb9337c1074f6fd000003/errors?offset=30&per_page=30&sort=last_seen",
-                    ],
-                    constraints: [
-                        "Only values provided in the output from this tool can be used. Do not attempt to construct it manually.",
-                    ],
-                },
-                ...(this.projectApiKey
-                    ? []
-                    : [
-                        {
-                            name: "projectId",
-                            type: z.string(),
-                            description: "ID of the project to query for errors",
-                            required: true,
-                        },
-                    ]),
-            ],
+            inputSchema: listProjectErrorsInputSchema,
             examples: [
                 {
                     description: "Find errors affecting a specific user in the last 24 hours",
@@ -564,7 +497,7 @@ export class BugsnagClient {
                 },
             ],
             hints: [
-                "Use list_project_event_filters tool first to discover valid filter field names for your project",
+                "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)",
@@ -575,12 +508,13 @@ export class BugsnagClient {
                 "Do not modify the next URL as this can cause incorrect results. The only other parameter that can be used with 'next' is 'per_page' to control the page size.",
             ],
         }, async (args, _extra) => {
-            const project = await this.getInputProject(args.projectId);
+            const params = listProjectErrorsInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
             // Validate filter keys against cached event fields
-            if (args.filters) {
-                const eventFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS) || [];
+            if (params.filters) {
+                const eventFields = await this.getProjectEventFilters(project);
                 const validKeys = new Set(eventFields.map((f) => f.displayId));
-                for (const key of Object.keys(args.filters)) {
+                for (const key of Object.keys(params.filters)) {
                     if (!validKeys.has(key)) {
                         throw new ToolError(`Invalid filter key: ${key}`);
                     }
@@ -589,9 +523,9 @@ export class BugsnagClient {
             const filters = {
                 "event.since": [{ type: "eq", value: "30d" }],
                 "error.status": [{ type: "eq", value: "open" }],
-                ...args.filters,
+                ...params.filters,
             };
-            const response = await this.errorsApi.listProjectErrors(project.id, null, args.sort || "last_seen", args.direction || "desc", args.perPage || 30, filters, args.nextUrl);
+            const response = await this.errorsApi.listProjectErrors(project.id, null, params.sort, params.direction, params.perPage, filters, params.nextUrl);
             const result = {
                 data: response.body,
                 next_url: response.nextUrl ?? undefined,
@@ -602,16 +536,19 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify(result) }],
             };
         });
+        const listProjectEventFiltersInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+        });
         register({
             title: "List Project Event Filters",
-            summary: "Get available event filter fields for the current project",
+            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",
             ],
-            parameters: [],
+            inputSchema: listProjectEventFiltersInputSchema,
             examples: [
                 {
                     description: "Get all available filter fields",
@@ -623,14 +560,20 @@ export class BugsnagClient {
                 "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",
             ],
-        }, async (_args, _extra) => {
-            const projectFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS);
-            if (!projectFields)
-                throw new ToolError("No event filters found in cache.");
+        }, async (args, _extra) => {
+            const params = listProjectEventFiltersInputSchema.parse(args);
+            const eventFilters = await this.getProjectEventFilters(await this.getInputProject(params.projectId));
             return {
-                content: [{ type: "text", text: JSON.stringify(projectFields) }],
+                content: [{ type: "text", text: JSON.stringify(eventFilters) }],
             };
         });
+        const updateErrorInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+            errorId: toolInputParameters.errorId,
+            operation: z
+                .enum(PERMITTED_UPDATE_OPERATIONS)
+                .describe("The operation to apply to the error"),
+        });
         register({
             title: "Update Error",
             summary: "Update the status of an error",
@@ -640,32 +583,7 @@ export class BugsnagClient {
                 "Discard or un-discard an error",
                 "Update the severity of an error",
             ],
-            parameters: [
-                ...(this.projectApiKey
-                    ? []
-                    : [
-                        {
-                            name: "projectId",
-                            type: z.string(),
-                            description: "ID of the project that contains the error to be updated",
-                            required: true,
-                        },
-                    ]),
-                {
-                    name: "errorId",
-                    type: z.string(),
-                    description: "ID of the error to update",
-                    required: true,
-                    examples: ["6863e2af8c857c0a5023b411"],
-                },
-                {
-                    name: "operation",
-                    type: z.enum(PERMITTED_UPDATE_OPERATIONS),
-                    description: "The operation to apply to the error",
-                    required: true,
-                    examples: ["fix", "open", "ignore", "discard", "undiscard"],
-                },
-            ],
+            inputSchema: updateErrorInputSchema,
             examples: [
                 {
                     description: "Mark an error as fixed",
@@ -682,10 +600,10 @@ export class BugsnagClient {
             readOnly: false,
             idempotent: false,
         }, async (args, _extra) => {
-            const { errorId, operation } = args;
-            const project = await this.getInputProject(args.projectId);
+            const params = updateErrorInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
             let severity;
-            if (operation === "override_severity") {
+            if (params.operation === "override_severity") {
                 // illicit the severity from the user
                 const result = await getInput({
                     message: "Please provide the new severity for the error (e.g. 'info', 'warning', 'error', 'critical')",
@@ -705,8 +623,8 @@ export class BugsnagClient {
                     severity = result.content.severity;
                 }
             }
-            const result = await this.errorsApi.updateErrorOnProject(project.id, errorId, {
-                operation: operation,
+            const result = await this.errorsApi.updateErrorOnProject(project.id, params.errorId, {
+                operation: Object.values(ErrorUpdateRequest.OperationEnum).find((value) => value === params.operation),
                 severity: severity,
             });
             return {
@@ -720,6 +638,16 @@ export class BugsnagClient {
                 ],
             };
         });
+        const listReleasesInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+            releaseStage: toolInputParameters.releaseStage,
+            visibleOnly: z
+                .boolean()
+                .describe("Whether to only include releases that are marked as visible in the dashboard")
+                .default(false),
+            perPage: toolInputParameters.perPage,
+            nextUrl: toolInputParameters.nextUrl,
+        });
         register({
             title: "List Releases",
             summary: "List releases for a project",
@@ -728,48 +656,7 @@ export class BugsnagClient {
                 "View recent releases to correlate with error spikes",
                 "Filter releases by stage (e.g. production, staging) for targeted analysis",
             ],
-            parameters: [
-                ...(this.projectApiKey
-                    ? []
-                    : [
-                        {
-                            name: "projectId",
-                            type: z.string(),
-                            description: "ID of the project to list releases for",
-                            required: true,
-                        },
-                    ]),
-                {
-                    name: "releaseStage",
-                    type: z.string().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(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(),
-                    description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available. If provided, other parameters are ignored.",
-                    required: false,
-                    examples: [
-                        "/projects/515fb9337c1074f6fd000003/releases?offset=30&per_page=30",
-                    ],
-                },
-            ],
+            inputSchema: listReleasesInputSchema,
             examples: [
                 {
                     description: "List production releases for a project",
@@ -800,9 +687,10 @@ export class BugsnagClient {
             idempotent: true,
             outputDescription: "JSON array of release summary objects with metadata, with a URL to the next page if more results are available",
         }, async (args, _extra) => {
-            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);
+            const params = listReleasesInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const response = await this.projectApi.listProjectReleaseGroups(project.id, params.releaseStage, false, // Not top-only
+            params.visibleOnly, params.perPage, params.nextUrl);
             let releases = [];
             if (response.body) {
                 releases = response.body.map((r) => this.addStabilityData(r, project));
@@ -821,6 +709,10 @@ export class BugsnagClient {
                 ],
             };
         });
+        const getReleaseInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+            releaseId: toolInputParameters.releaseId,
+        });
         register({
             title: "Get Release",
             summary: "Get more details for a specific release by its ID, including source control information and associated builds",
@@ -830,25 +722,7 @@ export class BugsnagClient {
                 "Analyze the stability data and targets for a release",
                 "See the builds that make up the release",
             ],
-            parameters: [
-                ...(this.projectApiKey
-                    ? []
-                    : [
-                        {
-                            name: "projectId",
-                            type: z.string(),
-                            description: "ID of the project containing the release",
-                            required: true,
-                        },
-                    ]),
-                {
-                    name: "releaseId",
-                    type: z.string(),
-                    description: "ID of the release to retrieve",
-                    required: true,
-                    examples: ["5f8d0d55c9e77c0017a1b2c3"],
-                },
-            ],
+            inputSchema: getReleaseInputSchema,
             examples: [
                 {
                     description: "Get details for a specific release",
@@ -863,16 +737,15 @@ export class BugsnagClient {
             idempotent: true,
             outputDescription: "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 ToolError("releaseId argument is required");
-            const project = await this.getInputProject(args.projectId);
-            const releaseResponse = await this.projectApi.getReleaseGroup(args.releaseId);
+            const params = getReleaseInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const releaseResponse = await this.projectApi.getReleaseGroup(params.releaseId);
             if (!releaseResponse.body)
-                throw new ToolError(`No release for ${args.releaseId} found.`);
+                throw new ToolError(`No release for ${params.releaseId} found.`);
             const release = this.addStabilityData(releaseResponse.body, project);
             let builds = [];
             if (releaseResponse.body) {
-                const buildsResponse = await this.projectApi.listBuildsInRelease(args.releaseId);
+                const buildsResponse = await this.projectApi.listBuildsInRelease(params.releaseId);
                 if (buildsResponse.body) {
                     builds = buildsResponse.body.map((b) => this.addStabilityData(b, project));
                 }
@@ -889,6 +762,10 @@ export class BugsnagClient {
                 ],
             };
         });
+        const getBuildInputSchema = z.object({
+            projectId: toolInputParameters.projectId,
+            buildId: toolInputParameters.buildId,
+        });
         register({
             title: "Get Build",
             summary: "Get more details for a specific build by its ID",
@@ -898,25 +775,7 @@ export class BugsnagClient {
                 "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"],
-                },
-            ],
+            inputSchema: getBuildInputSchema,
             examples: [
                 {
                     description: "Get details for a specific build",
@@ -931,12 +790,11 @@ export class BugsnagClient {
             idempotent: true,
             outputDescription: "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 ToolError("buildId argument is required");
-            const project = await this.getInputProject(args.projectId);
-            const response = await this.projectApi.getProjectReleaseById(project.id, args.buildId);
+            const params = getBuildInputSchema.parse(args);
+            const project = await this.getInputProject(params.projectId);
+            const response = await this.projectApi.getProjectReleaseById(project.id, params.buildId);
             if (!response.body)
-                throw new ToolError(`No build for ${args.buildId} found.`);
+                throw new ToolError(`No build for ${params.buildId} found.`);
             const build = this.addStabilityData(response.body, project);
             return {
                 content: [{ type: "text", text: JSON.stringify(build) }],