@smartbear/mcp 0.5.0 → 0.7.0

package/dist/common/info.js

@@ -1,3 +1,3 @@
-import packageJson from '../../package.json' with { type: "json" };
+import packageJson from "../../package.json" with { type: "json" };
 export const MCP_SERVER_NAME = packageJson.config.mcpServerName;
 export const MCP_SERVER_VERSION = packageJson.version;

package/dist/common/server.js

@@ -1,4 +1,4 @@
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ZodAny, ZodArray, ZodBoolean, ZodEnum, ZodLiteral, ZodNumber, ZodObject, ZodString, ZodUnion, } from "zod";
 import Bugsnag from "../common/bugsnag.js";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./info.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
             },
         });
     }
@@ -37,7 +41,9 @@ export class SmartBearMcpServer extends McpServer {
         });
         if (client.registerResources) {
             client.registerResources((name, path, cb) => {
-                return super.registerResource(name, new ResourceTemplate(`${client.prefix}://${name}/${path}`, { list: undefined }), {}, async (url, variables, extra) => {
+                return super.registerResource(name, new ResourceTemplate(`${client.prefix}://${name}/${path}`, {
+                    list: undefined,
+                }), {}, async (url, variables, extra) => {
                     try {
                         return await cb(url, variables, extra);
                     }
@@ -48,6 +54,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 = {
@@ -85,64 +96,70 @@ export class SmartBearMcpServer extends McpServer {
         return args;
     }
     getDescription(params) {
-        const { summary, useCases, examples, parameters, zodSchema, hints, outputFormat } = params;
+        const { summary, useCases, examples, parameters, zodSchema, hints, outputFormat, } = params;
         let description = summary;
         // Parameters if available otherwise use zodSchema
         if ((parameters ?? []).length > 0) {
-            description += `\n\n**Parameters:**\n${parameters?.map(p => `- ${p.name} (${this.getReadableTypeName(p.type)})${p.required ? ' *required*' : ''}` +
-                `${p.description ? `: ${p.description}` : ''}` +
-                `${p.examples ? ` (e.g. ${p.examples.join(', ')})` : ''}` +
-                `${p.constraints ? `\n  - ${p.constraints.join('\n  - ')}` : ''}`).join('\n')}`;
+            description += `\n\n**Parameters:**\n${parameters
+                ?.map((p) => `- ${p.name} (${this.getReadableTypeName(p.type)})${p.required ? " *required*" : ""}` +
+                `${p.description ? `: ${p.description}` : ""}` +
+                `${p.examples ? ` (e.g. ${p.examples.join(", ")})` : ""}` +
+                `${p.constraints ? `\n  - ${p.constraints.join("\n  - ")}` : ""}`)
+                .join("\n")}`;
         }
         if (zodSchema && zodSchema instanceof ZodObject) {
             description += "\n\n**Parameters:**\n";
             description += Object.keys(zodSchema.shape)
-                .map(key => this.formatParameterDescription(key, zodSchema.shape[key]))
-                .join('\n');
+                .map((key) => this.formatParameterDescription(key, zodSchema.shape[key]))
+                .join("\n");
         }
         if (outputFormat) {
             description += `\n\n**Output Format:** ${outputFormat}`;
         }
         // Use Cases
         if (useCases && useCases.length > 0) {
-            description += `\n\n**Use Cases:** ${useCases.map((uc, i) => `${i + 1}. ${uc}`).join(' ')}`;
+            description += `\n\n**Use Cases:** ${useCases.map((uc, i) => `${i + 1}. ${uc}`).join(" ")}`;
         }
         // Examples
         if (examples && examples.length > 0) {
-            description += `\n\n**Examples:**\n` + examples.map((ex, idx) => `${idx + 1}. ${ex.description}\n\`\`\`json\n${JSON.stringify(ex.parameters, null, 2)}\n\`\`\`${ex.expectedOutput ? `\nExpected Output: ${ex.expectedOutput}` : ''}`).join('\n\n');
+            description +=
+                `\n\n**Examples:**\n` +
+                    examples
+                        .map((ex, idx) => `${idx + 1}. ${ex.description}\n\`\`\`json\n${JSON.stringify(ex.parameters, null, 2)}\n\`\`\`${ex.expectedOutput ? `\nExpected Output: ${ex.expectedOutput}` : ""}`)
+                        .join("\n\n");
         }
         // Hints
         if (hints && hints.length > 0) {
-            description += `\n\n**Hints:** ${hints.map((hint, i) => `${i + 1}. ${hint}`).join(' ')}`;
+            description += `\n\n**Hints:** ${hints.map((hint, i) => `${i + 1}. ${hint}`).join(" ")}`;
         }
         return description.trim();
     }
     formatParameterDescription(key, field) {
-        return `- ${key} (${this.getReadableTypeName(field)})` +
-            `${field.isOptional() ? '' : ' *required*'}` +
-            `${field.description ? `: ${field.description}` : ''}` +
-            `${key === "examples" && field instanceof ZodEnum ? ` (e.g. ${Object.keys(field.enum).join(', ')})` : ''}` +
-            `${key === "constraints" && field instanceof ZodEnum ? `\n  - ${Object.keys(field.enum).join('\n  - ')}` : ''}`;
+        return (`- ${key} (${this.getReadableTypeName(field)})` +
+            `${field.isOptional() ? "" : " *required*"}` +
+            `${field.description ? `: ${field.description}` : ""}` +
+            `${key === "examples" && field instanceof ZodEnum ? ` (e.g. ${Object.keys(field.enum).join(", ")})` : ""}` +
+            `${key === "constraints" && field instanceof ZodEnum ? `\n  - ${Object.keys(field.enum).join("\n  - ")}` : ""}`);
     }
     getReadableTypeName(zodType) {
         if (zodType instanceof ZodString)
-            return 'string';
+            return "string";
         if (zodType instanceof ZodNumber)
-            return 'number';
+            return "number";
         if (zodType instanceof ZodBoolean)
-            return 'boolean';
+            return "boolean";
         if (zodType instanceof ZodArray)
-            return 'array';
+            return "array";
         if (zodType instanceof ZodObject)
-            return 'object';
+            return "object";
         if (zodType instanceof ZodEnum)
-            return 'enum';
+            return "enum";
         if (zodType instanceof ZodLiteral)
-            return 'literal';
+            return "literal";
         if (zodType instanceof ZodUnion)
-            return 'union';
+            return "union";
         if (zodType instanceof ZodAny)
-            return 'any';
-        return 'any';
+            return "any";
+        return "any";
     }
 }

package/dist/index.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import Bugsnag from "./common/bugsnag.js";
-import { BugsnagClient } from "./bugsnag/client.js";
-import { ReflectClient } from "./reflect/client.js";
 import { ApiHubClient } from "./api-hub/client.js";
+import { BugsnagClient } from "./bugsnag/client.js";
+import Bugsnag from "./common/bugsnag.js";
 import { SmartBearMcpServer } from "./common/server.js";
 import { PactflowClient } from "./pactflow/client.js";
+import { QmetryClient } from "./qmetry/client.js";
+import { ReflectClient } from "./reflect/client.js";
 // This is used to report errors in the MCP server itself
 // If you want to use your own BugSnag API key, set the MCP_SERVER_BUGSNAG_API_KEY environment variable
 const McpServerBugsnagAPIKey = process.env.MCP_SERVER_BUGSNAG_API_KEY;
@@ -21,6 +22,8 @@ async function main() {
     const pactBrokerUrl = process.env.PACT_BROKER_BASE_URL;
     const pactBrokerUsername = process.env.PACT_BROKER_USERNAME;
     const pactBrokerPassword = process.env.PACT_BROKER_PASSWORD;
+    const qmetryToken = process.env.QMETRY_API_KEY;
+    const qmetryBaseUrl = process.env.QMETRY_BASE_URL;
     let client_defined = false;
     if (reflectToken) {
         server.addClient(new ReflectClient(reflectToken));
@@ -38,19 +41,23 @@ 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 {
             console.error("If the Pact Broker base URL is specified, you must specify either (a) a PactFlow token, or (b) a Pact Broker username and password pair.");
         }
     }
+    if (qmetryToken) {
+        server.addClient(new QmetryClient(qmetryToken, qmetryBaseUrl));
+        client_defined = true;
+    }
     if (!client_defined) {
-        console.error("Please set one of REFLECT_API_TOKEN, BUGSNAG_AUTH_TOKEN, API_HUB_API_KEY or PACT_BROKER_BASE_URL / (and relevant Pact auth) environment variables");
+        console.error("Please set one of REFLECT_API_TOKEN, BUGSNAG_AUTH_TOKEN, API_HUB_API_KEY, QMETRY_API_KEY or PACT_BROKER_BASE_URL / (and relevant Pact auth) environment variables");
         process.exit(1);
     }
     const transport = new StdioServerTransport();

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,54 @@
 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),
 });

package/dist/pactflow/client/prompt-utils.js

@@ -0,0 +1,89 @@
+import { EndpointMatcherSchema, MatcherRecommendationInputSchema, } from "./ai.js";
+import { OADMatcherPrompt } from "./prompts.js";
+/**
+ * Get OpenAPI matcher recommendations using sampling.
+ *
+ * @param openAPI The OpenAPI document to analyze.
+ * @param server The SmartBear MCP server instance.
+ * @returns A promise that resolves to the matcher recommendations.
+ * @throws Error if unable to parse recommendations.
+ */
+export async function getOADMatcherRecommendations(openAPI, server) {
+    const matcherResponse = await server.createMessage({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: OADMatcherPrompt.replace("{0}", JSON.stringify(openAPI)),
+                },
+            },
+        ],
+        maxTokens: 1000,
+    });
+    const regex = /```json[c5]?([\s\S]*?)```/i;
+    const match = regex.exec(matcherResponse.content.text);
+    if (match) {
+        const jsonText = match[1].trim();
+        const parsed = JSON.parse(jsonText);
+        const matcherRecommendations = MatcherRecommendationInputSchema.parse(parsed);
+        return matcherRecommendations;
+    }
+    else {
+        throw new Error("Unable to parse recommendations please provide OpenAPI matchers manually.");
+    }
+}
+/**
+ * Get user selection for matcher recommendations.
+ *
+ * @param recommendations The list of matcher recommendations.
+ * @param getInput The function to get user input.
+ * @returns The selected endpoint matcher.
+ */
+export async function getUserMatcherSelection(recommendations, getInput) {
+    const recommendationsMap = new Map();
+    recommendations.forEach((rec, index) => {
+        recommendationsMap.set(`Recommendation ${index + 1}`, JSON.stringify(rec));
+    });
+    const result = await getInput({
+        message: `Select one of the generated matchers you would want to use \n\n ${recommendations
+            .map((rec, index) => `\n\nRecommendation ${index + 1}: \n\n\n ${JSON.stringify(rec)}`)
+            .join("\n\n")}`,
+        requestedSchema: {
+            type: "object",
+            properties: {
+                generatedMatchers: {
+                    type: "string",
+                    title: "Generated Matchers",
+                    description: "Use the matchers generated for the OpenAPI document",
+                    enum: recommendations.map((_, index) => `Recommendation ${index + 1}`),
+                },
+            },
+            required: ["generatedMatchers"],
+        },
+    });
+    if (result.action === "accept") {
+        return EndpointMatcherSchema.parse(JSON.parse(recommendationsMap.get(result.content?.generatedMatchers) ||
+            ""));
+    }
+    else {
+        const result = await getInput({
+            message: "Enter the matchers you would want to use for the OpenAPI document",
+            requestedSchema: {
+                type: "object",
+                properties: {
+                    enteredMatchers: {
+                        type: "string",
+                        title: "Enter the matchers you would want to use for the OpenAPI document",
+                        description: "Enter the matchers you would want to use for the OpenAPI document",
+                    },
+                },
+                required: ["enteredMatchers"],
+            },
+        });
+        if (result.action === "accept") {
+            return EndpointMatcherSchema.parse(JSON.parse(result.content?.enteredMatchers));
+        }
+        return {};
+    }
+}

package/dist/pactflow/client/prompts.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { EndpointMatcherSchema } from "./ai.js";
+const OADMatcherPromptOpenAPIDocExample = {
+    openapi: "3.1.0",
+    info: {
+        title: "My API",
+        version: "1.0.0",
+        description: "A sample API for demonstration purposes.",
+    },
+    paths: {
+        "/users": {
+            get: {
+                summary: "Get all users",
+                responses: {
+                    "200": {
+                        description: "A list of users",
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "array",
+                                    items: {
+                                        $ref: "#/components/schemas/User",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+    components: {
+        schemas: {
+            User: {
+                type: "object",
+                properties: {
+                    id: {
+                        type: "integer",
+                        format: "int64",
+                    },
+                    name: {
+                        type: "string",
+                    },
+                },
+            },
+        },
+    },
+};
+const OADMatcherPromptRecommendationExample = [
+    {
+        path: "/users",
+        methods: ["GET"],
+        statusCodes: [200, "2XX"],
+        operationId: "get*",
+    },
+    {
+        path: "/users/*",
+        methods: ["GET"],
+        statusCodes: ["2XX"],
+        operationId: "*User*",
+    },
+    {
+        path: "/users",
+        methods: ["GET"],
+        statusCodes: [200],
+        operationId: "getAllUsers",
+    },
+    {
+        path: "/users/**",
+        methods: ["GET"],
+        statusCodes: ["2XX", 404],
+        operationId: "get*",
+    },
+];
+export const OADMatcherPrompt = `
+
+Generate a list of recommendations(maximum of 5) in JSON to use with an OpenAPI matcher.
+Zod Schema for the matcher to be generated is provided below in the markdown block of javascript use this to generate the recommendations for the matcher. Recommendations should contain all the fields from the schema and only output the JSON in a markdown formatted block.
+
+\`\`\`javascript
+const EndpointMatcherSchema = ${JSON.stringify(zodToJsonSchema(EndpointMatcherSchema))};
+\`\`\`
+
+Example OpenAPI document:-
+
+if OpenAPI document provided is:-
+
+\`\`\`json
+${JSON.stringify(OADMatcherPromptOpenAPIDocExample, null, 2)}
+\`\`\`
+
+Generated recommendations are:-
+
+\`\`\`json
+${JSON.stringify(OADMatcherPromptRecommendationExample, null, 2)}
+\`\`\`
+
+Actual OpenAPI document:-
+
+Now provided the below OpenAPI document:-
+
+\`\`\`json
+{0}
+\`\`\`
+
+Give JSON recommendations only provide the JSON block in markdown don't include any additional text.
+`;
+export const PROMPTS = [
+    {
+        name: "OpenAPI Matcher recommendations",
+        params: {
+            description: "Get OpenAPI matcher recommendations using sampling",
+            title: "OpenAPI Matcher recommendations",
+            argsSchema: {
+                openAPI: z.string(),
+            },
+        },
+        callback: ({ openAPI }) => ({
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: OADMatcherPrompt.replace("{0}", openAPI),
+                    },
+                },
+            ],
+        }),
+    },
+];

package/dist/pactflow/client/tools.js

@@ -11,7 +11,7 @@
  */
 import { z } from "zod";
 import { GenerationInputSchema, RefineInputSchema } from "./ai.js";
-import { CanIDeploySchema } from "./base.js";
+import { CanIDeploySchema, MatrixSchema } from "./base.js";
 export const TOOLS = [
     {
         title: "Generate Pact Tests",
@@ -20,6 +20,7 @@ export const TOOLS = [
         zodSchema: GenerationInputSchema,
         handler: "generate",
         clients: ["pactflow"], // ONLY pactflow
+        enableElicitation: true,
     },
     {
         title: "Review Pact Tests",
@@ -27,7 +28,8 @@ export const TOOLS = [
         purpose: "Review Pact tests for API interactions",
         zodSchema: RefineInputSchema,
         handler: "review",
-        clients: ["pactflow"]
+        clients: ["pactflow"],
+        enableElicitation: true,
     },
     {
         title: "Get Provider States",
@@ -38,11 +40,11 @@ export const TOOLS = [
                 name: "provider",
                 type: z.string(),
                 description: "name of the provider to retrieve states for",
-                required: true
-            }
+                required: true,
+            },
         ],
         handler: "getProviderStates",
-        clients: ["pactflow", "pact_broker"]
+        clients: ["pactflow", "pact_broker"],
     },
     {
         title: "Can I Deploy",
@@ -50,6 +52,36 @@ export const TOOLS = [
         purpose: "To serve as a deployment safety check within the PactBroker and PactFlow ecosystem, leveraging contract testing results to validate whether a specific service / pacticipant version is compatible with all integrated services. This feature prevents unsafe releases, reduces integration risks, and enables teams to confidently automate deployments across environments with a clear, auditable record of verification results.",
         zodSchema: CanIDeploySchema,
         handler: "canIDeploy",
-        clients: ["pactflow", "pact_broker"]
-    }
+        clients: ["pactflow", "pact_broker"],
+    },
+    {
+        title: "Matrix",
+        summary: "Retrieve the comprehensive contract verification matrix that shows the relationship between consumer and provider versions, their associated pact files, and verification results stored in the Pact Broker or Pactflow. The matrix provides detailed visibility into which consumer and provider versions have been successfully verified against each other, and highlights failures with detailed information about the cause.",
+        purpose: "The Matrix serves as a powerful tool for teams to understand the state of their contract testing ecosystem. It enables tracking of all interactions between consumer and provider versions over time, with detailed insights into verification successes and failures. This helps teams rapidly identify compatibility issues, understand why specific verifications failed, and make informed decisions about deployments. Matrix offers a more intuitive and consolidated view of the verification status, making it easier to spot trends or problematic versions. Additionally, the Matrix supports complex queries using selectors, and can answer specific 'can-i-deploy' questions, ensuring that only compatible versions are deployed to production environments.",
+        useCases: [
+            "Quickly identify which consumer and provider version combinations have passed or failed verification.",
+            "Diagnose and investigate why a particular consumer-provider verification failed.",
+            "Visualize the overall contract compatibility across two pacticipants / services.",
+            "Perform advanced queries using selectors to understand compatibility within specific branches, environments, or version ranges.",
+            "Support informed deployment decisions by answering 'can I deploy version X of this service to production?'",
+            "Expose contract verification details to non-frequent API users in a more accessible format.",
+        ],
+        zodSchema: MatrixSchema,
+        handler: "getMatrix",
+        clients: ["pactflow", "pact_broker"],
+    },
+    {
+        title: "PactFlow AI Status",
+        summary: "Check PactFlow AI usage status, remaining credits, and eligibility",
+        purpose: "Retrieve the AI feature status for the PactFlow account, including whether AI is enabled, the number of remaining and consumed AI credits, and entitlement or permission issues preventing usage.",
+        useCases: [
+            "Verify if AI functionality is enabled for the account before attempting to use AI-powered features",
+            "Monitor remaining and consumed AI credits to manage usage and avoid unexpected disruptions",
+            "Detect entitlement or permission issues when a user tries to access AI features and guide corrective actions",
+            "Integrate into deployment pipelines to ensure the environment is correctly configured with necessary entitlements and sufficient credits before executing AI-driven tasks",
+            "Fetches usage and entitlement reports for auditing, budgeting, and compliance purposes",
+        ],
+        handler: "getAIStatus",
+        clients: ["pactflow"],
+    },
 ];

package/dist/pactflow/client/utils.js

@@ -1,7 +1,7 @@
-import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
 import yaml from "js-yaml";
 // @ts-expect-error missing type declarations
 import Swagger from "swagger-client";
+import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
 /**
  * Resolve the OpenAPI specification from the provided input.
  *