@smartbear/mcp 0.6.0 → 0.7.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), [API Hub](https://www.smartbear.com/api-hub), [PactFlow](https://pactflow.io/) and [Pact Broker](https://docs.pact.io/)
+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), [API Hub](https://www.smartbear.com/api-hub), [PactFlow](https://pactflow.io/), [Pact Broker](https://docs.pact.io/), and [QMetry](https://www.qmetry.com/)
 
 ## What is MCP?
 
@@ -32,12 +32,13 @@ See individual guides for suggested prompts and supported tools and resources:
 - [Test Hub](https://developer.smartbear.com/smartbear-mcp/docs/test-hub-integration) - Test management and execution capabilities
 - [API Hub](https://developer.smartbear.com/smartbear-mcp/docs/api-hub-integration) - Portal management capabilities
 - [PactFlow](https://developer.smartbear.com/pactflow/default/getting-started) - Contract testing capabilities
+- [QMetry](https://developer.smartbear.com/smartbear-mcp/docs/qmetry-integration) - QMetry Test Management capabilities
 
 
 ## Prerequisites
 
 - Node.js 20+ and npm
-- Access to SmartBear products (BugSnag, Reflect, or API Hub)
+- Access to SmartBear products (BugSnag, Reflect, API Hub, or QMetry)
 - Valid API tokens for the products you want to integrate
 
 ## Installation
@@ -73,7 +74,9 @@ Alternatively, you can use `npx` (or globally install) the `@smartbear/mcp` pack
         "PACT_BROKER_BASE_URL": "${input:pact_broker_base_url}",
         "PACT_BROKER_TOKEN": "${input:pact_broker_token}",
         "PACT_BROKER_USERNAME": "${input:pact_broker_username}",
-        "PACT_BROKER_PASSWORD": "${input:pact_broker_password}"
+        "PACT_BROKER_PASSWORD": "${input:pact_broker_password}",
+        "QMETRY_API_KEY": "${input:qmetry_api_key}",
+        "QMETRY_BASE_URL": "${input:qmetry_base_url}",
       }
     }
   },
@@ -126,6 +129,18 @@ Alternatively, you can use `npx` (or globally install) the `@smartbear/mcp` pack
          "description": "Pact Broker Password",
          "password": true
       },
+      {
+          "id": "qmetry_api_key",
+          "type": "promptString",
+          "description": "QMetry Open API Key",
+          "password": true
+      },
+      {
+          "id": "qmetry_base_url",
+          "type": "promptString",
+          "description": "By default, connects to https://testmanagement.qmetry.com. Change to a custom QMetry server URL or a region-specific endpoint if needed.",
+          "password": false
+      },
   ]
 }
 ```
@@ -153,6 +168,8 @@ Add the following configuration to your `claude_desktop_config.json` to launch t
         "PACT_BROKER_TOKEN": "your_pactflow_token",
         "PACT_BROKER_USERNAME": "your_pact_broker_username",
         "PACT_BROKER_PASSWORD": "your_pact_broker_password",
+        "QMETRY_API_KEY": "your_qmetry_api_key",
+        "QMETRY_BASE_URL": "https://testmanagement.qmetry.com",
       }
     }
   }

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

@@ -0,0 +1,253 @@
+// Regex to extract owner, name, and version from SwaggerHub URLs.
+// Matches /apis/owner/name/version, /domains/owner/name/version, or /templates/owner/name/version
+// Example: /apis/acme/petstore/1.0.0
+//   - group 1: type (apis|domains|templates)
+//   - group 2: owner
+//   - group 3: name
+//   - group 4: version
+const SWAGGER_URL_REGEX = /\/(apis|domains|templates)\/([^/]+)\/([^/]+)\/([^/]+)/;
+export class ApiHubAPI {
+    config;
+    headers;
+    constructor(config, userAgent) {
+        this.config = config;
+        this.headers = config.getHeaders(userAgent);
+    }
+    /**
+     * Core response parsing logic shared between different response handlers.
+     * Handles 204 No Content, empty responses, JSON parsing, and text fallbacks.
+     * @template T - Expected JSON response data type
+     * @template D - Default return type for empty responses
+     * @param response - The fetch Response object
+     * @param defaultReturn - Default value to return for empty responses
+     * @returns Parsed response data or fallback value
+     */
+    async parseResponse(response, defaultReturn = {}) {
+        // Handle 204 No Content responses
+        if (response.status === 204) {
+            return defaultReturn;
+        }
+        // Check if response has content-length of 0 (empty body)
+        const contentLength = response.headers.get("content-length");
+        if (contentLength === "0") {
+            return defaultReturn;
+        }
+        // Check if response is JSON
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+            try {
+                return (await response.json());
+            }
+            catch (error) {
+                console.warn("Failed to parse JSON response:", error);
+                return defaultReturn;
+            }
+        }
+        // Fallback for non-JSON responses
+        const text = await response.text();
+        return text ? { message: text } : defaultReturn;
+    }
+    /**
+     * Handles HTTP responses with smart JSON parsing and fallback handling.
+     * Includes HTTP error checking before parsing.
+     * @template T - Expected response data type
+     * @param response - The fetch Response object
+     * @param defaultReturn - Default value to return for empty responses
+     * @returns Parsed response data or fallback value
+     */
+    async handleResponse(response, defaultReturn = {}) {
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return this.parseResponse(response, defaultReturn);
+    }
+    async getPortals() {
+        const response = await fetch(`${this.config.portalBasePath}/portals`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async createPortal(body) {
+        const response = await fetch(`${this.config.portalBasePath}/portals`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+    async getPortal(portalId) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async deletePortal(portalId) {
+        await fetch(`${this.config.portalBasePath}/portals/${portalId}`, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+    }
+    async updatePortal(portalId, body) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}`, {
+            method: "PATCH",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return this.handleResponse(response);
+    }
+    async getPortalProducts(portalId) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}/products`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async createPortalProduct(portalId, body) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}/products`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+    async getPortalProduct(productId) {
+        const response = await fetch(`${this.config.portalBasePath}/products/${productId}`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async deletePortalProduct(productId) {
+        const response = await fetch(`${this.config.portalBasePath}/products/${productId}`, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+        return this.handleResponse(response);
+    }
+    async updatePortalProduct(productId, body) {
+        const response = await fetch(`${this.config.portalBasePath}/products/${productId}`, {
+            method: "PATCH",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        // Custom error handling for updatePortalProduct
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            throw new Error(`API Hub updatePortalProduct failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+        }
+        // Use handleResponse but with custom default return value
+        return this.handleResponseWithoutErrorCheck(response, { success: true });
+    }
+    /**
+     * Helper method for handling responses when error checking is already done.
+     * Delegates to parseResponse for the actual parsing logic.
+     * @template T - Expected response data type
+     * @template D - Default return type
+     * @param response - The fetch Response object
+     * @param defaultReturn - Default value to return for empty responses
+     * @returns Parsed response data or fallback value
+     */
+    async handleResponseWithoutErrorCheck(response, defaultReturn = {}) {
+        return this.parseResponse(response, defaultReturn);
+    }
+    // Registry API methods for SwaggerHub Design functionality
+    /**
+     * Search APIs and Domains in SwaggerHub Registry using /specs endpoint
+     * @param params Search parameters
+     * @returns Array of processed API metadata
+     */
+    async searchApis(params = {}) {
+        const searchParams = new URLSearchParams();
+        if (params.query)
+            searchParams.append("query", params.query);
+        if (params.state)
+            searchParams.append("state", params.state);
+        if (params.tag)
+            searchParams.append("tag", params.tag);
+        if (params.offset !== undefined)
+            searchParams.append("offset", params.offset.toString());
+        if (params.limit !== undefined)
+            searchParams.append("limit", params.limit.toString());
+        if (params.sort)
+            searchParams.append("sort", params.sort);
+        if (params.order)
+            searchParams.append("order", params.order);
+        if (params.owner)
+            searchParams.append("owner", params.owner);
+        if (params.specType)
+            searchParams.append("specType", params.specType);
+        const url = `${this.config.registryBasePath}/specs${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`SwaggerHub Registry API searchApis failed - status: ${response.status} ${response.statusText}`);
+        }
+        const apisJsonResponse = (await response.json());
+        // Transform APIs.json response to our ApiMetadata format
+        return this.transformApisJsonToMetadata(apisJsonResponse.apis);
+    }
+    /**
+     * Transform APIs.json specifications to our ApiMetadata format
+     * @param specs Array of API specifications from APIs.json
+     * @returns Array of processed API metadata
+     */
+    transformApisJsonToMetadata(specs) {
+        return specs.map((spec) => {
+            // Extract useful properties from the properties array
+            const properties = spec.properties || [];
+            const getProperty = (type) => {
+                const property = properties.find((p) => p.type === type);
+                return property?.value || property?.url;
+            };
+            // Extract owner, name, and version from the Swagger URL using the regex constant
+            const swaggerUrl = getProperty("Swagger") || "";
+            const urlMatch = RegExp(SWAGGER_URL_REGEX).exec(swaggerUrl);
+            return {
+                owner: urlMatch?.[2] || "",
+                name: spec.name || "",
+                description: spec.description || "",
+                summary: spec.summary || "",
+                version: getProperty("X-Version") || urlMatch?.[4] || "",
+                specification: getProperty("X-Specification") || "",
+                created: getProperty("X-Created"),
+                modified: getProperty("X-Modified"),
+                published: getProperty("X-Published"),
+                private: getProperty("X-Private"),
+                oasVersion: getProperty("X-OASVersion"),
+                url: swaggerUrl,
+            };
+        });
+    }
+    /**
+     * Get API definition from SwaggerHub Registry
+     * @param params Parameters including owner, api name, version, and options
+     * @returns API definition (OpenAPI/Swagger specification)
+     */
+    async getApiDefinition(params) {
+        const searchParams = new URLSearchParams();
+        if (params.resolved !== undefined)
+            searchParams.append("resolved", params.resolved.toString());
+        if (params.flatten !== undefined)
+            searchParams.append("flatten", params.flatten.toString());
+        const url = `${this.config.registryBasePath}/apis/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.api)}/${encodeURIComponent(params.version)}${searchParams.toString() ? `?${searchParams.toString()}` : ""}`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`SwaggerHub Registry API getApiDefinition failed - status: ${response.status} ${response.statusText}`);
+        }
+        // Return the raw API definition (could be JSON or YAML)
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+            return response.json();
+        }
+        else {
+            return response.text();
+        }
+    }
+}

package/dist/api-hub/client/configuration.js

@@ -0,0 +1,27 @@
+export class ApiHubConfiguration {
+    token;
+    portalBasePath;
+    registryBasePath;
+    headers;
+    constructor(param) {
+        this.token = param.token;
+        this.portalBasePath =
+            param.portalBasePath || "https://api.portal.swaggerhub.com/v1";
+        this.registryBasePath =
+            param.registryBasePath || "https://api.swaggerhub.com";
+        this.headers = {
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+            ...param.headers,
+        };
+    }
+    /**
+     * Get headers with User-Agent included
+     */
+    getHeaders(userAgent) {
+        return {
+            ...this.headers,
+            "User-Agent": userAgent,
+        };
+    }
+}

package/dist/api-hub/client/index.js

@@ -0,0 +1,5 @@
+export { ApiHubAPI } from "./api.js";
+export { ApiHubConfiguration, } from "./configuration.js";
+export * from "./portal-types.js";
+export * from "./registry-types.js";
+export { TOOLS } from "./tools.js";

package/dist/api-hub/client/portal-types.js

@@ -0,0 +1,131 @@
+import { z } from "zod";
+// Zod schemas for Portal API validation
+export const PortalArgsSchema = z.object({
+    portalId: z
+        .string()
+        .describe("Portal UUID or subdomain - unique identifier for the portal instance"),
+});
+export const ProductArgsSchema = z.object({
+    productId: z
+        .string()
+        .describe("Product UUID or identifier in the format 'portal-subdomain:product-slug' - unique identifier for the product"),
+});
+export const CreatePortalArgsSchema = z.object({
+    name: z
+        .string()
+        .optional()
+        .describe("The display name for the portal - shown to users and in branding (3-40 characters)"),
+    subdomain: z
+        .string()
+        .describe("The portal subdomain - used in the portal URL (e.g., 'myportal' for myportal.example.com). Must be unique, lowercase, 3-20 characters, alphanumeric with hyphens"),
+    offline: z
+        .boolean()
+        .optional()
+        .describe("If true, the portal will not be visible to customers - useful for development/staging environments. Defaults to false"),
+    routing: z
+        .string()
+        .optional()
+        .describe("Routing strategy for the portal - either 'browser' (client-side routing) or 'proxy' (server-side routing). Defaults to 'browser'"),
+    credentialsEnabled: z
+        .boolean()
+        .optional()
+        .describe("Whether authentication credentials are enabled for accessing the portal. When true, users can authenticate to access private content. Defaults to true"),
+    swaggerHubOrganizationId: z
+        .string()
+        .describe("The corresponding SwaggerHub organization UUID - required for portal creation. This links the portal to your SwaggerHub organization"),
+    openapiRenderer: z
+        .string()
+        .optional()
+        .describe("OpenAPI renderer type: 'SWAGGER_UI' (Swagger UI), 'ELEMENTS' (Stoplight Elements), or 'TOGGLE' (allows switching between both with Elements as default). Defaults to 'TOGGLE'"),
+    pageContentFormat: z
+        .string()
+        .optional()
+        .describe("Format for page content rendering - determines how documentation pages are processed: 'HTML', 'MARKDOWN', or 'BOTH'. Defaults to 'HTML'"),
+});
+export const UpdatePortalArgsSchema = PortalArgsSchema.extend({
+    name: z
+        .string()
+        .optional()
+        .describe("Update the portal display name - shown to users and in branding (3-40 characters)"),
+    subdomain: z
+        .string()
+        .optional()
+        .describe("Update the portal subdomain - changes the portal URL. Must remain unique across all portals (3-20 characters, lowercase, alphanumeric with hyphens)"),
+    customDomain: z
+        .boolean()
+        .optional()
+        .describe("Enable/disable custom domain for the portal - allows using your own domain instead of the default subdomain"),
+    gtmKey: z
+        .string()
+        .optional()
+        .describe("Google Tag Manager key for analytics tracking - format: GTM-XXXXXX (max 25 characters)"),
+    offline: z
+        .boolean()
+        .optional()
+        .describe("Set portal visibility - true hides portal from customers (useful for maintenance or development)"),
+    routing: z
+        .string()
+        .optional()
+        .describe("Update routing strategy - 'browser' for client-side routing or 'proxy' for server-side routing"),
+    credentialsEnabled: z
+        .boolean()
+        .optional()
+        .describe("Enable/disable authentication credentials for portal access - controls whether users can authenticate to view private content"),
+    openapiRenderer: z
+        .string()
+        .optional()
+        .describe("Change OpenAPI renderer: 'SWAGGER_UI' (Swagger UI), 'ELEMENTS' (Stoplight Elements), or 'TOGGLE' (switch between both)"),
+    pageContentFormat: z
+        .string()
+        .optional()
+        .describe("Update page content format for documentation rendering: 'HTML', 'MARKDOWN', or 'BOTH'"),
+});
+export const CreateProductArgsSchema = PortalArgsSchema.extend({
+    type: z
+        .string()
+        .describe("Product creation type - 'new' to create from scratch or 'copy' to duplicate an existing product"),
+    name: z
+        .string()
+        .describe("Product display name - will be shown to users in the portal navigation and product listings (3-40 characters)"),
+    slug: z
+        .string()
+        .describe("URL-friendly identifier for the product - must be unique within the portal, used in URLs (e.g., 'my-api' becomes /my-api). 3-22 characters, lowercase, alphanumeric with hyphens, underscores, or dots"),
+    description: z
+        .string()
+        .optional()
+        .describe("Product description - explains what the API/product does, shown in product listings and cards (max 110 characters)"),
+    public: z
+        .boolean()
+        .optional()
+        .describe("Whether the product is publicly visible to all portal visitors - false means only authenticated users with appropriate roles can access it"),
+    hidden: z
+        .boolean()
+        .optional()
+        .describe("Whether the product is hidden from the portal landing page navigation menus - useful for internal or draft products"),
+    role: z
+        .boolean()
+        .optional()
+        .describe("Whether the product has role-based access restrictions - controls if specific user roles are required to access the product"),
+});
+export const UpdateProductArgsSchema = ProductArgsSchema.extend({
+    name: z
+        .string()
+        .optional()
+        .describe("Update product display name - changes how it appears to users in navigation and listings (3-40 characters)"),
+    slug: z
+        .string()
+        .optional()
+        .describe("Update URL-friendly identifier - must remain unique within the portal, affects product URLs (3-22 characters, lowercase, alphanumeric with hyphens/underscores/dots)"),
+    description: z
+        .string()
+        .optional()
+        .describe("Update product description - explains the API/product functionality, shown in listings (max 110 characters)"),
+    public: z
+        .boolean()
+        .optional()
+        .describe("Change product visibility - true makes it publicly accessible to all visitors, false restricts to authenticated users with roles"),
+    hidden: z
+        .boolean()
+        .optional()
+        .describe("Change navigation visibility - true hides from portal landing page menus while keeping the product accessible via direct links"),
+});

package/dist/api-hub/client/registry-types.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+// Zod schemas for SwaggerHub Registry API validation
+export const ApiSearchParamsSchema = z.object({
+    query: z
+        .string()
+        .optional()
+        .describe("Search query to filter APIs by name, description, or content"),
+    state: z
+        .enum(["ALL", "PUBLISHED", "UNPUBLISHED"])
+        .optional()
+        .describe("Filter APIs by publication state - ALL (default), PUBLISHED, or UNPUBLISHED"),
+    tag: z.string().optional().describe("Filter APIs by tag"),
+    offset: z
+        .number()
+        .min(0)
+        .optional()
+        .describe("Offset for pagination (0-based, default 0)"),
+    limit: z
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Number of results per page (1-100, default 20)"),
+    sort: z
+        .enum(["NAME", "UPDATED", "CREATED"])
+        .optional()
+        .describe("Sort field - NAME, UPDATED, or CREATED (default NAME)"),
+    order: z
+        .enum(["ASC", "DESC"])
+        .optional()
+        .describe("Sort order - ASC or DESC (default ASC)"),
+    owner: z
+        .string()
+        .optional()
+        .describe("Filter APIs by owner (organization or user)"),
+    specType: z
+        .enum(["API", "DOMAIN"])
+        .optional()
+        .describe("Filter by specification type - API or DOMAIN (default all types)"),
+});
+export const ApiDefinitionParamsSchema = z.object({
+    owner: z
+        .string()
+        .describe("API owner (organization or user, case-sensitive)"),
+    api: z.string().describe("API name (case-sensitive)"),
+    version: z.string().describe("Version identifier"),
+    resolved: z
+        .boolean()
+        .optional()
+        .describe("Set to true to get the resolved version with all external $refs included (default false)"),
+    flatten: z
+        .boolean()
+        .optional()
+        .describe("Set to true to create models from inline schemas in OpenAPI definition (default false)"),
+});

package/dist/api-hub/client/tools.js

@@ -0,0 +1,86 @@
+/**
+ * TOOLS
+ *
+ * Defines tool configurations for API Hub operations.
+ * Each tool includes parameters, descriptions, and handler method names.
+ * This follows the pattern established in the pactflow module.
+ */
+import { CreatePortalArgsSchema, CreateProductArgsSchema, PortalArgsSchema, ProductArgsSchema, UpdatePortalArgsSchema, UpdateProductArgsSchema, } from "./portal-types.js";
+import { ApiDefinitionParamsSchema, ApiSearchParamsSchema, } from "./registry-types.js";
+export const TOOLS = [
+    {
+        title: "List Portals",
+        summary: "Search for available portals within API Hub. Only portals where you have at least a designer role, either at the product level or organization level, are returned.",
+        parameters: [],
+        handler: "getPortals",
+    },
+    {
+        title: "Create Portal",
+        summary: "Create a new portal within API Hub.",
+        zodSchema: CreatePortalArgsSchema,
+        handler: "createPortal",
+    },
+    {
+        title: "Get Portal",
+        summary: "Retrieve information about a specific portal.",
+        zodSchema: PortalArgsSchema,
+        handler: "getPortal",
+    },
+    {
+        title: "Delete Portal",
+        summary: "Delete a specific portal.",
+        zodSchema: PortalArgsSchema,
+        handler: "deletePortal",
+        formatResponse: () => "Portal deleted successfully.",
+    },
+    {
+        title: "Update Portal",
+        summary: "Update a specific portal's configuration.",
+        zodSchema: UpdatePortalArgsSchema,
+        handler: "updatePortal",
+    },
+    {
+        title: "List Portal Products",
+        summary: "Get products for a specific portal that match your criteria.",
+        zodSchema: PortalArgsSchema,
+        handler: "getPortalProducts",
+    },
+    {
+        title: "Create Portal Product",
+        summary: "Create a new product for a specific portal.",
+        zodSchema: CreateProductArgsSchema,
+        handler: "createPortalProduct",
+    },
+    {
+        title: "Get Portal Product",
+        summary: "Retrieve information about a specific product resource.",
+        zodSchema: ProductArgsSchema,
+        handler: "getPortalProduct",
+    },
+    {
+        title: "Delete Portal Product",
+        summary: "Delete a product from a specific portal",
+        zodSchema: ProductArgsSchema,
+        handler: "deletePortalProduct",
+        formatResponse: () => "Product deleted successfully.",
+    },
+    {
+        title: "Update Portal Product",
+        summary: "Update a product's settings within a specific portal.",
+        zodSchema: UpdateProductArgsSchema,
+        handler: "updatePortalProduct",
+    },
+    // Registry API tools for SwaggerHub Design functionality
+    {
+        title: "Search APIs and Domains",
+        summary: "Search for APIs and Domains in SwaggerHub Registry using the comprehensive /specs endpoint and retrieve metadata including owner, name, description, summary, version, and specification.",
+        zodSchema: ApiSearchParamsSchema,
+        handler: "searchApis",
+    },
+    {
+        title: "Get API Definition",
+        summary: "Fetch resolved API definition from SwaggerHub Registry based on owner, API name, and version.",
+        zodSchema: ApiDefinitionParamsSchema,
+        handler: "getApiDefinition",
+    },
+];