@smartbear/mcp 0.22.0 → 0.23.0

package/README.md

@@ -18,7 +18,7 @@
 </div>
 <br />
 
-A Model Context Protocol (MCP) server which provides AI assistants with seamless access to SmartBear's suite of testing and monitoring tools, including [BugSnag](https://www.bugsnag.com/), [Reflect](https://reflect.run), [Swagger](https://www.smartbear.com/api-hub), [PactFlow](https://pactflow.io/), [Pact Broker](https://docs.pact.io/), [QMetry](https://www.qmetry.com/), [QTM4J](https://www.qmetry.com/qmetry-test-management-for-jira), [Zephyr](https://smartbear.com/test-management/zephyr/) and [Collaborator](https://smartbear.com/product/collaborator/).
+A Model Context Protocol (MCP) server which provides AI assistants with seamless access to SmartBear's suite of testing and monitoring tools, including [BearQ](https://developer.smartbear.com/smartbear-mcp/docs/bearq-integration), [BugSnag](https://www.bugsnag.com/), [Reflect](https://reflect.run), [Swagger](https://www.smartbear.com/api-hub), [PactFlow](https://pactflow.io/), [Pact Broker](https://docs.pact.io/), [QMetry](https://www.qmetry.com/), [QTM4J](https://www.qmetry.com/qmetry-test-management-for-jira), [Zephyr](https://smartbear.com/test-management/zephyr/) and [Collaborator](https://smartbear.com/product/collaborator/).
 
 ## What is MCP?
 
@@ -28,6 +28,7 @@ The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction)
 
 See individual guides for suggested prompts and supported tools and resources:
 
+- [BearQ](https://developer.smartbear.com/smartbear-mcp/docs/bearq-integration) - AI-powered QA test management and execution capabilities
 - [BugSnag](https://developer.smartbear.com/smartbear-mcp/docs/bugsnag-integration) - Comprehensive error monitoring and debugging capabilities
 - [Reflect](https://developer.smartbear.com/smartbear-mcp/docs/reflect-integration) - Test management and execution capabilities
 - **Swagger**
@@ -51,7 +52,7 @@ For BugSnag, Swagger, and Zephyr, SmartBear hosts Remote MCP Servers that you ca
 
 See the [Remote MCP Servers guide](https://developer.smartbear.com/smartbear-mcp/docs/remote-mcp-servers) for per-client setup instructions. You can connect to multiple remote servers at the same time.
 
-> **Need Reflect, QMetry, QTM4J, PactFlow, or Collaborator?** These products are only available via the local npm package below, which bundles all products into a single MCP server.
+> **Need BearQ, Reflect, QMetry, QTM4J, PactFlow, or Collaborator?** These products are only available via the local npm package below, which bundles all products into a single MCP server.
 
 ## Prerequisites
 
@@ -85,6 +86,8 @@ Alternatively, you can use `npx` (or globally install) the `@smartbear/mcp` pack
         "@smartbear/mcp@latest"
       ],
       "env": {
+        "BEARQ_API_TOKEN": "${input:bearq_api_token}",
+        "BEARQ_API_BASE_URL": "${input:bearq_api_base_url}",
         "BUGSNAG_AUTH_TOKEN": "${input:bugsnag_auth_token}",
         "BUGSNAG_PROJECT_API_KEY": "${input:bugsnag_project_api_key}",
         "REFLECT_API_TOKEN": "${input:reflect_api_token}",
@@ -109,6 +112,18 @@ Alternatively, you can use `npx` (or globally install) the `@smartbear/mcp` pack
     }
   },
   "inputs": [
+      {
+         "id": "bearq_api_token",
+         "type": "promptString",
+         "description": "BearQ workspace API token - leave blank to disable BearQ tools",
+         "password": true
+      },
+      {
+         "id": "bearq_api_base_url",
+         "type": "promptString",
+         "description": "BearQ API base URL - leave blank to use the default (https://api.bearq.smartbear.com)",
+         "password": false
+      },
       {
          "id": "bugsnag_auth_token",
          "type": "promptString",
@@ -248,6 +263,7 @@ Add the following configuration to your `claude_desktop_config.json` to launch t
         "@smartbear/mcp@latest"
       ],
       "env": {
+        "BEARQ_API_TOKEN": "your_bearq_api_token",
         "BUGSNAG_AUTH_TOKEN": "your_personal_auth_token",
         "BUGSNAG_PROJECT_API_KEY": "your_project_api_key",
         "REFLECT_API_TOKEN": "your_reflect_token",

package/dist/bearq/client.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
+import { getRequestHeader } from "../common/request-context.js";
+import { ToolError } from "../common/tools.js";
+import { DEFAULT_API_BASE_URL, AUTHORIZATION_HEADER } from "./config/constants.js";
+import { ChatWithQaLead } from "./tool/tasks/chat-with-qa-lead.js";
+import { ExpandApplicationModel } from "./tool/tasks/expand-application-model.js";
+import { GetTask } from "./tool/tasks/get-task.js";
+import { GetTaskStatus } from "./tool/tasks/get-task-status.js";
+import { RefineAllDraftTests } from "./tool/tasks/refine-all-draft-tests.js";
+import { RefineTestCases } from "./tool/tasks/refine-test-cases.js";
+import { RefineTestsInFunctionalAreas } from "./tool/tasks/refine-tests-in-functional-areas.js";
+import { RunRegressionTests } from "./tool/tasks/run-regression-tests.js";
+import { RunTestCases } from "./tool/tasks/run-test-cases.js";
+import { RunTestsInFunctionalAreas } from "./tool/tasks/run-tests-in-functional-areas.js";
+import { StopTask } from "./tool/tasks/stop-task.js";
+import { WaitForTask } from "./tool/tasks/wait-for-task.js";
+const ConfigurationSchema = z.object({
+  api_token: z.string().describe("BearQ workspace API token (Bearer)."),
+  api_base_url: z.string().optional().describe(
+    "Override the BearQ public API base URL. Defaults to https://api.bearq.smartbear.com"
+  )
+});
+class BearQClient {
+  _apiToken;
+  _baseUrl = DEFAULT_API_BASE_URL;
+  name = "BearQ";
+  capabilityPrefix = "bearq";
+  configPrefix = "BearQ";
+  config = ConfigurationSchema;
+  async configure(_server, config) {
+    this._apiToken = config.api_token;
+    if (config.api_base_url) this._baseUrl = config.api_base_url;
+  }
+  getAuthToken() {
+    const contextHeader = getRequestHeader(AUTHORIZATION_HEADER);
+    if (contextHeader) {
+      let token = Array.isArray(contextHeader) ? contextHeader[0] : contextHeader;
+      if (token.startsWith("Bearer ")) token = token.substring(7);
+      return token;
+    }
+    return this._apiToken ?? null;
+  }
+  isConfigured() {
+    return true;
+  }
+  getBaseUrl() {
+    return this._baseUrl;
+  }
+  getHeaders() {
+    const token = this.getAuthToken();
+    if (!token) throw new ToolError("BearQ API token not found");
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`
+    };
+  }
+  async registerTools(register, _getInput) {
+    const tools = [
+      new RunRegressionTests(this),
+      new RunTestCases(this),
+      new RunTestsInFunctionalAreas(this),
+      new RefineTestCases(this),
+      new RefineTestsInFunctionalAreas(this),
+      new RefineAllDraftTests(this),
+      new ExpandApplicationModel(this),
+      new ChatWithQaLead(this),
+      new GetTask(this),
+      new GetTaskStatus(this),
+      new StopTask(this),
+      new WaitForTask(this)
+    ];
+    for (const tool of tools) {
+      register(tool.specification, tool.handle);
+    }
+  }
+}
+export {
+  BearQClient
+};

package/dist/bearq/config/constants.js

@@ -0,0 +1,6 @@
+const DEFAULT_API_BASE_URL = "https://api.bearq.smartbear.com";
+const AUTHORIZATION_HEADER = "authorization";
+export {
+  AUTHORIZATION_HEADER,
+  DEFAULT_API_BASE_URL
+};

package/dist/bearq/tool/tasks/chat-with-qa-lead.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  instruction: z.string().min(1).describe(
+    "Natural language instruction to send to the BearQ QA lead agent."
+  )
+});
+class ChatWithQaLead extends Tool {
+  specification = {
+    title: "Chat with QA Lead",
+    summary: "Sends an open-ended instruction to BearQ's QA lead agent. Use this when no other BearQ tool fits — the QA lead can list, create, and update test cases, manage functional areas, and read the application model, and acts as a general-purpose escape hatch.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { instruction } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({ agent: "qa-lead", instruction })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  ChatWithQaLead
+};

package/dist/bearq/tool/tasks/expand-application-model.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  functionalArea: z.union([z.number().int().positive(), z.string().min(1)]).optional().describe(
+    "Functional area to scope the exploration to, by ID or name. Omit to explore the entire application."
+  )
+});
+class ExpandApplicationModel extends Tool {
+  specification = {
+    title: "Expand Application Model",
+    summary: "Explores the live application to discover or update its pages and elements in BearQ's application model. Optionally scope to a single functional area.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { functionalArea } = inputSchema.parse(args);
+    const body = { agent: "explorer" };
+    if (functionalArea !== void 0) body.functionalArea = functionalArea;
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  ExpandApplicationModel
+};

package/dist/bearq/tool/tasks/get-task-status.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  taskId: z.number().int().positive().describe("BearQ task ID.")
+});
+class GetTaskStatus extends Tool {
+  specification = {
+    title: "Get Task Status",
+    summary: "Retrieves the status of a task (running / complete / error / cancelled). Cheaper than fetching full task details.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { taskId } = inputSchema.parse(args);
+    const res = await fetch(
+      `${this.client.getBaseUrl()}/tasks/${taskId}/status`,
+      {
+        method: "GET",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!res.ok)
+      throw new ToolError(
+        `GET /tasks/${taskId}/status failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  GetTaskStatus
+};

package/dist/bearq/tool/tasks/get-task.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  taskId: z.number().int().positive().describe("BearQ task ID.")
+});
+class GetTask extends Tool {
+  specification = {
+    title: "Get Task",
+    summary: "Retrieves a task's current state, metadata, and activity log. Returns immediately with whatever's available — does not block on the task completing.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { taskId } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks/${taskId}`, {
+      method: "GET",
+      headers: this.client.getHeaders()
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `GET /tasks/${taskId} failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  GetTask
+};

package/dist/bearq/tool/tasks/refine-all-draft-tests.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({});
+class RefineAllDraftTests extends Tool {
+  specification = {
+    title: "Refine All Draft Tests",
+    summary: "Refines every draft test case in the workspace. Use to push an entire draft backlog forward; may take multiple passes before all drafts are ready to be promoted to regression tests.",
+    inputSchema
+  };
+  handle = async (_args) => {
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({ agent: "tester", mode: "refine" })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  RefineAllDraftTests
+};

package/dist/bearq/tool/tasks/refine-test-cases.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  testCaseIds: z.array(z.number().int().positive()).min(1).describe("IDs of BearQ draft test cases to refine.")
+});
+class RefineTestCases extends Tool {
+  specification = {
+    title: "Refine Test Cases",
+    summary: "Refines specific BearQ draft test cases — improves their steps so they can eventually be promoted to regression tests. Use when a draft is incomplete or has drifted from its intent.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { testCaseIds } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({ agent: "tester", mode: "refine", testCaseIds })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  RefineTestCases
+};

package/dist/bearq/tool/tasks/refine-tests-in-functional-areas.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  functionalAreas: z.array(z.union([z.number().int().positive(), z.string().min(1)])).min(1).describe("Functional areas to target, by ID or name.")
+});
+class RefineTestsInFunctionalAreas extends Tool {
+  specification = {
+    title: "Refine Tests in Functional Areas",
+    summary: "Refines every draft test case tagged with one or more functional areas. Functional areas can be given by ID or name. May take multiple passes before drafts are ready to be promoted to regression tests.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { functionalAreas } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({
+        agent: "tester",
+        mode: "refine",
+        functionalAreas
+      })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  RefineTestsInFunctionalAreas
+};

package/dist/bearq/tool/tasks/run-regression-tests.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({});
+class RunRegressionTests extends Tool {
+  specification = {
+    title: "Run Regression Tests",
+    summary: "Runs the full BearQ regression suite — every regression-ready test case in the workspace. Use for CI/CD or pre-release smoke.",
+    inputSchema
+  };
+  handle = async (_args) => {
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({ agent: "tester", mode: "run" })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  RunRegressionTests
+};

package/dist/bearq/tool/tasks/run-test-cases.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  testCaseIds: z.array(z.number().int().positive()).min(1).describe("IDs of BearQ regression test cases to run.")
+});
+class RunTestCases extends Tool {
+  specification = {
+    title: "Run Test Cases",
+    summary: "Runs specific BearQ regression test cases by ID. Targets only regression-ready cases — drafts will be rejected.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { testCaseIds } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({ agent: "tester", mode: "run", testCaseIds })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  RunTestCases
+};

package/dist/bearq/tool/tasks/run-tests-in-functional-areas.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  functionalAreas: z.array(z.union([z.number().int().positive(), z.string().min(1)])).min(1).describe("Functional areas to target, by ID or name.")
+});
+class RunTestsInFunctionalAreas extends Tool {
+  specification = {
+    title: "Run Tests in Functional Areas",
+    summary: "Runs every regression test case tagged with one or more functional areas. Functional areas can be given by ID or name.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { functionalAreas } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
+      method: "POST",
+      headers: this.client.getHeaders(),
+      body: JSON.stringify({ agent: "tester", mode: "run", functionalAreas })
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `POST /tasks failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  RunTestsInFunctionalAreas
+};

package/dist/bearq/tool/tasks/stop-task.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  taskId: z.number().int().positive().describe("BearQ task ID to cancel.")
+});
+class StopTask extends Tool {
+  specification = {
+    title: "Stop Task",
+    summary: "Cancels a running task.",
+    inputSchema
+  };
+  handle = async (args) => {
+    const { taskId } = inputSchema.parse(args);
+    const res = await fetch(`${this.client.getBaseUrl()}/tasks/${taskId}`, {
+      method: "DELETE",
+      headers: this.client.getHeaders()
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `DELETE /tasks/${taskId} failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  StopTask
+};

package/dist/bearq/tool/tasks/wait-for-task.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({
+  taskId: z.number().int().positive().describe("BearQ task ID.")
+});
+function parseFrame(frame) {
+  let event = "";
+  let data = "";
+  for (const line of frame.split("\n")) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) data = line.slice(5).trim();
+  }
+  if (!event || !data) return null;
+  return { event, data };
+}
+class WaitForTask extends Tool {
+  specification = {
+    title: "Wait For Task",
+    summary: "Blocks until a BearQ task reaches a terminal state (completed / failed / cancelled) or the stream times out, then returns the full ordered sequence of SSE events from the public API (metadata, activityLogEntries, and a terminal done or timeout event) verbatim. Blocks for the lifetime of the task — for a quick check use bearq_get_task_status instead.",
+    inputSchema
+  };
+  handle = async (args, extra) => {
+    const { taskId } = inputSchema.parse(args);
+    const url = `${this.client.getBaseUrl()}/tasks/${taskId}/stream`;
+    const res = await fetch(url, {
+      headers: { ...this.client.getHeaders(), Accept: "text/event-stream" }
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `GET /tasks/${taskId}/stream failed: ${res.status} ${res.statusText}`
+      );
+    if (!res.body)
+      throw new ToolError(`GET /tasks/${taskId}/stream: no response body`);
+    const progressToken = extra?._meta?.progressToken;
+    let progress = 0;
+    const notify = async (event, data) => {
+      if (progressToken === void 0) return;
+      await extra.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress: ++progress,
+          message: JSON.stringify({ event, data })
+        }
+      });
+    };
+    const events = [];
+    const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += value;
+        let boundary = buffer.indexOf("\n\n");
+        while (boundary !== -1) {
+          const frame = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          boundary = buffer.indexOf("\n\n");
+          const parsed = parseFrame(frame);
+          if (!parsed) continue;
+          const data = JSON.parse(parsed.data);
+          events.push({ event: parsed.event, data });
+          await notify(parsed.event, data);
+          if (parsed.event === "done" || parsed.event === "timeout") {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ events }) }]
+            };
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    throw new ToolError(
+      `GET /tasks/${taskId}/stream closed without a done or timeout event`
+    );
+  };
+}
+export {
+  WaitForTask
+};

package/dist/common/register-clients.js

@@ -1,3 +1,4 @@
+import { BearQClient } from "../bearq/client.js";
 import { BugsnagClient } from "../bugsnag/client.js";
 import { CollaboratorClient } from "../collaborator/client.js";
 import { PactflowClient } from "../pactflow/client.js";
@@ -7,6 +8,7 @@ import { ReflectClient } from "../reflect/client.js";
 import { SwaggerClient } from "../swagger/client.js";
 import { ZephyrClient } from "../zephyr/client.js";
 import { clientRegistry } from "./client-registry.js";
+clientRegistry.register(new BearQClient());
 clientRegistry.register(new ReflectClient());
 clientRegistry.register(new BugsnagClient());
 clientRegistry.register(new SwaggerClient());

package/dist/package.json.js

@@ -1,4 +1,4 @@
-const version = "0.22.0";
+const version = "0.23.0";
 const config = { "mcpServerName": "SmartBear MCP Server" };
 const packageJson = {
   version,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartbear/mcp",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "MCP server for interacting SmartBear Products",
   "keywords": [
     "smartbear",