@smartbear/mcp 0.28.0 → 0.29.0

package/README.md

@@ -35,7 +35,7 @@ See individual guides for suggested prompts and supported tools and resources:
   - [Portal](https://developer.smartbear.com/smartbear-mcp/docs/swagger-portal-integration) - Portal and product management capabilities
   - [Studio](https://developer.smartbear.com/smartbear-mcp/docs/swagger-studio-integration) - API and Domain management capabilities, including AI-powered API generation from prompts and automatic standardization
   - [Contract Testing (PactFlow)](https://developer.smartbear.com/pactflow/default/getting-started) - Contract testing capabilities
-  - [Functional Testing](https://developer.smartbear.com/smartbear-mcp/docs/functional-testing-integration) - API test discovery capabilities
+  - [Functional Testing](https://developer.smartbear.com/smartbear-mcp/docs/swagger-functional-testing-integration) - API test discovery capabilities
 - [QMetry](https://developer.smartbear.com/smartbear-mcp/docs/qmetry-integration) - QMetry Test Management capabilities
 - [Zephyr](https://developer.smartbear.com/smartbear-mcp/docs/zephyr-integration) - Zephyr Test Management capabilities
 - [Collaborator](https://developer.smartbear.com/smartbear-mcp/docs/collaborator-integration) - Review and Remote System Configuration management capabilities

package/dist/bearq/client.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
-import { USER_AGENT } from "../common/info.js";
+import { getUserAgent } 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 { ListEnvironments } from "./tool/environments/list-environments.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";
@@ -53,7 +54,7 @@ class BearQClient {
     return {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
-      "User-Agent": USER_AGENT
+      "User-Agent": getUserAgent()
     };
   }
   async registerTools(register, _getInput) {
@@ -69,7 +70,8 @@ class BearQClient {
       new GetTask(this),
       new GetTaskStatus(this),
       new StopTask(this),
-      new WaitForTask(this)
+      new WaitForTask(this),
+      new ListEnvironments(this)
     ];
     for (const tool of tools) {
       register(tool.specification, tool.handle);

package/dist/bearq/tool/environments/list-environments.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+const inputSchema = z.object({});
+class ListEnvironments extends Tool {
+  specification = {
+    title: "List Environments",
+    toolset: "Environments",
+    summary: "Lists the environments configured in the workspace. Use this to discover valid environment names to pass to the test-running tools, and to identify the workspace default.",
+    inputSchema,
+    readOnly: true
+  };
+  handle = async (_args) => {
+    const res = await fetch(`${this.client.getBaseUrl()}/environments`, {
+      method: "GET",
+      headers: this.client.getHeaders()
+    });
+    if (!res.ok)
+      throw new ToolError(
+        `GET /environments failed: ${res.status} ${res.statusText}`
+      );
+    return {
+      content: [{ type: "text", text: JSON.stringify(await res.json()) }]
+    };
+  };
+}
+export {
+  ListEnvironments
+};

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

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { Tool, ToolError } from "../../../common/tools.js";
-const inputSchema = z.object({});
+const inputSchema = z.object({
+  environment: z.string().min(1).optional().describe(
+    "Target environment name to run tests against. Omit to use the workspace default."
+  )
+});
 class RunRegressionTests extends Tool {
   specification = {
     title: "Run Regression Tests",
@@ -8,11 +12,14 @@ class RunRegressionTests extends Tool {
     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) => {
+  handle = async (args) => {
+    const { environment } = inputSchema.parse(args);
+    const body = { agent: "tester", mode: "run" };
+    if (environment !== void 0) body.environment = environment;
     const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
       method: "POST",
       headers: this.client.getHeaders(),
-      body: JSON.stringify({ agent: "tester", mode: "run" })
+      body: JSON.stringify(body)
     });
     if (!res.ok)
       throw new ToolError(

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

@@ -1,7 +1,10 @@
 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.")
+  testCaseIds: z.array(z.number().int().positive()).min(1).describe("IDs of BearQ regression test cases to run."),
+  environment: z.string().min(1).optional().describe(
+    "Target environment name to run tests against. Omit to use the workspace default."
+  )
 });
 class RunTestCases extends Tool {
   specification = {
@@ -11,11 +14,17 @@ class RunTestCases extends Tool {
     inputSchema
   };
   handle = async (args) => {
-    const { testCaseIds } = inputSchema.parse(args);
+    const { testCaseIds, environment } = inputSchema.parse(args);
+    const body = {
+      agent: "tester",
+      mode: "run",
+      testCaseIds
+    };
+    if (environment !== void 0) body.environment = environment;
     const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
       method: "POST",
       headers: this.client.getHeaders(),
-      body: JSON.stringify({ agent: "tester", mode: "run", testCaseIds })
+      body: JSON.stringify(body)
     });
     if (!res.ok)
       throw new ToolError(

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

@@ -1,7 +1,10 @@
 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.")
+  functionalAreas: z.array(z.union([z.number().int().positive(), z.string().min(1)])).min(1).describe("Functional areas to target, by ID or name."),
+  environment: z.string().min(1).optional().describe(
+    "Target environment name to run tests against. Omit to use the workspace default."
+  )
 });
 class RunTestsInFunctionalAreas extends Tool {
   specification = {
@@ -11,11 +14,17 @@ class RunTestsInFunctionalAreas extends Tool {
     inputSchema
   };
   handle = async (args) => {
-    const { functionalAreas } = inputSchema.parse(args);
+    const { functionalAreas, environment } = inputSchema.parse(args);
+    const body = {
+      agent: "tester",
+      mode: "run",
+      functionalAreas
+    };
+    if (environment !== void 0) body.environment = environment;
     const res = await fetch(`${this.client.getBaseUrl()}/tasks`, {
       method: "POST",
       headers: this.client.getHeaders(),
-      body: JSON.stringify({ agent: "tester", mode: "run", functionalAreas })
+      body: JSON.stringify(body)
     });
     if (!res.ok)
       throw new ToolError(

package/dist/bugsnag/client.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { USER_AGENT } from "../common/info.js";
+import { getUserAgent } from "../common/info.js";
 import { getRequestHeader } from "../common/request-context.js";
 import { ToolError } from "../common/tools.js";
 import { CurrentUserAPI } from "./client/api/CurrentUser.js";
@@ -123,7 +123,7 @@ class BugsnagClient {
         );
       },
       headers: {
-        "User-Agent": USER_AGENT,
+        "User-Agent": getUserAgent(),
         "Content-Type": "application/json",
         "X-Bugsnag-API": "true",
         "X-Version": "2"

package/dist/collaborator/client.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { USER_AGENT } from "../common/info.js";
+import { getUserAgent } from "../common/info.js";
 import { getRequestHeader } from "../common/request-context.js";
 const ConfigurationSchema = z.object({
   base_url: z.url().describe("Collaborator server base URL"),
@@ -48,7 +48,10 @@ class CollaboratorClient {
     ];
     const response = await fetch(url, {
       method: "POST",
-      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": getUserAgent()
+      },
       body: JSON.stringify(body)
     });
     if (!response.ok) {

package/dist/common/client-identity.js

@@ -0,0 +1,20 @@
+import { getRequestContext } from "./request-context.js";
+function toClientIdentity(info, protocolVersion) {
+  return {
+    name: info?.name,
+    version: info?.version,
+    protocolVersion
+  };
+}
+let processClientIdentity;
+function setProcessClientIdentity(identity) {
+  processClientIdentity = identity;
+}
+function getCurrentClientIdentity() {
+  return getRequestContext()?.mcpClient ?? processClientIdentity;
+}
+export {
+  getCurrentClientIdentity,
+  setProcessClientIdentity,
+  toClientIdentity
+};

package/dist/common/info.js

@@ -1,11 +1,31 @@
 import packageJson from "../package.json.js";
+import { getCurrentClientIdentity } from "./client-identity.js";
 const MCP_SERVER_NAME = packageJson.config.mcpServerName;
 const MCP_SERVER_VERSION = packageJson.version;
 const MCP_TRANSPORT = process.env.MCP_TRANSPORT?.toLowerCase().trim() || "stdio";
 const USER_AGENT = `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION} ${MCP_TRANSPORT}`;
+function sanitizeUserAgentToken(value) {
+  return value.replace(/[()\r\n;]/g, "").trim();
+}
+function clientIdentitySuffix(identity) {
+  if (!identity?.name) {
+    return "";
+  }
+  const clientName = sanitizeUserAgentToken(identity.name) || "unknown";
+  const version = identity.version ? sanitizeUserAgentToken(identity.version) || "unknown" : "unknown";
+  return ` (client: ${clientName}; clientVersion: ${version})`;
+}
+function appendClientIdentity(baseUserAgent) {
+  return baseUserAgent + clientIdentitySuffix(getCurrentClientIdentity());
+}
+function getUserAgent() {
+  return appendClientIdentity(USER_AGENT);
+}
 export {
   MCP_SERVER_NAME,
   MCP_SERVER_VERSION,
   MCP_TRANSPORT,
-  USER_AGENT
+  USER_AGENT,
+  appendClientIdentity,
+  getUserAgent
 };

package/dist/common/initialize.js

@@ -1,8 +1,15 @@
+import { toClientIdentity, setProcessClientIdentity } from "./client-identity.js";
 function handleInitializeMessage(server, message) {
   if (typeof message !== "object" || message === null || !("method" in message) || message.method !== "initialize") {
     return;
   }
   const params = message.params;
+  const identity = toClientIdentity(
+    params?.clientInfo,
+    params?.protocolVersion
+  );
+  server.setMcpClientIdentity(identity);
+  setProcessClientIdentity(identity);
   const clientInfo = params?.clientInfo;
   if (clientInfo) {
     server.setClientInfo(clientInfo);

package/dist/common/request-context.js

@@ -6,6 +6,12 @@ function withRequestContext(req, fn) {
 function getRequestContext() {
   return requestContextStorage.getStore();
 }
+function setRequestMcpClient(identity) {
+  const context = getRequestContext();
+  if (context) {
+    context.mcpClient = identity;
+  }
+}
 function getRequestHeader(name) {
   const context = getRequestContext();
   if (!context?.headers) return void 0;
@@ -16,5 +22,6 @@ export {
   getRequestContext,
   getRequestHeader,
   requestContextStorage,
+  setRequestMcpClient,
   withRequestContext
 };

package/dist/common/server.js

@@ -2,6 +2,7 @@ import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mc
 import { ZodObject, ZodIntersection } from "zod";
 import Bugsnag from "./bugsnag.js";
 import { CacheService } from "./cache.js";
+import { toClientIdentity } from "./client-identity.js";
 import { MCP_SERVER_VERSION, MCP_SERVER_NAME } from "./info.js";
 import { executeElicitationOrPolyfill, isElicitationPolyfillResult } from "./pollyfills.js";
 import { ToolError } from "./tools.js";
@@ -13,6 +14,7 @@ class SmartBearMcpServer extends McpServer {
   clientInfo;
   clients = [];
   enabledToolsets;
+  mcpClientIdentity;
   constructor(enabledToolsets) {
     super(
       {
@@ -58,6 +60,33 @@ class SmartBearMcpServer extends McpServer {
   getClients() {
     return this.clients;
   }
+  /**
+   * Record the MCP client identity reported in the `initialize` handshake.
+   * Captured once per session by the transport layer.
+   */
+  setMcpClientIdentity(identity) {
+    this.mcpClientIdentity = identity;
+  }
+  /**
+   * Return the MCP client identity for this session. Prefers the value captured
+   * at `initialize`; falls back to the SDK's `getClientVersion()` so callers
+   * still get an answer if the explicit capture was skipped.
+   */
+  getMcpClientIdentity() {
+    return this.mcpClientIdentity ?? toClientIdentity(this.server.getClientVersion());
+  }
+  /**
+   * Attach MCP client attribution to a Bugsnag event so errors can be segmented
+   * by originating client/marketplace.
+   */
+  addClientMetadata(event) {
+    const identity = this.getMcpClientIdentity();
+    event.addMetadata("mcpClient", {
+      mcp_client_name: identity.name ?? null,
+      mcp_client_version: identity.version ?? null,
+      mcp_protocol_version: identity.protocolVersion ?? null
+    });
+  }
   async cleanupSession(mcpSessionId) {
     for (const client of this.clients) {
       await client.cleanupSession?.(mcpSessionId);
@@ -113,6 +142,7 @@ class SmartBearMcpServer extends McpServer {
               } else {
                 Bugsnag.notify(e, (event) => {
                   event.addMetadata("app", { tool: toolName });
+                  this.addClientMetadata(event);
                   event.unhandled = true;
                 });
               }
@@ -163,6 +193,7 @@ ${result.instructions}`
                   resource: resourceName,
                   url: url2
                 });
+                this.addClientMetadata(event);
                 event.unhandled = true;
               });
               throw e;
@@ -188,6 +219,7 @@ ${result.instructions}`
                 event.addMetadata("app", {
                   prompt: this.getCapabilityName(client, params.title)
                 });
+                this.addClientMetadata(event);
                 event.unhandled = true;
               });
               throw e;

package/dist/common/transport-http.js

@@ -6,7 +6,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { clientRegistry } from "./client-registry.js";
 import { handleInitializeMessage } from "./initialize.js";
-import { withRequestContext } from "./request-context.js";
+import { withRequestContext, setRequestMcpClient } from "./request-context.js";
 import { SmartBearMcpServer } from "./server.js";
 import { isDraining, registerShutdownHandler } from "./shutdown.js";
 import { getEnvVarName } from "./transport-stdio.js";
@@ -269,10 +269,13 @@ async function handleStreamableHttpRequest(req, res, transports) {
       );
       return;
     }
-    await withRequestContext(
-      req,
-      async () => await transport.handleRequest(req, res, parsedBody)
-    );
+    const sessionServer = sessionId ? transports.get(sessionId)?.server : void 0;
+    await withRequestContext(req, async () => {
+      if (sessionServer) {
+        setRequestMcpClient(sessionServer.getMcpClientIdentity());
+      }
+      return await transport.handleRequest(req, res, parsedBody);
+    });
   } catch (error) {
     console.error("Error handling StreamableHTTP request:", error);
     res.writeHead(500, { "Content-Type": "text/plain" });
@@ -285,6 +288,7 @@ async function handleLegacySseRequest(req, res, transports) {
     return;
   }
   const transport = new SSEServerTransport("/message", res);
+  transport.onmessage = (message) => handleInitializeMessage(server, message);
   transports.set(transport.sessionId, { server, transport });
   res.on("close", () => {
     transports.delete(transport.sessionId);
@@ -317,14 +321,10 @@ async function handleLegacyMessageRequest(req, res, url, transports) {
   req.on("end", async () => {
     try {
       const parsedBody = JSON.parse(body);
-      await withRequestContext(
-        req,
-        async () => await session.transport.handlePostMessage(
-          req,
-          res,
-          parsedBody
-        )
-      );
+      await withRequestContext(req, async () => {
+        setRequestMcpClient(session.server.getMcpClientIdentity());
+        return await session.transport.handlePostMessage(req, res, parsedBody);
+      });
     } catch (error) {
       console.error("Error handling POST message:", error);
       res.writeHead(500, { "Content-Type": "text/plain" });

package/dist/package.json.js

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

package/dist/pactflow/client.js

@@ -1884,7 +1884,7 @@ class PactflowClient {
       `${this.baseUrl}/admin/teams/${encodeURIComponent(teamId)}/users`,
       {
         method: "PUT",
-        body: { uuids },
+        body: { users: uuids },
         errorContext: "Set Team Users"
       }
     );

package/dist/qmetry/client/api/client-api.js

@@ -1,4 +1,4 @@
-import { USER_AGENT } from "../../../common/info.js";
+import { getUserAgent } from "../../../common/info.js";
 import { QMETRY_DEFAULTS } from "../../config/constants.js";
 import { handleQMetryFetchError, handleQMetryApiError } from "./error-handler.js";
 async function qmetryRequest({
@@ -16,7 +16,7 @@ async function qmetryRequest({
   const headers = {
     apikey: token,
     project: project || QMETRY_DEFAULTS.PROJECT_KEY,
-    "User-Agent": USER_AGENT,
+    "User-Agent": getUserAgent(),
     "qmetry-source": "smartbear-mcp"
   };
   if (scopeId !== void 0) {

package/dist/qmetry/client/automation.js

@@ -1,4 +1,4 @@
-import { USER_AGENT } from "../../common/info.js";
+import { getUserAgent } from "../../common/info.js";
 import { QMETRY_DEFAULTS } from "../config/constants.js";
 import { QMETRY_PATHS } from "../config/rest-endpoints.js";
 import { DEFAULT_IMPORT_AUTOMATION_PAYLOAD } from "../types/automation.js";
@@ -91,7 +91,7 @@ async function importAutomationResults(token, baseUrl, project, payload) {
   const headers = {
     apikey: token,
     project: finalPayload.projectID || project || QMETRY_DEFAULTS.PROJECT_KEY,
-    "User-Agent": USER_AGENT,
+    "User-Agent": getUserAgent(),
     "qmetry-source": "smartbear-mcp"
     // Note: Content-Type will be set automatically by fetch for FormData
   };

package/dist/qtm4j/http/auth-service.js

@@ -1,4 +1,4 @@
-import { USER_AGENT } from "../../common/info.js";
+import { getUserAgent } from "../../common/info.js";
 import { CONTENT_TYPES, HTTP_HEADERS } from "../config/constants.js";
 class AuthService {
   apiKey;
@@ -13,7 +13,7 @@ class AuthService {
     return {
       [HTTP_HEADERS.API_KEY]: this.apiKey,
       [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON,
-      [HTTP_HEADERS.USER_AGENT]: USER_AGENT,
+      [HTTP_HEADERS.USER_AGENT]: getUserAgent(),
       [HTTP_HEADERS.ACCEPT]: CONTENT_TYPES.JSON
     };
   }

package/dist/reflect/client.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { USER_AGENT } from "../common/info.js";
+import { getUserAgent } from "../common/info.js";
 import { getRequestHeader } from "../common/request-context.js";
 import { ToolError } from "../common/tools.js";
 import { API_KEY_HEADER, REFLECT_API_TOKEN_HEADER, AUTHORIZATION_HEADER } from "./config/constants.js";
@@ -73,7 +73,7 @@ class ReflectClient {
     return {
       ...this.getAuthHeader(),
       "Content-Type": "application/json",
-      "User-Agent": USER_AGENT
+      "User-Agent": getUserAgent()
     };
   }
   getSessionState(sessionId) {

package/dist/swagger/client/api.js

@@ -1,3 +1,4 @@
+import { appendClientIdentity } from "../../common/info.js";
 import { ToolError } from "../../common/tools.js";
 import { buildSubdomainCandidate, buildSuffixedSubdomain, buildPortalName, isConflictError, isOrganizationPortalConflict } from "./portal-utils.js";
 import { findTableOfContentsItem, buildPortalLiveUrl, normalizeSlug } from "./utils.js";
@@ -22,7 +23,7 @@ class SwaggerAPI {
     this.userAgent = userAgent;
   }
   get headers() {
-    return this.config.getHeaders(this.userAgent);
+    return this.config.getHeaders(appendClientIdentity(this.userAgent));
   }
   /**
    * Core response parsing logic shared between different response handlers.

package/dist/swagger/client/functional-testing-api.js

@@ -1,3 +1,4 @@
+import { appendClientIdentity } from "../../common/info.js";
 import { ToolError } from "../../common/tools.js";
 const API_HOSTNAME = "api.reflect.run";
 const FUNCTIONAL_TESTING_API_KEY_HEADER = "X-API-KEY";
@@ -16,11 +17,27 @@ class FunctionalTestingAPI {
     return {
       [FUNCTIONAL_TESTING_API_KEY_HEADER]: token,
       "Content-Type": "application/json",
-      "User-Agent": this.userAgent
+      "User-Agent": appendClientIdentity(this.userAgent)
     };
   }
+  async ftFetch(input, init) {
+    let response;
+    try {
+      response = await fetch(input, init);
+    } catch {
+      throw new ToolError(
+        "Swagger Functional Testing service is currently unreachable. Retry after a moment."
+      );
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new ToolError(
+        "Authentication failed. Verify your API token is valid and has not expired."
+      );
+    }
+    return response;
+  }
   async listTests() {
-    const response = await fetch(`${this.baseUrl}/tests`, {
+    const response = await this.ftFetch(`${this.baseUrl}/tests`, {
       method: "GET",
       headers: this.getFtHeaders()
     });
@@ -33,8 +50,8 @@ class FunctionalTestingAPI {
   }
   async runTest(args) {
     if (!args.testId) throw new ToolError("testId argument is required");
-    const response = await fetch(
-      `${this.baseUrl}/tests/${args.testId}/executions`,
+    const response = await this.ftFetch(
+      `${this.baseUrl}/tests/${encodeURIComponent(args.testId)}/executions`,
       {
         method: "POST",
         headers: this.getFtHeaders()
@@ -51,8 +68,8 @@ class FunctionalTestingAPI {
     if (!args.executionId) {
       throw new ToolError("executionId argument is required");
     }
-    const response = await fetch(
-      `${this.baseUrl}/executions/${args.executionId}`,
+    const response = await this.ftFetch(
+      `${this.baseUrl}/executions/${encodeURIComponent(args.executionId)}`,
       {
         method: "GET",
         headers: this.getFtHeaders()
@@ -63,16 +80,87 @@ class FunctionalTestingAPI {
         `Failed to get test status: ${response.status} ${response.statusText}`
       );
     }
-    return response.json();
+    const data = await response.json();
+    if (Array.isArray(data.tests)) {
+      for (const test of data.tests) {
+        const run = test.run;
+        if (run) {
+          delete run.videoUrl;
+        }
+      }
+    }
+    return data;
+  }
+  async listSuiteExecutions(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    const response = await this.ftFetch(
+      `${this.baseUrl}/suites/${encodeURIComponent(args.suiteId)}/executions`,
+      {
+        method: "GET",
+        headers: this.getFtHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(suiteExecutionsErrorMessage(response));
+    }
+    const data = await response.json();
+    return {
+      ...data,
+      executions: {
+        data: data.executions.data.map(
+          ({ executionId, status, isFinished }) => ({
+            executionId,
+            status,
+            isFinished
+          })
+        )
+      }
+    };
   }
   async listSuites() {
-    const headers = this.getFtHeaders();
+    const response = await this.ftFetch(`${this.baseUrl}/suites`, {
+      method: "GET",
+      headers: this.getFtHeaders()
+    });
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to list Functional Testing suites: ${response.status} ${response.statusText}`
+      );
+    }
+    return response.json();
+  }
+  async cancelSuiteExecution(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    if (!args.executionId) {
+      throw new ToolError("executionId argument is required");
+    }
+    const response = await this.ftFetch(
+      `${this.baseUrl}/suites/${encodeURIComponent(args.suiteId)}/executions/${encodeURIComponent(args.executionId)}/cancel`,
+      {
+        method: "PATCH",
+        headers: this.getFtHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(cancelSuiteExecutionErrorMessage(response));
+    }
+    return response.json();
+  }
+  async runSuite(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    const body = args.tunnelAgentName ? JSON.stringify({
+      overrides: { agent: { name: args.tunnelAgentName } }
+    }) : void 0;
     let response;
     try {
-      response = await fetch(`${this.baseUrl}/suites`, {
-        method: "GET",
-        headers
-      });
+      response = await fetch(
+        `${this.baseUrl}/suites/${args.suiteId}/executions`,
+        {
+          method: "POST",
+          headers: this.getFtHeaders(),
+          body
+        }
+      );
     } catch {
       throw new ToolError(
         "Swagger Functional Testing service is currently unreachable. Retry after a moment."
@@ -85,10 +173,79 @@ class FunctionalTestingAPI {
     }
     if (!response.ok) {
       throw new ToolError(
-        `Failed to list Functional Testing suites: ${response.status} ${response.statusText}`
+        `Failed to run suite: ${response.status} ${response.statusText}`
       );
     }
-    return response.json();
+    return this.withoutField("url", response);
+  }
+  async getSuiteExecution(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    if (!args.executionId) {
+      throw new ToolError("executionId argument is required");
+    }
+    let response;
+    try {
+      response = await fetch(
+        `${this.baseUrl}/suites/${args.suiteId}/executions/${args.executionId}`,
+        {
+          method: "GET",
+          headers: this.getFtHeaders()
+        }
+      );
+    } catch {
+      throw new ToolError(
+        "Swagger Functional Testing service is currently unreachable. Retry after a moment."
+      );
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new ToolError(
+        "Authentication failed. Verify your API token is valid and has not expired."
+      );
+    }
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to get suite execution status: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await this.withoutField("url", response);
+    const testsData = data.tests?.data;
+    if (Array.isArray(testsData)) {
+      for (const test of testsData) {
+        if (Array.isArray(test.runs)) {
+          for (const run of test.runs) {
+            delete run.videoUrl;
+          }
+        }
+      }
+    }
+    return data;
+  }
+  async withoutField(field, response) {
+    const data = await response.json();
+    delete data[field];
+    return data;
+  }
+}
+function suiteExecutionsErrorMessage(response) {
+  switch (response.status) {
+    // Defensive: the Reflect API currently returns 200 with an empty
+    // `executions.data` list for an unknown suiteId rather than a 404, so this
+    // branch is not expected to fire today. Kept in case the API starts
+    // returning 404 for missing suites.
+    case 404:
+      return "Test suite not found. Verify the suiteId is correct and belongs to your workspace.";
+    default:
+      return `Failed to list suite executions: ${response.status} ${response.statusText}`;
+  }
+}
+function cancelSuiteExecutionErrorMessage(response) {
+  switch (response.status) {
+    case 404:
+      return "Suite execution not found. Verify the suiteId and executionId are correct and belong to your workspace.";
+    case 409:
+      return "Suite execution cannot be cancelled because it has already finished.";
+    default:
+      return `Failed to cancel suite execution: ${response.status} ${response.statusText}`;
   }
 }
 export {

package/dist/swagger/client/functional-testing-tools.js

@@ -1,10 +1,12 @@
-import { RunFunctionalTestingTestParamsSchema, GetFunctionalTestingExecutionTestSchema } from "./functional-testing-types.js";
+import { RunFunctionalTestingTestParamsSchema, GetFunctionalTestingExecutionTestSchema, ListFunctionalTestingSuiteExecutionsSchema, CancelFunctionalTestingSuiteExecutionSchema, RunFunctionalTestingSuiteParamsSchema, GetFunctionalTestingSuiteExecutionSchema } from "./functional-testing-types.js";
 const FUNCTIONAL_TESTING_TOOLS = [
   {
     title: "List Tests",
     toolset: "Functional Testing",
     summary: "Lists all API tests available in your Swagger Functional Testing account. Use this tool when you need to discover available tests before running them or checking their status. Do not use this tool to retrieve test execution results or history.",
-    handler: "listFunctionalTestingTests"
+    handler: "listFunctionalTestingTests",
+    idempotent: true,
+    readOnly: true
   },
   {
     title: "Run Test",
@@ -21,6 +23,25 @@ const FUNCTIONAL_TESTING_TOOLS = [
     summary: "Get the status of a Swagger Functional Testing test execution. It returns information about the execution such as its status (running, passed or failed), run time, as well as the break down of the status of each test step.",
     inputSchema: GetFunctionalTestingExecutionTestSchema,
     handler: "getFunctionalTestingExecution",
+    idempotent: true,
+    readOnly: true
+  },
+  {
+    title: "List Suite Executions",
+    toolset: "Functional Testing",
+    summary: "Lists all executions for a given test suite in your Swagger Functional Testing workspace. Use this tool when you need to review execution history and timings for a specific suite. Do not use this tool to retrieve the status of a single execution or individual test results.",
+    inputSchema: ListFunctionalTestingSuiteExecutionsSchema,
+    handler: "listFunctionalTestingSuiteExecutions",
+    readOnly: true,
+    idempotent: true
+  },
+  {
+    title: "Cancel Suite Execution",
+    toolset: "Functional Testing",
+    summary: "Cancels an ongoing test suite execution in your Swagger Functional Testing workspace. Use this tool when you need to stop a long-running or accidentally triggered suite run. Do not use this tool to cancel individual test runs.",
+    inputSchema: CancelFunctionalTestingSuiteExecutionSchema,
+    handler: "cancelFunctionalTestingSuiteExecution",
+    readOnly: false,
     idempotent: false
   },
   {
@@ -30,6 +51,24 @@ const FUNCTIONAL_TESTING_TOOLS = [
     handler: "listFunctionalTestingSuites",
     idempotent: true,
     readOnly: true
+  },
+  {
+    title: "Run Suite",
+    toolset: "Functional Testing",
+    summary: "Runs a specific test suite in your Swagger Functional Testing workspace. The execution is asynchronous — it returns an executionId, not results directly. Use `swagger_get_suite_status` with your suiteId and executionId to track progress and retrieve the final per-test results. Optionally accepts a `tunnelAgentName` argument to override the suite's saved tunnel for this run. Do not use this tool to run a single test — use `swagger_run_test` instead.",
+    inputSchema: RunFunctionalTestingSuiteParamsSchema,
+    handler: "runFunctionalTestingSuite",
+    idempotent: false,
+    readOnly: false
+  },
+  {
+    title: "Get Suite Status",
+    toolset: "Functional Testing",
+    summary: "Get the status of a Swagger Functional Testing suite execution. Returns the overall status (pending, canceled, passed or failed), whether the run is finished, and a per-test breakdown with pass/fail. Use this to poll for the outcome of a suite run triggered by `swagger_run_suite`. Requires both `suiteId` and the `executionId` arguments returned by `swagger_run_suite`.",
+    inputSchema: GetFunctionalTestingSuiteExecutionSchema,
+    handler: "getFunctionalTestingSuiteExecution",
+    idempotent: true,
+    readOnly: true
   }
 ];
 export {

package/dist/swagger/client/functional-testing-types.js

@@ -5,7 +5,28 @@ const RunFunctionalTestingTestParamsSchema = z.object({
 const GetFunctionalTestingExecutionTestSchema = z.object({
   executionId: z.string().describe("ID of the Functional Testing execution").trim().min(1)
 });
+const ListFunctionalTestingSuiteExecutionsSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite to list executions for").trim().min(1)
+});
+const CancelFunctionalTestingSuiteExecutionSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite the execution belongs to").trim().min(1),
+  executionId: z.string().describe("ID of the Functional Testing suite execution to cancel").trim().min(1)
+});
+const RunFunctionalTestingSuiteParamsSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite to run").trim().min(1),
+  tunnelAgentName: z.string().describe(
+    "Optional tunnel agent name to override the suite's saved tunnel for this run. When omitted, the suite's saved tunnel overrides are used, falling back to each test's saved tunnel."
+  ).trim().min(1).optional()
+});
+const GetFunctionalTestingSuiteExecutionSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite").trim().min(1),
+  executionId: z.string().describe("ID of the Functional Testing suite execution").trim().min(1)
+});
 export {
+  CancelFunctionalTestingSuiteExecutionSchema,
   GetFunctionalTestingExecutionTestSchema,
+  GetFunctionalTestingSuiteExecutionSchema,
+  ListFunctionalTestingSuiteExecutionsSchema,
+  RunFunctionalTestingSuiteParamsSchema,
   RunFunctionalTestingTestParamsSchema
 };

package/dist/swagger/client.js

@@ -181,6 +181,22 @@ class SwaggerClient {
   async getFunctionalTestingExecution(args) {
     return this.withFunctionalTesting((ftApi) => ftApi.getTestExecution(args));
   }
+  async listFunctionalTestingSuiteExecutions(args) {
+    return this.withFunctionalTesting(
+      (ftApi) => ftApi.listSuiteExecutions(args)
+    );
+  }
+  async cancelFunctionalTestingSuiteExecution(args) {
+    return this.withFunctionalTesting(
+      (ftApi) => ftApi.cancelSuiteExecution(args)
+    );
+  }
+  async runFunctionalTestingSuite(args) {
+    return this.withFunctionalTesting((ftApi) => ftApi.runSuite(args));
+  }
+  async getFunctionalTestingSuiteExecution(args) {
+    return this.withFunctionalTesting((ftApi) => ftApi.getSuiteExecution(args));
+  }
   /**
    * Perform an operation with the Functional Testing API.
    * Throws a ToolError if Functional Testing is not configured

package/dist/zephyr/common/auth-service.js

@@ -1,4 +1,4 @@
-import { USER_AGENT } from "../../common/info.js";
+import { getUserAgent } from "../../common/info.js";
 class AuthService {
   bearerToken;
   constructor(accessToken) {
@@ -8,7 +8,7 @@ class AuthService {
     return {
       Authorization: `Bearer ${this.bearerToken}`,
       "Content-Type": "application/json",
-      "User-Agent": USER_AGENT,
+      "User-Agent": getUserAgent(),
       "zscale-source": "smartbear-mcp"
     };
   }

package/dist/zephyr/common/rest-api-schemas.js

@@ -144,7 +144,7 @@ const createTestCaseBodyProjectKeyRegExp = /([A-Z][A-Z_0-9]+)/;
 const createTestCaseBodyNameMax = 255;
 const createTestCaseBodyNameRegExp = /^(?!\\s*$).+/;
 const createTestCaseBodyEstimatedTimeMin = 0;
-const createTestCaseBodyComponentIdMin = 0;
+const createTestCaseBodyComponentIdMin = 1;
 const createTestCaseBodyPriorityNameMax = 255;
 const createTestCaseBodyStatusNameMax = 255;
 const createTestCaseBodyOwnerIdRegExp = /^[-:a-zA-Z0-9]{1,128}$/;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartbear/mcp",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "MCP server for interacting SmartBear Products",
   "keywords": [
     "smartbear",
@@ -45,6 +45,7 @@
     "test:coverage": "vitest --coverage",
     "test:coverage:ci": "vitest --coverage --reporter=verbose",
     "test:run": "vitest run",
+    "test:pact": "vitest run --config vitest.pact.config.ts",
     "coverage:check": "vitest --coverage --reporter=verbose",
     "bump": "node scripts/bump.js"
   },
@@ -60,6 +61,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.8",
+    "@pact-foundation/pact": "^17.0.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.19.15",
     "@types/ws": "^8.18.1",