@smartbear/mcp 0.4.0 → 0.6.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

@@ -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 = {
@@ -96,10 +105,9 @@ export class SmartBearMcpServer extends McpServer {
         }
         if (zodSchema && zodSchema instanceof ZodObject) {
             description += "\n\n**Parameters:**\n";
-            for (const key of Object.keys(zodSchema.shape)) {
-                const field = zodSchema.shape[key];
-                description += this.formatParameterDescription(key, field);
-            }
+            description += Object.keys(zodSchema.shape)
+                .map(key => this.formatParameterDescription(key, zodSchema.shape[key]))
+                .join('\n');
         }
         if (outputFormat) {
             description += `\n\n**Output Format:** ${outputFormat}`;
@@ -119,7 +127,11 @@ export class SmartBearMcpServer extends McpServer {
         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  - ')}` : ''} \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)

package/dist/index.js

@@ -1,21 +1,21 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import Bugsnag from "./common/bugsnag.js";
-import { InsightHubClient } from "./insight-hub/client.js";
+import { BugsnagClient } from "./bugsnag/client.js";
 import { ReflectClient } from "./reflect/client.js";
 import { ApiHubClient } from "./api-hub/client.js";
 import { SmartBearMcpServer } from "./common/server.js";
 import { PactflowClient } from "./pactflow/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_INSIGHT_HUB_API_KEY environment variable
-const McpServerBugsnagAPIKey = process.env.MCP_SERVER_INSIGHT_HUB_API_KEY;
+// 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;
 if (McpServerBugsnagAPIKey) {
     Bugsnag.start(McpServerBugsnagAPIKey);
 }
 async function main() {
     const server = new SmartBearMcpServer();
     const reflectToken = process.env.REFLECT_API_TOKEN;
-    const insightHubToken = process.env.INSIGHT_HUB_AUTH_TOKEN;
+    const bugsnagToken = process.env.BUGSNAG_AUTH_TOKEN;
     const apiHubToken = process.env.API_HUB_API_KEY;
     const pactBrokerToken = process.env.PACT_BROKER_TOKEN;
     const pactBrokerUrl = process.env.PACT_BROKER_BASE_URL;
@@ -26,10 +26,10 @@ async function main() {
         server.addClient(new ReflectClient(reflectToken));
         client_defined = true;
     }
-    if (insightHubToken) {
-        const insightHubClient = new InsightHubClient(insightHubToken, process.env.INSIGHT_HUB_PROJECT_API_KEY, process.env.INSIGHT_HUB_ENDPOINT);
-        await insightHubClient.initialize();
-        server.addClient(insightHubClient);
+    if (bugsnagToken) {
+        const bugsnagClient = new BugsnagClient(bugsnagToken, process.env.BUGSNAG_PROJECT_API_KEY, process.env.BUGSNAG_ENDPOINT);
+        await bugsnagClient.initialize();
+        server.addClient(bugsnagClient);
         client_defined = true;
     }
     if (apiHubToken) {
@@ -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 {
@@ -50,7 +50,7 @@ async function main() {
         }
     }
     if (!client_defined) {
-        console.error("Please set one of REFLECT_API_TOKEN, INSIGHT_HUB_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 or PACT_BROKER_BASE_URL / (and relevant Pact auth) environment variables");
         process.exit(1);
     }
     const transport = new StdioServerTransport();

package/dist/pactflow/client/ai.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { addOpenAPISpecToSchema } from "./utils.js";
 // Type definitions for PactFlow AI API
 export const GenerationLanguages = [
     "javascript",
@@ -53,12 +54,11 @@ export const OpenAPISchema = z
         .describe("OpenAPI components section (schemas, responses, etc.)"),
 })
     .passthrough()
-    .describe("The complete OpenAPI document describing the API")
+    .describe("The complete OpenAPI document describing the API.")
     .refine((data) => data.openapi || data.swagger, {
     message: "Either 'openapi' (for v3+) or 'swagger' (for v2) must be provided",
     path: ["openapi"],
-})
-    .optional();
+});
 export const EndpointMatcherSchema = z
     .object({
     path: z
@@ -78,14 +78,34 @@ 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({
+    authToken: z
+        .string()
+        .describe("Auth Bearer Token if the OpenAPI spec requires authentication.")
+        .optional(),
+    authScheme: z
+        .string()
+        .describe("Authentication scheme (e.g., 'Bearer', 'Basic'). Default scheme passed should be Bearer if authToken is specified and this field is not set.")
+        .default("Bearer")
+        .optional(),
+    url: z
+        .string()
+        .url("Must be a valid openapi url")
+        .describe("URL of the remote OpenAPI document.")
+        .optional(),
+})
+    .describe("Use this schema to fetch openapi documents present over a url.");
 export const OpenAPIWithMatcherSchema = z
     .object({
-    document: OpenAPISchema,
+    document: OpenAPISchema.describe("The OpenAPI document describing the API being tested. if document is not provided, don't add the field if remoteOpenAPIDocument is provided.").optional(),
     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.");
+    .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
@@ -125,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 +1,19 @@
-export {};
+import { z } from "zod";
+export const CanIDeploySchema = z.object({
+    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,133 @@
+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: function ({ openAPI }) {
+            return {
+                messages: [
+                    {
+                        role: "user",
+                        content: {
+                            type: "text",
+                            text: OADMatcherPrompt.replace("{0}", openAPI),
+                        },
+                    },
+                ],
+            };
+        },
+    },
+];

package/dist/pactflow/client/tools.js

@@ -10,7 +10,8 @@
  * and registered with their corresponding handler.
  */
 import { z } from "zod";
-import { GenerationInputSchema, RefineInputSchema } from "./ai.js";
+import { GenerationInputSchema, RefineInputSchema, } from "./ai.js";
+import { CanIDeploySchema, MatrixSchema } from "./base.js";
 export const TOOLS = [
     {
         title: "Generate Pact Tests",
@@ -19,6 +20,7 @@ export const TOOLS = [
         zodSchema: GenerationInputSchema,
         handler: "generate",
         clients: ["pactflow"], // ONLY pactflow
+        enableElicitation: true,
     },
     {
         title: "Review Pact Tests",
@@ -26,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",
@@ -42,5 +45,43 @@ export const TOOLS = [
         ],
         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.",
+        zodSchema: 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."
+        ],
+        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

@@ -0,0 +1,70 @@
+import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
+import yaml from "js-yaml";
+// @ts-expect-error missing type declarations
+import Swagger from "swagger-client";
+/**
+ * Resolve the OpenAPI specification from the provided input.
+ *
+ * @param remoteOpenAPIDocument The remote OpenAPI document to resolve.
+ * @returns The resolved OpenAPI document.
+ * @throws Error if the resolution fails.
+ */
+export async function resolveOpenAPISpec(remoteOpenAPIDocument) {
+    const openAPISchema = RemoteOpenAPIDocumentSchema.safeParse(remoteOpenAPIDocument);
+    if (openAPISchema.error || !remoteOpenAPIDocument) {
+        throw new Error(`Invalid RemoteOpenAPIDocument: ${JSON.stringify(openAPISchema.error?.issues)}`);
+    }
+    const unresolvedSpec = await getRemoteSpecContents(openAPISchema.data);
+    const resolvedSpec = await Swagger.resolve({ spec: unresolvedSpec });
+    if (resolvedSpec.errors?.length) {
+        throw new Error(`Failed to resolve OpenAPI document: ${resolvedSpec.errors?.join(", ")}`);
+    }
+    return resolvedSpec.spec;
+}
+/**
+ * Fetch the contents of a remote OpenAPI document.
+ *
+ * @param openAPISchema The schema for the remote OpenAPI document.
+ * @returns A promise that resolves to a map of the OpenAPI document contents.
+ * @throws Error if the URL is not provided or the fetch fails.
+ */
+export async function getRemoteSpecContents(openAPISchema) {
+    if (!openAPISchema.url) {
+        throw new Error("'url' must be provided.");
+    }
+    let headers = {};
+    if (openAPISchema.authToken) {
+        headers = {
+            Authorization: `${openAPISchema.authScheme ?? "Bearer"} ${openAPISchema.authToken}`,
+        };
+    }
+    const remoteSpec = await fetch(openAPISchema.url, {
+        headers,
+        method: "GET",
+    });
+    const specRawBody = await remoteSpec.text();
+    try {
+        return JSON.parse(specRawBody);
+    }
+    catch (jsonError) {
+        try {
+            return yaml.load(specRawBody);
+        }
+        catch (yamlError) {
+            throw new Error(`Unsupported Content-Type: ${remoteSpec.headers.get("Content-Type")} for remote OpenAPI document. Found following parse errors:-\nJSON parse error: ${jsonError}\nYAML parse error: ${yamlError}`);
+        }
+    }
+}
+/**
+ * Adds the OpenAPI specification to the input schema if a remote document is provided.
+ *
+ * @param inputSchema The input schema to modify.
+ * @returns The modified input schema with the OpenAPI specification added.
+ */
+export async function addOpenAPISpecToSchema(inputSchema) {
+    if (inputSchema.remoteDocument) {
+        const resolvedSpec = await resolveOpenAPISpec(inputSchema.remoteDocument);
+        inputSchema.document = resolvedSpec;
+    }
+    return inputSchema;
+}