@smartbear/mcp 0.8.0 → 0.10.0

package/dist/collaborator/client.js

@@ -0,0 +1,364 @@
+import { z } from "zod";
+export class CollaboratorClient {
+    name = "Collaborator";
+    prefix = "collaborator";
+    baseUrl;
+    username;
+    loginTicket;
+    constructor(baseUrl, username, loginTicket) {
+        this.baseUrl = baseUrl;
+        this.username = username;
+        this.loginTicket = loginTicket;
+    }
+    /**
+     * Calls the Collaborator API with the given commands, prepending authentication automatically.
+     * @param commands Array of Collaborator API commands (excluding authentication)
+     * @returns Raw Collaborator API response
+     */
+    async call(commands) {
+        const url = `${this.baseUrl}/services/json/v1`;
+        // Always prepend authentication command automatically
+        const body = [
+            {
+                command: "SessionService.authenticate",
+                args: { login: this.username, ticket: this.loginTicket },
+            },
+            ...commands,
+        ];
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Collaborator API call failed: ${response.status} - ${await response.text()}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Registers the Collaborator API tool with the MCP server. Accepts commands (excluding authentication).
+     */
+    registerTools(register, _getInput) {
+        // findReviewById tool
+        register({
+            title: "Find Collaborator Review By ID",
+            summary: "Finds a review in Collaborator by its review ID.",
+            inputSchema: z.object({
+                reviewId: z.string().describe("The Collaborator review ID to find."),
+            }),
+        }, async (args, _extra) => {
+            const { reviewId } = args;
+            const commands = [
+                {
+                    command: "ReviewService.findReviewById",
+                    args: { reviewId },
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // createReview tool
+        register({
+            title: "Create Collaborator Review",
+            summary: "Creates a new review in Collaborator. All parameters are optional.",
+            inputSchema: z.object({
+                creator: z
+                    .string()
+                    .optional()
+                    .describe("Collaborator username of the review creator. Optional. Default: currently logged in user."),
+                title: z
+                    .string()
+                    .optional()
+                    .describe("Title of the review. Optional. Default: null."),
+                templateName: z
+                    .string()
+                    .optional()
+                    .describe("Review template name. Optional. Default: system default template."),
+                accessPolicy: z
+                    .string()
+                    .optional()
+                    .describe("Access policy for the review. Optional. Default: ANYONE."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.creator !== undefined)
+                commandArgs.creator = args.creator;
+            if (args.title !== undefined)
+                commandArgs.title = args.title;
+            if (args.templateName !== undefined)
+                commandArgs.templateName = args.templateName;
+            if (args.accessPolicy !== undefined)
+                commandArgs.accessPolicy = args.accessPolicy;
+            const commands = [
+                {
+                    command: "ReviewService.createReview",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // rejectReview tool
+        register({
+            title: "Reject Collaborator Review",
+            summary: "Rejects a review in Collaborator by its review ID and reason.",
+            inputSchema: z.object({
+                reviewId: z
+                    .union([z.string(), z.number()])
+                    .describe("The Collaborator review ID to reject."),
+                reason: z.string().describe("Reason for rejecting the review."),
+            }),
+        }, async (args, _extra) => {
+            const { reviewId, reason } = args;
+            const commands = [
+                {
+                    command: "ReviewService.reject",
+                    args: {
+                        reviewId,
+                        reason,
+                    },
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        register({
+            title: "ReviewService Action",
+            summary: "Invoke any ReviewService method by name and arguments. For finishReviewPhase and waitOnPhase, provide reviewId (required) and until (optional, defaults to 'ANY').",
+            inputSchema: z.object({
+                action: z.enum([
+                    "moveReviewToAnnotatePhase",
+                    "cancel",
+                    "reopen",
+                    "uncancel",
+                ]),
+                args: z.record(z.any()),
+            }),
+        }, async (params, _extra) => {
+            const { action, args } = params;
+            const commands = [{ command: `ReviewService.${action}`, args }];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // getReviews tool
+        register({
+            title: "Get Collaborator Reviews",
+            summary: "Retrieves reviews from Collaborator using ReviewService.getReviews. All parameters are optional and only provided ones are sent.",
+            inputSchema: z.object({
+                login: z
+                    .string()
+                    .optional()
+                    .describe("Collaborator username to filter reviews."),
+                role: z
+                    .string()
+                    .optional()
+                    .describe("Role to filter reviews (e.g., AUTHOR)."),
+                creator: z
+                    .boolean()
+                    .optional()
+                    .describe("Whether to filter by creator."),
+                reviewPhase: z
+                    .string()
+                    .optional()
+                    .describe("Review phase to filter (e.g., PLANNING)."),
+                fullInfo: z
+                    .boolean()
+                    .optional()
+                    .describe("Whether to retrieve full review info."),
+                fromDate: z
+                    .string()
+                    .optional()
+                    .describe('Minimal creation date in format "yyyy-MM-dd"'),
+                toDate: z
+                    .string()
+                    .optional()
+                    .describe('Maximal creation date in format "yyyy-MM-dd"'),
+            }),
+        }, async (args, _extra) => {
+            const reviewArgs = {};
+            if (args.login !== undefined)
+                reviewArgs.login = args.login;
+            if (args.role !== undefined)
+                reviewArgs.role = args.role;
+            if (args.creator !== undefined)
+                reviewArgs.creator = args.creator;
+            if (args.reviewPhase !== undefined)
+                reviewArgs.reviewPhase = args.reviewPhase;
+            if (args.fullInfo !== undefined)
+                reviewArgs.fullInfo = args.fullInfo;
+            if (args.fromDate !== undefined)
+                reviewArgs.fromDate = args.fromDate;
+            if (args.toDate !== undefined)
+                reviewArgs.toDate = args.toDate;
+            const commands = [
+                {
+                    command: "ReviewService.getReviews",
+                    args: reviewArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // createIntegration tool
+        register({
+            title: "Create Collaborator Remote System Configuration",
+            summary: "Creates a remote system configuration in Collaborator (e.g., Bitbucket, GitHub, etc).",
+            inputSchema: z.object({
+                token: z
+                    .string()
+                    .describe("Remote system token, e.g., BITBUCKET, GITHUB, etc."),
+                title: z.string().describe("Remote system title."),
+                config: z
+                    .string()
+                    .describe("JSON string containing configuration parameters for the remote system."),
+                reviewTemplateId: z
+                    .string()
+                    .optional()
+                    .describe("Optional review template ID used by this remote system."),
+            }),
+        }, async (args, _extra) => {
+            const { token, title, config, reviewTemplateId } = args;
+            const commandArgs = { token, title, config };
+            if (reviewTemplateId)
+                commandArgs.reviewTemplateId = reviewTemplateId;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.createIntegration",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // editIntegration tool
+        register({
+            title: "Edit Collaborator Remote System Configuration",
+            summary: "Edits parameters of an existing remote system configuration in Collaborator. Only title and config are editable after creation.",
+            inputSchema: z.object({
+                id: z
+                    .string()
+                    .describe("ID of the remote system Configuration to edit."),
+                title: z.string().optional().describe("Remote system title."),
+                config: z
+                    .string()
+                    .optional()
+                    .describe("JSON string containing configuration parameters for the remote system."),
+                reviewTemplateId: z
+                    .string()
+                    .optional()
+                    .describe("Optional review template ID used by this remote system."),
+            }),
+        }, async (args, _extra) => {
+            const { id, title, config, reviewTemplateId } = args;
+            const commandArgs = { id };
+            if (title)
+                commandArgs.title = title;
+            if (config)
+                commandArgs.config = config;
+            if (reviewTemplateId)
+                commandArgs.reviewTemplateId = reviewTemplateId;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.editIntegration",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // deleteIntegration tool
+        register({
+            title: "Delete Collaborator Remote System Configuration",
+            summary: "Deletes a remote system configuration in Collaborator by its ID.",
+            inputSchema: z.object({
+                id: z
+                    .union([z.string(), z.number()])
+                    .describe("ID of the remote system Configuration to delete."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.id !== undefined)
+                commandArgs.id =
+                    typeof args.id === "string" && !Number.isNaN(Number(args.id))
+                        ? Number(args.id)
+                        : args.id;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.deleteIntegration",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        register({
+            title: "Update Collaborator Remote System Configuration Webhook",
+            summary: "Updates the webhook for a remote system configuration in Collaborator by its ID.",
+            inputSchema: z.object({
+                id: z
+                    .union([z.string(), z.number()])
+                    .describe("ID of the remote system Configuration to update the webhook for."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.id !== undefined)
+                commandArgs.id =
+                    typeof args.id === "string" && !Number.isNaN(Number(args.id))
+                        ? Number(args.id)
+                        : args.id;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.updateWebhook",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // Test connection tool
+        register({
+            title: "Test Collaborator Remote System Configuration Connection",
+            summary: "Tests the connection for a remote system configuration in Collaborator by its ID.",
+            inputSchema: z.object({
+                id: z
+                    .union([z.string(), z.number()])
+                    .describe("ID of the remote system Configuration to test connection for."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.id !== undefined)
+                commandArgs.id =
+                    typeof args.id === "string" && !Number.isNaN(Number(args.id))
+                        ? Number(args.id)
+                        : args.id;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.testConnection",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+    }
+}

package/dist/common/server.js

@@ -1,7 +1,8 @@
 import { McpServer, ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ZodAny, ZodArray, ZodBoolean, ZodEnum, ZodLiteral, ZodNumber, ZodObject, ZodOptional, ZodString, ZodUnion, } from "zod";
+import { ZodAny, ZodArray, ZodBoolean, ZodEnum, ZodIntersection, ZodLiteral, ZodNumber, ZodObject, ZodOptional, ZodString, ZodUnion, } from "zod";
 import Bugsnag from "../common/bugsnag.js";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./info.js";
+import { ToolError } from "./types.js";
 export class SmartBearMcpServer extends McpServer {
     constructor() {
         super({
@@ -26,13 +27,36 @@ export class SmartBearMcpServer extends McpServer {
                 title: toolTitle,
                 description: this.getDescription(params),
                 inputSchema: this.getInputSchema(params),
+                outputSchema: this.getOutputSchema(params),
                 annotations: this.getAnnotations(toolTitle, params),
             }, async (args, extra) => {
                 try {
-                    return await cb(args, extra);
+                    const result = await cb(args, extra);
+                    if (result) {
+                        this.validateCallbackResult(result, params);
+                        this.addStructuredContentAsText(result);
+                    }
+                    return result;
                 }
                 catch (e) {
-                    Bugsnag.notify(e);
+                    // ToolErrors should not be reported to BugSnag
+                    if (e instanceof ToolError) {
+                        return {
+                            isError: true,
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Error executing ${toolTitle}: ${e.message}`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        Bugsnag.notify(e, (event) => {
+                            event.addMetadata("app", { tool: toolName });
+                            event.unhandled = true;
+                        });
+                    }
                     throw e;
                 }
             });
@@ -41,14 +65,18 @@ export class SmartBearMcpServer extends McpServer {
         });
         if (client.registerResources) {
             client.registerResources((name, path, cb) => {
-                return super.registerResource(name, new ResourceTemplate(`${client.prefix}://${name}/${path}`, {
+                const url = `${client.prefix}://${name}/${path}`;
+                return super.registerResource(name, new ResourceTemplate(url, {
                     list: undefined,
                 }), {}, async (url, variables, extra) => {
                     try {
                         return await cb(url, variables, extra);
                     }
                     catch (e) {
-                        Bugsnag.notify(e);
+                        Bugsnag.notify(e, (event) => {
+                            event.addMetadata("app", { resource: name, url: url });
+                            event.unhandled = true;
+                        });
                         throw e;
                     }
                 });
@@ -60,6 +88,24 @@ export class SmartBearMcpServer extends McpServer {
             });
         }
     }
+    validateCallbackResult(result, params) {
+        if (result.isError) {
+            return;
+        }
+        if (params.outputSchema && !result.structuredContent) {
+            throw new Error(`The result of the tool '${params.title}' must include 'structuredContent'`);
+        }
+    }
+    addStructuredContentAsText(result) {
+        if (result.structuredContent && !result.content?.length) {
+            result.content = [
+                {
+                    type: "text",
+                    text: JSON.stringify(result.structuredContent),
+                },
+            ];
+        }
+    }
     getAnnotations(toolTitle, params) {
         const annotations = {
             title: toolTitle,
@@ -81,24 +127,28 @@ export class SmartBearMcpServer extends McpServer {
                 args[param.name] = args[param.name].optional();
             }
         }
-        if (params.zodSchema && params.zodSchema instanceof ZodObject) {
-            for (const key of Object.keys(params.zodSchema.shape)) {
-                const field = params.zodSchema.shape[key];
-                args[key] = field;
-                if (field.description) {
-                    args[key] = args[key].describe(field.description);
-                }
-                if (field.isOptional()) {
-                    args[key] = args[key].optional();
-                }
+        return { ...args, ...this.schemaToRawShape(params.inputSchema) };
+    }
+    schemaToRawShape(schema) {
+        if (schema) {
+            if (schema instanceof ZodObject) {
+                return schema.shape;
+            }
+            if (schema instanceof ZodIntersection) {
+                const leftShape = this.schemaToRawShape(schema._def.left);
+                const rightShape = this.schemaToRawShape(schema._def.right);
+                return { ...leftShape, ...rightShape };
             }
         }
-        return args;
+        return undefined;
+    }
+    getOutputSchema(params) {
+        return this.schemaToRawShape(params.outputSchema);
     }
     getDescription(params) {
-        const { summary, useCases, examples, parameters, zodSchema, hints, outputFormat, } = params;
+        const { summary, useCases, examples, parameters, inputSchema, hints, outputDescription, } = params;
         let description = summary;
-        // Parameters if available otherwise use zodSchema
+        // Parameters if available otherwise use inputSchema
         if ((parameters ?? []).length > 0) {
             description += `\n\n**Parameters:**\n${parameters
                 ?.map((p) => `- ${p.name} (${this.getReadableTypeName(p.type)})${p.required ? " *required*" : ""}` +
@@ -107,14 +157,14 @@ export class SmartBearMcpServer extends McpServer {
                 `${p.constraints ? `\n  - ${p.constraints.join("\n  - ")}` : ""}`)
                 .join("\n")}`;
         }
-        if (zodSchema && zodSchema instanceof ZodObject) {
+        if (inputSchema && inputSchema instanceof ZodObject) {
             description += "\n\n**Parameters:**\n";
-            description += Object.keys(zodSchema.shape)
-                .map((key) => this.formatParameterDescription(key, zodSchema.shape[key]))
+            description += Object.keys(inputSchema.shape)
+                .map((key) => this.formatParameterDescription(key, inputSchema.shape[key]))
                 .join("\n");
         }
-        if (outputFormat) {
-            description += `\n\n**Output Format:** ${outputFormat}`;
+        if (outputDescription) {
+            description += `\n\n**Output Description:** ${outputDescription}`;
         }
         // Use Cases
         if (useCases && useCases.length > 0) {

package/dist/common/types.js

@@ -1 +1,6 @@
-export {};
+/**
+ * Error class for tool-specific errors – these result in a response to the LLM with `isError: true`
+ * and are not reported to BugSnag
+ */
+export class ToolError extends Error {
+}

package/dist/index.js

@@ -2,6 +2,7 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ApiHubClient } from "./api-hub/client.js";
 import { BugsnagClient } from "./bugsnag/client.js";
+import { CollaboratorClient } from "./collaborator/client.js";
 import Bugsnag from "./common/bugsnag.js";
 import { SmartBearMcpServer } from "./common/server.js";
 import { PactflowClient } from "./pactflow/client.js";
@@ -27,6 +28,9 @@ async function main() {
     const qmetryBaseUrl = process.env.QMETRY_BASE_URL;
     const zephyrToken = process.env.ZEPHYR_API_TOKEN;
     const zephyrBaseUrl = process.env.ZEPHYR_BASE_URL;
+    const collaboratorBaseUrl = process.env.COLLAB_BASE_URL;
+    const collaboratorUsername = process.env.COLLAB_USERNAME;
+    const collaboratorLoginTicket = process.env.COLLAB_LOGIN_TICKET;
     let client_defined = false;
     if (reflectToken) {
         server.addClient(new ReflectClient(reflectToken));
@@ -63,8 +67,12 @@ async function main() {
         server.addClient(new ZephyrClient(zephyrToken, zephyrBaseUrl));
         client_defined = true;
     }
+    if (collaboratorBaseUrl && collaboratorUsername && collaboratorLoginTicket) {
+        server.addClient(new CollaboratorClient(collaboratorBaseUrl, collaboratorUsername, collaboratorLoginTicket));
+        client_defined = true;
+    }
     if (!client_defined) {
-        console.error("Please set one of REFLECT_API_TOKEN, BUGSNAG_AUTH_TOKEN, API_HUB_API_KEY, QMETRY_API_KEY, ZEPHYR_API_TOKEN, or PACT_BROKER_BASE_URL / (and relevant Pact auth) environment variables");
+        console.error("No SmartBear products were configured. Please provide at least one of the required configuration options.");
         process.exit(1);
     }
     const transport = new StdioServerTransport();

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

@@ -1,3 +1,4 @@
+import { ToolError } from "../../common/types.js";
 import { EndpointMatcherSchema, MatcherRecommendationInputSchema, } from "./ai.js";
 import { OADMatcherPrompt } from "./prompts.js";
 /**
@@ -30,7 +31,7 @@ export async function getOADMatcherRecommendations(openAPI, server) {
         return matcherRecommendations;
     }
     else {
-        throw new Error("Unable to parse recommendations please provide OpenAPI matchers manually.");
+        throw new ToolError("Unable to parse recommendations please provide OpenAPI matchers manually.");
     }
 }
 /**

package/dist/pactflow/client/tools.js

@@ -17,7 +17,7 @@ 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",
-        zodSchema: GenerationInputSchema,
+        inputSchema: GenerationInputSchema,
         handler: "generate",
         clients: ["pactflow"], // ONLY pactflow
         enableElicitation: true,
@@ -26,7 +26,7 @@ export const TOOLS = [
         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",
-        zodSchema: RefineInputSchema,
+        inputSchema: RefineInputSchema,
         handler: "review",
         clients: ["pactflow"],
         enableElicitation: true,
@@ -50,7 +50,7 @@ export const TOOLS = [
         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,
+        inputSchema: CanIDeploySchema,
         handler: "canIDeploy",
         clients: ["pactflow", "pact_broker"],
     },
@@ -66,7 +66,7 @@ export const TOOLS = [
             "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,
+        inputSchema: MatrixSchema,
         handler: "getMatrix",
         clients: ["pactflow", "pact_broker"],
     },

package/dist/pactflow/client/utils.js

@@ -1,6 +1,7 @@
 import yaml from "js-yaml";
 // @ts-expect-error missing type declarations
 import Swagger from "swagger-client";
+import { ToolError } from "../../common/types.js";
 import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
 /**
  * Resolve the OpenAPI specification from the provided input.
@@ -12,12 +13,12 @@ import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
 export async function resolveOpenAPISpec(remoteOpenAPIDocument) {
     const openAPISchema = RemoteOpenAPIDocumentSchema.safeParse(remoteOpenAPIDocument);
     if (openAPISchema.error || !remoteOpenAPIDocument) {
-        throw new Error(`Invalid RemoteOpenAPIDocument: ${JSON.stringify(openAPISchema.error?.issues)}`);
+        throw new ToolError(`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(", ")}`);
+        throw new ToolError(`Failed to resolve OpenAPI document: ${resolvedSpec.errors?.join(", ")}`);
     }
     return resolvedSpec.spec;
 }
@@ -30,7 +31,7 @@ export async function resolveOpenAPISpec(remoteOpenAPIDocument) {
  */
 export async function getRemoteSpecContents(openAPISchema) {
     if (!openAPISchema.url) {
-        throw new Error("'url' must be provided.");
+        throw new ToolError("'url' must be provided.");
     }
     let headers = {};
     if (openAPISchema.authToken) {
@@ -51,7 +52,7 @@ export async function getRemoteSpecContents(openAPISchema) {
             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}`);
+            throw new ToolError(`Unsupported Content-Type: ${remoteSpec.headers.get("Content-Type")} for remote OpenAPI document. Found following parse errors:-\nJSON parse error: ${jsonError}\nYAML parse error: ${yamlError}`);
         }
     }
 }