@smartbear/mcp 0.5.0 → 0.6.0

package/dist/bugsnag/client.js

@@ -2,8 +2,9 @@ import NodeCache from "node-cache";
 import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
 import { CurrentUserAPI, ErrorAPI, Configuration } from "./client/index.js";
-import { ProjectAPI } from "./client/api/Project.js";
 import { FilterObjectSchema, toQueryString } from "./client/api/filters.js";
+import { ProjectAPI, } from "./client/api/Project.js";
+import { getNextUrlPathFromHeader } from "./client/api/base.js";
 const HUB_PREFIX = "00000";
 const DEFAULT_DOMAIN = "bugsnag.com";
 const HUB_DOMAIN = "bugsnag.smartbear.com";
@@ -12,6 +13,9 @@ const cacheKeys = {
     PROJECTS: "bugsnag_projects",
     CURRENT_PROJECT: "bugsnag_current_project",
     CURRENT_PROJECT_EVENT_FILTERS: "bugsnag_current_project_event_filters",
+    BUILD: "bugsnag_build", // + buildId
+    RELEASE: "bugsnag_release", // + releaseId
+    BUILDS_IN_RELEASE: "bugsnag_builds_in_release" // + releaseId
 };
 // Exclude certain event fields from the project event filters to improve agent usage
 const EXCLUDED_EVENT_FIELDS = new Set([
@@ -33,7 +37,7 @@ export class BugsnagClient {
     projectApiKey;
     apiEndpoint;
     appEndpoint;
-    name = "Bugsnag";
+    name = "BugSnag";
     prefix = "bugsnag";
     constructor(token, projectApiKey, endpoint) {
         this.apiEndpoint = this.getEndpoint("api", projectApiKey, endpoint);
@@ -50,14 +54,32 @@ export class BugsnagClient {
         });
         this.currentUserApi = new CurrentUserAPI(config);
         this.errorsApi = new ErrorAPI(config);
-        this.cache = new NodeCache();
+        this.cache = new NodeCache({
+            stdTTL: 24 * 60 * 60, // default cache TTL of 24 hours
+        });
         this.projectApi = new ProjectAPI(config);
         this.projectApiKey = projectApiKey;
     }
     async initialize() {
         // Trigger caching of org and projects
-        await this.getProjects();
-        await this.getCurrentProject();
+        try {
+            await this.getProjects();
+        }
+        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) {
+            try {
+                await this.getCurrentProject();
+            }
+            catch (error) {
+                // 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);
+            }
+        }
     }
     getHost(apiKey, subdomain) {
         if (apiKey && apiKey.startsWith(HUB_PREFIX)) {
@@ -127,10 +149,7 @@ export class BugsnagClient {
         let projects = this.cache.get(cacheKeys.PROJECTS);
         if (!projects) {
             const org = await this.getOrganization();
-            const options = {
-                paginate: true
-            };
-            const response = await this.currentUserApi.getOrganizationProjects(org.id, options);
+            const response = await this.currentUserApi.getOrganizationProjects(org.id);
             projects = response.body || [];
             this.cache.set(cacheKeys.PROJECTS, projects);
         }
@@ -192,6 +211,83 @@ export class BugsnagClient {
             return currentProject;
         }
     }
+    async listBuilds(projectId, opts) {
+        const response = await this.projectApi.listBuilds(projectId, opts);
+        const fetchedBuilds = response.body || [];
+        const nextUrl = getNextUrlPathFromHeader(response.headers, this.apiEndpoint);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedBuilds = fetchedBuilds.map((b) => this.addStabilityData(b, stabilityTargets));
+        return { builds: formattedBuilds, nextUrl };
+    }
+    async getBuild(projectId, buildId) {
+        const cacheKey = `${cacheKeys.BUILD}_${buildId}`;
+        const build = this.cache.get(cacheKey);
+        if (build)
+            return build;
+        const fetchedBuild = (await this.projectApi.getBuild(projectId, buildId)).body;
+        if (!fetchedBuild)
+            throw new Error(`No build for ${buildId} found.`);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedBuild = this.addStabilityData(fetchedBuild, stabilityTargets);
+        this.cache.set(cacheKey, formattedBuild, 5 * 60);
+        return formattedBuild;
+    }
+    async listReleases(projectId, opts) {
+        const response = await this.projectApi.listReleases(projectId, opts);
+        const fetchedReleases = response.body || [];
+        const nextUrl = getNextUrlPathFromHeader(response.headers, this.apiEndpoint);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedReleases = fetchedReleases.map((r) => this.addStabilityData(r, stabilityTargets));
+        return { releases: formattedReleases, nextUrl };
+    }
+    async getRelease(projectId, releaseId) {
+        const cacheKey = `${cacheKeys.RELEASE}_${releaseId}`;
+        const release = this.cache.get(cacheKey);
+        if (release)
+            return release;
+        const fetchedRelease = (await this.projectApi.getRelease(releaseId)).body;
+        if (!fetchedRelease)
+            throw new Error(`No release for ${releaseId} found.`);
+        const stabilityTargets = await this.getProjectStabilityTargets(projectId);
+        const formattedRelease = this.addStabilityData(fetchedRelease, stabilityTargets);
+        this.cache.set(cacheKey, formattedRelease, 5 * 60);
+        return formattedRelease;
+    }
+    async listBuildsInRelease(releaseId) {
+        const cacheKey = `${cacheKeys.BUILDS_IN_RELEASE}_${releaseId}`;
+        const builds = this.cache.get(cacheKey);
+        if (builds)
+            return builds;
+        const fetchedBuilds = (await this.projectApi.listBuildsInRelease(releaseId)).body || [];
+        this.cache.set(cacheKey, fetchedBuilds, 5 * 60);
+        return fetchedBuilds;
+    }
+    async getProjectStabilityTargets(projectId) {
+        return await this.projectApi.getProjectStabilityTargets(projectId);
+    }
+    addStabilityData(source, stabilityTargets) {
+        const { stability_target_type, target_stability, critical_stability } = stabilityTargets;
+        const user_stability = source.accumulative_daily_users_seen === 0 // avoid division by zero
+            ? 0
+            : (source.accumulative_daily_users_seen - source.accumulative_daily_users_with_unhandled) /
+                source.accumulative_daily_users_seen;
+        const session_stability = source.total_sessions_count === 0 // avoid division by zero
+            ? 0
+            : (source.total_sessions_count - source.unhandled_sessions_count) / source.total_sessions_count;
+        const stabilityMetric = stability_target_type === "user" ? user_stability : session_stability;
+        const meets_target_stability = stabilityMetric >= target_stability.value;
+        const meets_critical_stability = stabilityMetric >= critical_stability.value;
+        return {
+            ...source,
+            user_stability,
+            session_stability,
+            stability_target_type,
+            target_stability: target_stability.value,
+            critical_stability: critical_stability.value,
+            meets_target_stability,
+            meets_critical_stability,
+        };
+    }
     registerTools(register, getInput) {
         if (!this.projectApiKey) {
             register({
@@ -420,7 +516,6 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        // Dynamically infer the filters schema from cached project event fields
         register({
             title: "List Project Errors",
             summary: "List and search errors in a project using customizable filters and pagination",
@@ -434,7 +529,10 @@ export class BugsnagClient {
             parameters: [
                 {
                     name: "filters",
-                    type: FilterObjectSchema,
+                    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: [
@@ -451,8 +549,8 @@ export class BugsnagClient {
                 },
                 {
                     name: "sort",
-                    type: z.enum(["first_seen", "last_seen", "events", "users", "unsorted"]),
-                    description: "Field to sort the errors by (default: last_seen)",
+                    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"]
                 },
@@ -465,7 +563,7 @@ export class BugsnagClient {
                 },
                 {
                     name: "per_page",
-                    type: z.number().min(1).max(100),
+                    type: z.number().min(1).max(100).default(30),
                     description: "How many results to return per page.",
                     required: false,
                     examples: ["30", "50", "100"]
@@ -525,6 +623,7 @@ export class BugsnagClient {
                 "Combine multiple filters to narrow results - filters are applied with AND logic",
                 "For time filters: use relative format (7d, 24h) for recent periods or ISO 8601 UTC format (2018-05-20T00:00:00Z) for specific dates",
                 "Common time filters: event.since (from this time), event.before (until this time)",
+                "The 'event.since' filter and 'error.status' filters are always applied and if not specified are set to '30d' and 'open' respectively",
                 "There may not be any errors matching the filters - this is not a problem with the tool, in fact it might be a good thing that the user's application had no errors",
                 "This tool returns paged results. The 'count' field indicates the number of results returned in the current page, and the 'total' field indicates the total number of results across all pages.",
                 "If the output contains a 'next' value, there are more results available - call this tool again supplying the next URL as a parameter to retrieve the next page.",
@@ -542,9 +641,13 @@ export class BugsnagClient {
                     }
                 }
             }
-            const options = {};
-            if (args.filters)
-                options.filters = args.filters;
+            const defaultFilters = {
+                "event.since": [{ "type": "eq", "value": "30d" }],
+                "error.status": [{ "type": "eq", "value": "open" }]
+            };
+            const options = {
+                filters: { ...defaultFilters, ...args.filters }
+            };
             if (args.sort !== undefined)
                 options.sort = args.sort;
             if (args.direction !== undefined)
@@ -673,6 +776,317 @@ export class BugsnagClient {
                 content: [{ type: "text", text: JSON.stringify({ success: result }) }],
             };
         });
+        register({
+            title: "List Builds",
+            summary: "List builds for a project with optional filtering by release stage",
+            purpose: "Retrieve a list of build summaries to analyze deployment history and associated errors",
+            useCases: [
+                "View recent builds to correlate with error spikes",
+                "Filter builds by stage (e.g. production, staging) for targeted analysis",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project to list builds for",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "releaseStage",
+                    type: z.string(),
+                    description: "Filter builds by this stage (e.g. production, staging)",
+                    required: false,
+                    examples: ["production", "staging"],
+                },
+                {
+                    name: "nextUrl",
+                    type: z.string(),
+                    description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available. If provided, other parameters are ignored.",
+                    required: false,
+                    examples: [
+                        "/projects/515fb9337c1074f6fd000003/builds?offset=30&per_page=30",
+                    ],
+                },
+            ],
+            examples: [
+                {
+                    description: "List all builds for a project",
+                    parameters: {},
+                    expectedOutput: "JSON array of build objects with metadata",
+                },
+                {
+                    description: "List production builds for a project",
+                    parameters: {
+                        releaseStage: "production",
+                    },
+                    expectedOutput: "JSON array of build objects in the production stage",
+                },
+                {
+                    description: "Get the next page of results",
+                    parameters: {
+                        nextUrl: "/projects/515fb9337c1074f6fd000003/builds?offset=30&per_page=30",
+                    },
+                    expectedOutput: "JSON array of build objects with metadata from the next page",
+                }
+            ],
+            hints: ["For more detailed results use the Get Build tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON array of build summary objects with metadata",
+        }, async (args, _extra) => {
+            const project = await this.getInputProject(args.projectId);
+            const { builds, nextUrl } = await this.listBuilds(project.id, {
+                release_stage: args.releaseStage,
+                next_url: args.nextUrl,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            builds,
+                            next: nextUrl,
+                        }),
+                    }
+                ],
+            };
+        });
+        register({
+            title: "Get Build",
+            summary: "Get more details for a specific build by its ID",
+            purpose: "Retrieve detailed information about a build for analysis and debugging",
+            useCases: [
+                "View build metadata such as version, source control info, and error counts",
+                "Analyze a specific build to correlate with error spikes or deployments",
+                "See the stability targets for a project and if the build meets them",
+            ],
+            parameters: [
+                ...(this.projectApiKey
+                    ? []
+                    : [
+                        {
+                            name: "projectId",
+                            type: z.string(),
+                            description: "ID of the project containing the build",
+                            required: true,
+                        },
+                    ]),
+                {
+                    name: "buildId",
+                    type: z.string(),
+                    description: "ID of the build to retrieve",
+                    required: true,
+                    examples: ["5f8d0d55c9e77c0017a1b2c3"],
+                },
+            ],
+            examples: [
+                {
+                    description: "Get details for a specific build",
+                    parameters: {
+                        buildId: "5f8d0d55c9e77c0017a1b2c3",
+                    },
+                    expectedOutput: "JSON object with build details including version, source control info, error counts and stability data.",
+                },
+            ],
+            hints: ["Build IDs can be found using the List builds tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON object containing build details along with stability metrics such as user and session stability, and whether it meets project targets",
+        }, async (args, _extra) => {
+            if (!args.buildId)
+                throw new Error("buildId argument is required");
+            const build = await this.getBuild((await this.getInputProject(args.projectId)).id, args.buildId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(build) }],
+            };
+        });
+        register({
+            title: "List Releases",
+            summary: "List releases for a project with optional filtering by release stage",
+            purpose: "Retrieve a list of release summaries to analyze deployment history and associated errors",
+            useCases: [
+                "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(),
+                    description: "Filter releases by this stage (e.g. production, staging)",
+                    required: false,
+                    examples: ["production", "staging"],
+                },
+                {
+                    name: "visibleOnly",
+                    type: z.boolean().default(true),
+                    description: "Whether to only include releases that are marked as visible (default: true)",
+                    required: true,
+                    examples: ["true", "false"],
+                },
+                {
+                    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",
+                    ],
+                },
+            ],
+            examples: [
+                {
+                    description: "List all releases for a project",
+                    parameters: {},
+                    expectedOutput: "JSON array of release objects with metadata",
+                },
+                {
+                    description: "List production releases for a project",
+                    parameters: {
+                        releaseStage: "production",
+                    },
+                    expectedOutput: "JSON array of release objects in the production stage",
+                },
+                {
+                    description: "Get the next page of results",
+                    parameters: {
+                        nextUrl: "/projects/515fb9337c1074f6fd000003/releases?offset=30&per_page=30",
+                    },
+                    expectedOutput: "JSON array of release objects with metadata from the next page",
+                },
+            ],
+            hints: ["For more detailed results use the Get Release tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON array of release summary objects with metadata",
+        }, async (args, _extra) => {
+            const { releases, nextUrl } = await this.listReleases((await this.getInputProject(args.projectId)).id, {
+                release_stage_name: args.releaseStage ?? "production",
+                visible_only: args.visibleOnly,
+                next_url: args.nextUrl ?? null,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            releases,
+                            next: nextUrl ?? null,
+                        }),
+                    },
+                ],
+            };
+        });
+        register({
+            title: "Get Release",
+            summary: "Get more details for a specific release by its ID",
+            purpose: "Retrieve detailed information about a release for analysis and debugging",
+            useCases: [
+                "View release metadata such as version, source control info, and error counts",
+                "Analyze a specific release to correlate with error spikes or deployments",
+                "See the stability targets for a project and if the release meets them",
+            ],
+            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"],
+                },
+            ],
+            examples: [
+                {
+                    description: "Get details for a specific release",
+                    parameters: {
+                        releaseId: "5f8d0d55c9e77c0017a1b2c3",
+                    },
+                    expectedOutput: "JSON object with release details including version, source control info, error counts and stability data.",
+                },
+            ],
+            hints: ["Release IDs can be found using the List releases tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON object containing release details along with stability metrics such as user and session stability, and whether it meets project targets",
+        }, async (args, _extra) => {
+            if (!args.releaseId)
+                throw new Error("releaseId argument is required");
+            const release = await this.getRelease((await this.getInputProject(args.projectId)).id, args.releaseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(release) }],
+            };
+        });
+        register({
+            title: "List Builds in Release",
+            summary: "List builds associated with a specific release",
+            purpose: "Retrieve a list of builds for a given release to analyze deployment history and associated errors",
+            useCases: [
+                "View builds within a release to correlate with error spikes",
+                "Analyze the composition of a release by examining its builds",
+            ],
+            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 list builds for",
+                    required: true,
+                    examples: ["5f8d0d55c9e77c0017a1b2c3"],
+                },
+            ],
+            examples: [
+                {
+                    description: "List all builds in a specific release",
+                    parameters: {
+                        releaseId: "5f8d0d55c9e77c0017a1b2c3",
+                    },
+                    expectedOutput: "JSON array of build objects with metadata",
+                },
+            ],
+            hints: ["Release IDs can be found using the List releases tool"],
+            readOnly: true,
+            idempotent: true,
+            outputFormat: "JSON array of build summary objects with metadata",
+        }, async (args, _extra) => {
+            if (!args.releaseId)
+                throw new Error("releaseId argument is required");
+            const builds = await this.listBuildsInRelease(args.releaseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(builds) }],
+            };
+        });
     }
     registerResources(register) {
         register("event", "{id}", async (uri, variables, _extra) => {

package/dist/common/server.js

@@ -11,6 +11,10 @@ export class SmartBearMcpServer extends McpServer {
             capabilities: {
                 resources: { listChanged: true }, // Server supports dynamic resource lists
                 tools: { listChanged: true }, // Server supports dynamic tool lists
+                sampling: {}, // Server supports sampling requests to Host
+                elicitation: {}, // Server supports eliciting input from the user
+                logging: {}, // Server supports logging messages
+                prompts: {}, // Server supports sending prompts to Host
             },
         });
     }
@@ -48,6 +52,11 @@ export class SmartBearMcpServer extends McpServer {
                 });
             });
         }
+        if (client.registerPrompts) {
+            client.registerPrompts((name, config, cb) => {
+                return super.registerPrompt(name, config, cb);
+            });
+        }
     }
     getAnnotations(toolTitle, params) {
         const annotations = {

package/dist/index.js

@@ -38,11 +38,11 @@ async function main() {
     }
     if (pactBrokerUrl) {
         if (pactBrokerToken) {
-            server.addClient(new PactflowClient(pactBrokerToken, pactBrokerUrl, "pactflow"));
+            server.addClient(new PactflowClient(pactBrokerToken, pactBrokerUrl, "pactflow", server.server));
             client_defined = true;
         }
         else if (pactBrokerUsername && pactBrokerPassword) {
-            server.addClient(new PactflowClient({ username: pactBrokerUsername, password: pactBrokerPassword }, pactBrokerUrl, "pact_broker"));
+            server.addClient(new PactflowClient({ username: pactBrokerUsername, password: pactBrokerPassword }, pactBrokerUrl, "pact_broker", server.server));
             client_defined = true;
         }
         else {

package/dist/pactflow/client/ai.js

@@ -78,7 +78,7 @@ export const EndpointMatcherSchema = z
         .optional()
         .describe("OpenAPI operation ID to match (e.g., 'getUserById', 'get*'). Supports glob patterns"),
 })
-    .required()
+    .optional()
     .describe("REQUIRED: Matcher to specify which endpoints from the OpenAPI document to generate tests for. At least one matcher field must be provided");
 export const RemoteOpenAPIDocumentSchema = z
     .object({
@@ -104,7 +104,8 @@ export const OpenAPIWithMatcherSchema = z
     matcher: EndpointMatcherSchema,
     remoteDocument: RemoteOpenAPIDocumentSchema.optional().describe("The remote OpenAPI document to use for the review/generation in case openapi document is not provided. If provided do not include the document field under openapi."),
 })
-    .describe("If provided, the OpenAPI document which describes the API being tested and is accompanied by a matcher which will be used to identify the interactions in the OpenAPI document which are relevant to the Pact refinement process.").transform(addOpenAPISpecToSchema);
+    .describe("If provided, the OpenAPI document which describes the API being tested and is accompanied by a matcher which will be used to identify the interactions in the OpenAPI document which are relevant to the Pact refinement process.")
+    .transform(addOpenAPISpecToSchema);
 export const RefineInputSchema = z.object({
     pactTests: FileInputSchema.describe("Primary pact tests that needs to be refined."),
     code: z
@@ -144,3 +145,33 @@ export const GenerationInputSchema = z.object({
         .describe("Optional free-form instructions to guide the generation process (e.g., 'Focus on error scenarios', 'Include authentication headers', 'Use specific test framework patterns')"),
     testTemplate: FileInputSchema.optional().describe("Optional test template to use as a basis for generation. Helps ensure generated tests follow your specific patterns, frameworks, and coding standards"),
 });
+export const MatcherRecommendationInputSchema = z.array(EndpointMatcherSchema);
+export const AiCreditsSchema = z.object({
+    total: z
+        .number()
+        .describe("The total number of AI credits available."),
+    used: z
+        .number()
+        .describe("The number of AI credits used."),
+}).describe("AI credits information.");
+export const OrganizationEntitlementsSchema = z.object({
+    name: z
+        .string()
+        .describe("The name of the organization."),
+    planAiEnabled: z
+        .boolean()
+        .describe("Whether AI features are enabled at the plan level."),
+    preferencesAiEnabled: z
+        .boolean()
+        .describe("Whether AI features are enabled at the preferences level."),
+    aiCredits: AiCreditsSchema.describe("AI credits information."),
+}).describe("Organization entitlements information.");
+export const UserEntitlementsSchema = z.object({
+    aiPermissions: z
+        .array(z.string())
+        .describe("List of AI permissions."),
+}).describe("User entitlements information.");
+export const EntitlementsSchema = z.object({
+    organizationEntitlements: OrganizationEntitlementsSchema.describe("Organization entitlements information."),
+    userEntitlements: UserEntitlementsSchema.describe("User entitlements information."),
+}).describe("Entitlements information.");

package/dist/pactflow/client/base.js

@@ -1,6 +1,19 @@
 import { z } from "zod";
 export const CanIDeploySchema = z.object({
-    pacticipant: z.string(),
-    version: z.string(),
-    environment: z.string(),
+    pacticipant: z.string().describe("The name of the pacticipant (application/service) being evaluated for deployment"),
+    version: z.string().describe("The version of the pacticipant that you want to check if it's safe to deploy"),
+    environment: z.string().describe("The target environment where the pacticipant version will be deployed (e.g., 'production', 'staging', 'test')"),
+});
+export const MatrixSchema = z.object({
+    latestby: z.string().optional().describe("This property removes the rows for the overridden pacts/verifications from the results. The options are cvp (show only the latest row for each consumer version and provider) and cvpv (show only the latest row each consumer version and provider version). For a can-i-deploy query with one selector, it should be set to cvp. For a can-i-deploy query with two selectors, it should be set to cvpv."),
+    limit: z.number().min(1).max(1000).default(100).optional().describe("The limit on the number of results to return (1-1000, default: 100)"),
+    q: z.array(z.object({
+        pacticipant: z.string().describe("Name of the pacticipant (application)"),
+        version: z.string().optional().describe("Version number"),
+        branch: z.string().optional().describe("Name of the pacticipant version branch"),
+        environment: z.string().optional().describe("The name of the environment that the pacticipant version is deployed to"),
+        latest: z.boolean().optional().describe("Used in conjunction with other properties to indicate whether the selector is describing the latest version from a branch/with a tag/for a pacticipant, or all of them. Note that when used with tags, the 'latest' is calculated using the creation date of the pacticipant version, NOT the creation date of the tag."),
+        tag: z.string().optional().describe("The name of the pacticipant version tag (superseded by branch and environments)"),
+        mainBranch: z.boolean().optional().describe("Whether or not the version(s) described are from the main branch of the pacticipant, as set in the mainBranch property of the pacticipant resource."),
+    })).min(1).max(2)
 });