@smartbear/mcp 0.6.0 → 0.8.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/), [QMetry](https://www.qmetry.com/), and [Zephyr](https://smartbear.com/test-management/zephyr/).
 
 ## What is MCP?
 
@@ -32,12 +32,14 @@ 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
+- [Zephyr](https://developer.smartbear.com/smartbear-mcp/docs/zephyr-integration) - Zephyr 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, QMetry, or Zephyr)
 - Valid API tokens for the products you want to integrate
 
 ## Installation
@@ -73,7 +75,11 @@ 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}",
+        "ZEPHYR_API_TOKEN": "${input:zephyr_api_token}",
+        "ZEPHYR_BASE_URL": "${input:zephyr_base_url}"
       }
     }
   },
@@ -126,6 +132,30 @@ 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
+      },
+      {
+          "id": "zephyr_api_token",
+          "type": "promptString",
+          "description": "Zephyr API token - leave blank to disable Zephyr tools",
+          "password": true
+      },
+      {
+          "id": "zephyr_base_url",
+          "type": "promptString",
+          "description": "Zephyr API base URL. By default, connects to https://api.zephyrscale.smartbear.com/v2. Change to region-specific endpoint if needed.",
+          "password": false
+      }
   ]
 }
 ```
@@ -153,6 +183,10 @@ 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",
+        "ZEPHYR_API_TOKEN": "your_zephyr_api_token",
+        "ZEPHYR_BASE_URL": "https://api.zephyrscale.smartbear.com/v2"
       }
     }
   }

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

@@ -0,0 +1,387 @@
+// 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 (declared JSON):", error);
+                return defaultReturn;
+            }
+        }
+        // Fallback: read text and attempt heuristic JSON parse
+        const text = await response.text();
+        if (!text)
+            return defaultReturn;
+        const trimmed = text.trim();
+        const firstChar = trimmed[0];
+        if (firstChar === "{" || firstChar === "[") {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch (error) {
+                console.warn("Heuristic JSON parse failed:", error);
+                return { message: text };
+            }
+        }
+        return { message: text };
+    }
+    /**
+     * 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,
+        });
+        const result = await this.handleResponse(response, []);
+        return result;
+    }
+    async createPortal(body) {
+        const response = await fetch(`${this.config.portalBasePath}/portals`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        const result = await this.handleResponse(response);
+        if (!("id" in result)) {
+            throw new Error("Unexpected empty response creating portal");
+        }
+        return result;
+    }
+    async getPortal(portalId) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        const result = await this.handleResponse(response);
+        if (!("id" in result)) {
+            throw new Error("Portal not found or empty response");
+        }
+        return result;
+    }
+    async deletePortal(portalId) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}`, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            throw new Error(`API Hub deletePortal failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+        }
+    }
+    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,
+        });
+        const result = await this.handleResponse(response, []);
+        return result;
+    }
+    async createPortalProduct(portalId, body) {
+        const response = await fetch(`${this.config.portalBasePath}/portals/${portalId}/products`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        const result = await this.handleResponse(response);
+        if (!("id" in result)) {
+            throw new Error("Unexpected empty response creating product");
+        }
+        return result;
+    }
+    async getPortalProduct(productId) {
+        const response = await fetch(`${this.config.portalBasePath}/products/${productId}`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        const result = await this.handleResponse(response);
+        if (!("id" in result)) {
+            throw new Error("Product not found or empty response");
+        }
+        return result;
+    }
+    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),
+        });
+        return this.handleResponse(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
+     */
+    // 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();
+        }
+    }
+    /**
+     * Create or Update API in SwaggerHub Registry
+     * @param params Parameters for creating or updating the API including owner, name, version, specification, and definition
+     * @returns Created or updated API metadata with URL. HTTP 201 indicates creation, HTTP 200 indicates update
+     */
+    async createOrUpdateApi(params) {
+        // Determine the format of the definition
+        let contentType;
+        let requestBody;
+        // Auto-detect format from the definition content
+        const format = this.detectDefinitionFormat(params.definition);
+        if (format === "yaml") {
+            contentType = "application/yaml";
+            requestBody = params.definition; // Send YAML as-is
+        }
+        else {
+            contentType = "application/json";
+            // For JSON, parse and stringify to ensure valid JSON
+            try {
+                const parsedDefinition = JSON.parse(params.definition);
+                requestBody = JSON.stringify(parsedDefinition);
+            }
+            catch (error) {
+                throw new Error(`Invalid JSON format in definition: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        // Construct the URL with query parameters
+        // Fixed values: visibility=private, automock=false, version=1.0.0
+        const searchParams = new URLSearchParams();
+        searchParams.append("isPrivate", "true");
+        const url = `${this.config.registryBasePath}/apis/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.apiName)}?${searchParams.toString()}`;
+        // Use POST method with the appropriate content type
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                ...this.headers,
+                "Content-Type": contentType,
+            },
+            body: requestBody,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            throw new Error(`SwaggerHub Registry API createOrUpdateApi failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}. URL: ${url}`);
+        }
+        // Determine operation type based on HTTP status code
+        const operation = response.status === 201 ? "create" : "update";
+        // Return formatted response with the required fields
+        // Fixed version is always 1.0.0
+        return {
+            owner: params.owner,
+            apiName: params.apiName,
+            version: "1.0.0",
+            url: `https://app.swaggerhub.com/apis/${params.owner}/${params.apiName}/1.0.0`,
+            operation,
+        };
+    }
+    /**
+     * Create API from Template in SwaggerHub Registry
+     * @param params Parameters for creating API from template including owner, api name, and template
+     * @returns Created API metadata with URL. HTTP 201 indicates creation, HTTP 200 indicates update
+     */
+    async createApiFromTemplate(params) {
+        // Construct the URL with query parameters
+        // Fixed values: visibility=private, no project, noReconcile=false
+        const searchParams = new URLSearchParams();
+        searchParams.append("isPrivate", "true");
+        searchParams.append("template", params.template);
+        const url = `${this.config.registryBasePath}/apis/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.apiName)}/.template?${searchParams.toString()}`;
+        // Use POST method for template creation
+        const response = await fetch(url, {
+            method: "POST",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            throw new Error(`SwaggerHub Registry API createApiFromTemplate failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}. URL: ${url}`);
+        }
+        // Determine operation type based on HTTP status code
+        const operation = response.status === 201 ? "create" : "update";
+        // Return formatted response with the required fields
+        return {
+            owner: params.owner,
+            apiName: params.apiName,
+            template: params.template,
+            url: `https://app.swaggerhub.com/apis/${params.owner}/${params.apiName}`,
+            operation,
+        };
+    }
+    /**
+     * Auto-detect the format of an API definition string
+     * @param definition The API definition content
+     * @returns 'json' or 'yaml'
+     */
+    detectDefinitionFormat(definition) {
+        const trimmed = definition.trim();
+        if (!trimmed) {
+            throw new Error("Empty definition content provided");
+        }
+        try {
+            JSON.parse(trimmed);
+            return "json";
+        }
+        catch {
+            return "yaml";
+        }
+    }
+}

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"),
+});