@smartbear/mcp 0.12.0 → 0.13.1

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

@@ -1,90 +1,99 @@
-import { ToolError } from "../../common/types.js";
-import { EndpointMatcherSchema, MatcherRecommendationInputSchema, } from "./ai.js";
+import { ToolError } from "../../common/tools.js";
+import { MatcherRecommendationInputSchema, EndpointMatcherSchema } 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 ToolError("Unable to parse recommendations please provide OpenAPI matchers manually.");
-    }
+async function getOADMatcherRecommendations(openAPI, server) {
+  const matcherResponse = await server.createMessage({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: OADMatcherPrompt.replace("{0}", JSON.stringify(openAPI))
+        }
+      }
+    ],
+    maxTokens: 1e3
+  });
+  const regex = /```json[c5]?([\s\S]*?)```/i;
+  const content = matcherResponse.content;
+  if (content.type !== "text") {
+    throw new Error(
+      `Received unexpected response type from matcher recommendations: ${content.type}`
+    );
+  }
+  const match = regex.exec(content.text);
+  if (match) {
+    const jsonText = match[1].trim();
+    const parsed = JSON.parse(jsonText);
+    const matcherRecommendations = MatcherRecommendationInputSchema.parse(parsed);
+    return matcherRecommendations;
+  } else {
+    throw new ToolError(
+      "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"],
+async function getUserMatcherSelection(recommendations, getInput) {
+  const recommendationsMap = /* @__PURE__ */ 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 
+
+ ${recommendations.map(
+      (rec, index) => `
+
+Recommendation ${index + 1}: 
+
+
+ ${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 result2 = 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(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 {};
+    if (result2.action === "accept") {
+      return EndpointMatcherSchema.parse(
+        JSON.parse(result2.content?.enteredMatchers)
+      );
     }
+    return {};
+  }
 }
+export {
+  getOADMatcherRecommendations,
+  getUserMatcherSelection
+};

package/dist/pactflow/client/prompts.js

@@ -1,85 +1,84 @@
 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",
-                    },
-                },
-            },
-        },
-    },
+  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*",
-    },
+  {
+    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 = `
+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))};
+const EndpointMatcherSchema = ${JSON.stringify(EndpointMatcherSchema.toJSONSchema())};
 \`\`\`
 
 Example OpenAPI document:-
@@ -106,26 +105,30 @@ Now provided the below OpenAPI document:-
 
 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),
-                    },
-                },
-            ],
-        }),
+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)
+          }
+        }
+      ]
+    })
+  }
 ];
+export {
+  OADMatcherPrompt,
+  PROMPTS
+};

package/dist/pactflow/client/tools.js

@@ -1,87 +1,98 @@
-/**
- * TOOLS
- *
- * Extends the default `ToolParams` with:
- *  - `handler`: Name of the `PactflowClient` method to execute.
- *  - `clients`: List of `ClientType`s allowed to use the tool.
- *  - `formatResponse` (optional): Formats the tool's output before returning.
- *
- * In `PactflowClient.registerTools()`, tools are filtered by `clientType`
- * and registered with their corresponding handler.
- */
 import { z } from "zod";
 import { GenerationInputSchema, RefineInputSchema } from "./ai.js";
 import { CanIDeploySchema, MatrixSchema } from "./base.js";
-export const TOOLS = [
-    {
-        title: "Generate Pact Tests",
-        summary: "Generate Pact tests using PactFlow AI. You can provide one or more of the following input types: (1) request/response pairs for specific interactions, (2) code files to analyze and extract interactions from, and/or (3) OpenAPI document to generate tests for specific endpoints. When providing an OpenAPI document, a matcher is required to specify which endpoints to generate tests for.",
-        purpose: "Generate Pact tests for API interactions",
-        inputSchema: GenerationInputSchema,
-        handler: "generate",
-        clients: ["pactflow"], // ONLY pactflow
-        enableElicitation: true,
-    },
-    {
-        title: "Review Pact Tests",
-        summary: "Review Pact tests using PactFlow AI. You can provide the following inputs: (1) Pact tests to be reviewed along with metadata",
-        purpose: "Review Pact tests for API interactions",
-        inputSchema: RefineInputSchema,
-        handler: "review",
-        clients: ["pactflow"],
-        enableElicitation: true,
-    },
-    {
-        title: "Get Provider States",
-        summary: "Retrieve the states of a specific provider",
-        purpose: "A provider state in Pact defines the specific preconditions that must be met on the provider side before a consumer–provider interaction can be tested. It sets up the provider in the right context—such as ensuring a particular user or record exists—so that the provider can return the response the consumer expects. This makes contract tests reliable, repeatable, and isolated by injecting or configuring the necessary data and conditions directly into the provider before each test runs.",
-        parameters: [
-            {
-                name: "provider",
-                type: z.string(),
-                description: "name of the provider to retrieve states for",
-                required: true,
-            },
-        ],
-        handler: "getProviderStates",
-        clients: ["pactflow", "pact_broker"],
-    },
-    {
-        title: "Can I Deploy",
-        summary: "Performs a comprehensive compatibility check to determine whether a specific version of a service (pacticipant) can be safely deployed into a given environment. It analyzes the complete contract matrix of consumer-provider relationships to confirm that all required integrations are verified and compatible.",
-        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.",
-        inputSchema: CanIDeploySchema,
-        handler: "canIDeploy",
-        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.",
-        ],
-        inputSchema: MatrixSchema,
-        handler: "getMatrix",
-        clients: ["pactflow", "pact_broker"],
-    },
-    {
-        title: "Check PactFlow AI Entitlements",
-        summary: "Check your PactFlow AI entitlements and credit balance if you encounter 401 Unauthorized errors or permission/credit issues when using PactFlow AI features.",
-        purpose: "Retrieve AI entitlement information when PactFlow AI operations fail with 401 unauthorized errors. Use this to diagnose permission issues, check remaining credits, and verify account eligibility for AI features.",
-        useCases: [
-            "Diagnose 401 unauthorized errors when attempting to use PactFlow AI features",
-            "Check remaining AI credits when PactFlow AI operations are rejected due to insufficient credits",
-            "Verify account entitlements when users receive permission denied errors for PactFlow AI functionality",
-            "Troubleshoot PactFlow AI access issues by retrieving current entitlement status and credit balance",
-            "Provide detailed error context when PactFlow AI features are unavailable due to account limitations",
-        ],
-        handler: "checkAIEntitlements",
-        clients: ["pactflow"],
-    },
+const TOOLS = [
+  {
+    title: "Generate Pact Tests",
+    summary: "Generate Pact tests using PactFlow AI. You can provide one or more of the following input types: (1) request/response pairs for specific interactions, (2) code files to analyze and extract interactions from, and/or (3) OpenAPI document to generate tests for specific endpoints. When providing an OpenAPI document, a matcher is required to specify which endpoints to generate tests for.",
+    purpose: "Generate Pact tests for API interactions",
+    inputSchema: GenerationInputSchema,
+    handler: "generate",
+    clients: ["pactflow"],
+    // ONLY pactflow
+    enableElicitation: true,
+    tags: ["pactflow-ai"]
+  },
+  {
+    title: "Review Pact Tests",
+    summary: "Review Pact tests using PactFlow AI. You can provide the following inputs: (1) Pact tests to be reviewed along with metadata",
+    purpose: "Review Pact tests for API interactions",
+    inputSchema: RefineInputSchema,
+    handler: "review",
+    clients: ["pactflow"],
+    enableElicitation: true,
+    tags: ["pactflow-ai"]
+  },
+  {
+    title: "Get Provider States",
+    summary: "Retrieve the states of a specific provider",
+    purpose: "A provider state in Pact defines the specific preconditions that must be met on the provider side before a consumer-provider interaction can be tested. It sets up the provider in the right context—such as ensuring a particular user or record exists—so that the provider can return the response the consumer expects. This makes contract tests reliable, repeatable, and isolated by injecting or configuring the necessary data and conditions directly into the provider before each test runs.",
+    parameters: [
+      {
+        name: "provider",
+        type: z.string(),
+        description: "name of the provider to retrieve states for",
+        required: true
+      }
+    ],
+    handler: "getProviderStates",
+    clients: ["pactflow", "pact_broker"]
+  },
+  {
+    title: "Can I Deploy",
+    summary: "Performs a comprehensive compatibility check to determine whether a specific version of a service (pacticipant) can be safely deployed into a given environment. It analyzes the complete contract matrix of consumer-provider relationships to confirm that all required integrations are verified and compatible.",
+    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.",
+    inputSchema: CanIDeploySchema,
+    handler: "canIDeploy",
+    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."
+    ],
+    inputSchema: MatrixSchema,
+    handler: "getMatrix",
+    clients: ["pactflow", "pact_broker"]
+  },
+  {
+    title: "Check PactFlow AI Entitlements",
+    summary: "Check your PactFlow AI entitlements and credit balance if you encounter 401 Unauthorized errors or permission/credit issues when using PactFlow AI features.",
+    purpose: "Retrieve AI entitlement information when PactFlow AI operations fail with 401 unauthorized errors. Use this to diagnose permission issues, check remaining credits, and verify account eligibility for AI features.",
+    useCases: [
+      "Diagnose 401 unauthorized errors when attempting to use PactFlow AI features",
+      "Check remaining AI credits when PactFlow AI operations are rejected due to insufficient credits",
+      "Verify account entitlements when users receive permission denied errors for PactFlow AI functionality",
+      "Troubleshoot PactFlow AI access issues by retrieving current entitlement status and credit balance",
+      "Provide detailed error context when PactFlow AI features are unavailable due to account limitations"
+    ],
+    handler: "checkAIEntitlements",
+    clients: ["pactflow"]
+  },
+  {
+    title: "Get Metrics",
+    summary: "Fetch metrics across the entire workspace",
+    purpose: "Fetch metrics across the workspace. Use this to get an overview of contract testing usage, resource consumption and account-wide statistics.",
+    inputSchema: z.object({}),
+    handler: "getMetrics",
+    clients: ["pactflow", "pact_broker"]
+  },
+  {
+    title: "Get Team Metrics",
+    summary: "Fetch metrics for all teams",
+    purpose: "Fetch metrics for all teams within PactFlow. Use this to get an overview of team-specific contract testing usage, resource consumption and usage statistics.",
+    inputSchema: z.object({}),
+    handler: "getTeamMetrics",
+    clients: ["pactflow"]
+  }
 ];
+export {
+  TOOLS
+};