@smartbear/mcp 0.20.0 → 0.22.0

package/README.md

@@ -18,7 +18,7 @@
 </div>
 <br />
 
-A Model Context Protocol (MCP) server which provides AI assistants with seamless access to SmartBear's suite of testing and monitoring tools, including [BugSnag](https://www.bugsnag.com/), [Reflect](https://reflect.run), [Swagger](https://www.smartbear.com/api-hub), [PactFlow](https://pactflow.io/), [Pact Broker](https://docs.pact.io/), [QMetry](https://www.qmetry.com/), [Zephyr](https://smartbear.com/test-management/zephyr/) and [Collaborator](https://smartbear.com/product/collaborator/).
+A Model Context Protocol (MCP) server which provides AI assistants with seamless access to SmartBear's suite of testing and monitoring tools, including [BugSnag](https://www.bugsnag.com/), [Reflect](https://reflect.run), [Swagger](https://www.smartbear.com/api-hub), [PactFlow](https://pactflow.io/), [Pact Broker](https://docs.pact.io/), [QMetry](https://www.qmetry.com/), [QTM4J](https://www.qmetry.com/qmetry-test-management-for-jira), [Zephyr](https://smartbear.com/test-management/zephyr/) and [Collaborator](https://smartbear.com/product/collaborator/).
 
 ## What is MCP?
 
@@ -37,6 +37,7 @@ See individual guides for suggested prompts and supported tools and resources:
 - [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
+- [QTM4J](https://developer.smartbear.com/smartbear-mcp/docs/qtm4j-integration) - QTM4J Test Management for Jira capabilities
 
 ## Remote MCP Servers
 
@@ -50,12 +51,12 @@ For BugSnag, Swagger, and Zephyr, SmartBear hosts Remote MCP Servers that you ca
 
 See the [Remote MCP Servers guide](https://developer.smartbear.com/smartbear-mcp/docs/remote-mcp-servers) for per-client setup instructions. You can connect to multiple remote servers at the same time.
 
-> **Need Reflect, QMetry, PactFlow, or Collaborator?** These products are only available via the local npm package below, which bundles all products into a single MCP server.
+> **Need Reflect, QMetry, QTM4J, PactFlow, or Collaborator?** These products are only available via the local npm package below, which bundles all products into a single MCP server.
 
 ## Prerequisites
 
 - Node.js 20+ and npm
-- Access to SmartBear products (BugSnag, Reflect, Swagger, QMetry, or Zephyr)
+- Access to SmartBear products (BugSnag, Reflect, Swagger, QMetry, QTM4J or Zephyr)
 - Valid API tokens for the products you want to integrate
 
 ## Local MCP Server Installation (npm)
@@ -101,7 +102,9 @@ Alternatively, you can use `npx` (or globally install) the `@smartbear/mcp` pack
         "ZEPHYR_BASE_URL": "${input:zephyr_base_url}",
         "COLLABORATOR_BASE_URL": "${input:collab_base_url}",
         "COLLABORATOR_USERNAME": "${input:collab_username}",
-        "COLLABORATOR_LOGIN_TICKET": "${input:collab_login_ticket}"
+        "COLLABORATOR_LOGIN_TICKET": "${input:collab_login_ticket}",
+        "QTM4J_API_KEY": "${input:qtm4j_api_key}",
+        "QTM4J_BASE_URL": "${input:qtm4j_base_url}"
       }
     }
   },
@@ -213,7 +216,19 @@ Alternatively, you can use `npx` (or globally install) the `@smartbear/mcp` pack
           "type": "promptString",
           "description": "Collab login ticket",
           "password": true
-      }
+      },
+      {
+          "id": "qtm4j_api_key",
+          "type": "promptString",
+          "description": "QTM4J API Key",
+          "password": true
+    },
+    {
+          "id": "qtm4j_base_url",
+          "type": "promptString",
+          "description": "US region (default): https://qtmcloud.qmetry.com. Australia region: https://syd-qtmcloud.qmetry.com.",
+          "password": false
+    }
   ]
 }
 ```
@@ -250,7 +265,9 @@ Add the following configuration to your `claude_desktop_config.json` to launch t
         "ZEPHYR_BASE_URL": "https://api.zephyrscale.smartbear.com/v2",
         "COLLABORATOR_BASE_URL": "your collab base url",
         "COLLABORATOR_USERNAME": "your collab user name",
-        "COLLABORATOR_LOGIN_TICKET": "your collab login ticket"
+        "COLLABORATOR_LOGIN_TICKET": "your collab login ticket",
+        "QTM4J_API_KEY": "your_qtm4j_key",
+        "QTM4J_BASE_URL": "https://qtmcloud.qmetry.com"
       }
     }
   }

package/dist/common/register-clients.js

@@ -2,6 +2,7 @@ import { BugsnagClient } from "../bugsnag/client.js";
 import { CollaboratorClient } from "../collaborator/client.js";
 import { PactflowClient } from "../pactflow/client.js";
 import { QmetryClient } from "../qmetry/client.js";
+import { Qtm4jClient } from "../qtm4j/client.js";
 import { ReflectClient } from "../reflect/client.js";
 import { SwaggerClient } from "../swagger/client.js";
 import { ZephyrClient } from "../zephyr/client.js";
@@ -12,4 +13,5 @@ clientRegistry.register(new SwaggerClient());
 clientRegistry.register(new PactflowClient());
 clientRegistry.register(new QmetryClient());
 clientRegistry.register(new ZephyrClient());
+clientRegistry.register(new Qtm4jClient());
 clientRegistry.register(new CollaboratorClient());

package/dist/common/server.js

@@ -19,12 +19,9 @@ class SmartBearMcpServer extends McpServer {
       },
       {
         capabilities: {
+          // resources and prompts are supported by some but not all clients
           tools: { listChanged: true },
           // Server supports dynamic tool lists
-          resources: { listChanged: true },
-          // Server supports dynamic resource lists
-          prompts: { listChanged: true },
-          // Server supports sending prompts to Host
           logging: {}
           // Server supports logging messages
         }

package/dist/package.json.js

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

package/dist/qtm4j/client.js

@@ -0,0 +1,109 @@
+import zod__default from "zod";
+import { getRequestHeader } from "../common/request-context.js";
+import { CONFIG_KEYS, API_CONFIG, SCHEMA_DESCRIPTIONS, CLIENT_CONFIG, ERROR_MESSAGES } from "./config/constants.js";
+import { ApiClient } from "./http/api-client.js";
+import { ResolverRegistry } from "./resolver/resolver-registry.js";
+const ConfigurationSchema = zod__default.object({
+  [CONFIG_KEYS.API_KEY]: zod__default.string().describe(SCHEMA_DESCRIPTIONS.API_KEY),
+  [CONFIG_KEYS.BASE_URL]: zod__default.string().url().optional().default(API_CONFIG.DEFAULT_BASE_URL).describe(SCHEMA_DESCRIPTIONS.BASE_URL)
+});
+class Qtm4jClient {
+  name = CLIENT_CONFIG.NAME;
+  capabilityPrefix = CLIENT_CONFIG.TOOL_PREFIX;
+  configPrefix = CLIENT_CONFIG.CONFIG_PREFIX;
+  config = ConfigurationSchema;
+  _apiKey;
+  baseUrl = API_CONFIG.DEFAULT_BASE_URL;
+  apiClient;
+  resolverRegistry;
+  /**
+   * Configure the QTM4J client with API credentials
+   * @param server - MCP Server instance
+   * @param config - Configuration object containing API key and optional base URL
+   */
+  async configure(server, config) {
+    this._apiKey = config[CONFIG_KEYS.API_KEY];
+    if (config[CONFIG_KEYS.BASE_URL]) {
+      this.baseUrl = config[CONFIG_KEYS.BASE_URL];
+    }
+    this.apiClient = new ApiClient(() => this.getAuthToken(), this.baseUrl);
+    this.resolverRegistry = new ResolverRegistry(
+      this.apiClient,
+      server.getCache()
+    );
+  }
+  /**
+   * Get authentication token with request-scoped override support
+   * Checks request headers first, then falls back to configured API key
+   * @returns API key or null if not found
+   */
+  getAuthToken() {
+    const contextHeader = getRequestHeader("Qtm4j-Api-Key") || getRequestHeader("apiKey") || getRequestHeader("Authorization");
+    if (contextHeader) {
+      let token = Array.isArray(contextHeader) ? contextHeader[0] : contextHeader;
+      if (token.startsWith("Bearer ")) {
+        token = token.substring(7);
+      }
+      return token;
+    }
+    return this._apiKey || null;
+  }
+  /**
+   * Check if the client is properly configured
+   * @returns true if API key is set and client is ready
+   */
+  isConfigured() {
+    return this.apiClient !== void 0;
+  }
+  /**
+   * Get the configured API client instance
+   * @returns ApiClient instance
+   * @throws Error if client is not configured
+   */
+  getApiClient() {
+    if (!this.apiClient) {
+      throw new Error(ERROR_MESSAGES.CLIENT_NOT_CONFIGURED);
+    }
+    return this.apiClient;
+  }
+  getResolverRegistry() {
+    if (!this.resolverRegistry) {
+      throw new Error(ERROR_MESSAGES.CLIENT_NOT_CONFIGURED);
+    }
+    return this.resolverRegistry;
+  }
+  requireProjectContext() {
+    return this.getResolverRegistry().requireProjectContext();
+  }
+  /**
+   * Register all QTM4J tools with the MCP server
+   *
+   * This method creates tool instances and registers them with the MCP server.
+   * Each tool is prefixed with 'qtm4j_' (e.g., qtm4j_get_projects)
+   *
+   * @param register - Function to register tools with MCP server
+   * @param _getInput - Function to get user input (not used currently)
+   */
+  async registerTools(register, _getInput) {
+    const { GetProjects } = await import("./tool/project/get-projects.js");
+    const { SetProjectContext } = await import("./tool/project/set-project-context.js");
+    const { CreateTestCase } = await import("./tool/test-case/create-test-case.js");
+    const { GetTestCases } = await import("./tool/test-case/get-test-cases.js");
+    const { GetTestSteps } = await import("./tool/test-case/get-test-steps.js");
+    const { UpdateTestCase } = await import("./tool/test-case/update-test-case.js");
+    const tools = [
+      new GetProjects(this),
+      new SetProjectContext(this),
+      new CreateTestCase(this),
+      new GetTestCases(this),
+      new GetTestSteps(this),
+      new UpdateTestCase(this)
+    ];
+    for (const tool of tools) {
+      register(tool.specification, tool.handle);
+    }
+  }
+}
+export {
+  Qtm4jClient
+};

package/dist/qtm4j/config/constants.js

@@ -0,0 +1,169 @@
+const API_CONFIG = {
+  /** Default base URL for QTM4J Cloud */
+  DEFAULT_BASE_URL: "https://qtmcloud.qmetry.com",
+  /** API version prefix */
+  API_VERSION: "/rest/api/latest"
+};
+const ENDPOINTS = {
+  /** Projects endpoint */
+  PROJECTS: `${API_CONFIG.API_VERSION}/projects`,
+  /** Create test case endpoint */
+  CREATE_TEST_CASE: `${API_CONFIG.API_VERSION}/testcases`,
+  /** Search test cases endpoint */
+  SEARCH_TEST_CASES: `${API_CONFIG.API_VERSION}/testcases/search`,
+  /** Resolve test case keys → internal UIDs for a given project */
+  RESOLVE_TEST_CASE_IDS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/testcases/resolve-ids`,
+  /** Update test case endpoint */
+  UPDATE_TEST_CASE: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}`,
+  /** Test steps search endpoint */
+  TEST_STEPS: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}/teststeps/search`,
+  /** Common attributes endpoint (priority, statuses) */
+  COMMON_ATTRIBUTES: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/common-attributes`,
+  /** Labels search endpoint */
+  LABELS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/labels`,
+  /** Components search endpoint */
+  COMPONENTS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/components`
+};
+const HTTP_HEADERS = {
+  /** API key header name */
+  API_KEY: "apiKey",
+  /** Content type header */
+  CONTENT_TYPE: "Content-Type",
+  /** User agent header */
+  USER_AGENT: "User-Agent",
+  /** Accept header */
+  ACCEPT: "Accept",
+  /** Content length header */
+  CONTENT_LENGTH: "content-length"
+};
+const CONTENT_TYPES = {
+  /** JSON content type */
+  JSON: "application/json"
+};
+const HTTP_METHODS = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT"
+};
+const HTTP_STATUS = {
+  /** No content status code */
+  NO_CONTENT: 204
+};
+const CLIENT_CONFIG = {
+  /** Client name */
+  NAME: "QTM4J",
+  /** Tool prefix for all QTM4J tools */
+  TOOL_PREFIX: "qtm4j",
+  /** Configuration prefix */
+  CONFIG_PREFIX: "Qtm4j"
+};
+const PAGINATION = {
+  /** Default starting position for pagination */
+  DEFAULT_START_AT: 0,
+  /** Default maximum results for projects */
+  DEFAULT_MAX_RESULTS_PROJECTS: 100,
+  /** Default maximum results for test cases */
+  DEFAULT_MAX_RESULTS_TEST_CASES: 50,
+  /** Maximum allowed results per request */
+  MAX_ALLOWED_RESULTS: 100,
+  /** Maximum allowed results per request for test cases (backend enforced) */
+  MAX_ALLOWED_RESULTS_TEST_CASES: 50,
+  /** Default maximum results for test steps */
+  DEFAULT_MAX_RESULTS_TEST_STEPS: 50,
+  /** Maximum allowed results per request for test steps */
+  MAX_ALLOWED_RESULTS_TEST_STEPS: 100,
+  /** Minimum allowed results per request */
+  MIN_ALLOWED_RESULTS: 1
+};
+const ERROR_MESSAGES = {
+  /** Client not configured error */
+  CLIENT_NOT_CONFIGURED: "QTM4J client not configured. Please set API key.",
+  /** Request failed template */
+  REQUEST_FAILED: (status, errorText) => `Request failed with status ${status}: ${errorText}`
+};
+const TOOL_NAMES = {
+  /** Get Projects tool */
+  GET_PROJECTS: {
+    TITLE: "Get Projects",
+    SUMMARY: "Get all projects from QTM4J with optional filtering"
+  },
+  /** Set Project Context tool */
+  SET_PROJECT_CONTEXT: {
+    TITLE: "Set Project Context",
+    SUMMARY: "Set the active QTM4J project for the current session. Must be called before any project-specific operation. Pre-loads priority and status values so you can map user-provided names to valid options via NLP."
+  },
+  /** Create Test Case tool */
+  CREATE_TEST_CASE: {
+    TITLE: "Create Test Case",
+    SUMMARY: "Create a new test case in a QTM4J project. Supports auto-resolving human-readable names for priority, status, labels, and components."
+  },
+  /** Search Test Cases tool */
+  SEARCH_TEST_CASES: {
+    TITLE: "Search Test Cases",
+    SUMMARY: "Search and filter test cases in a QTM4J project with support for pagination, field selection, and sorting."
+  },
+  /** Get Test Steps tool */
+  GET_TEST_STEPS: {
+    TITLE: "Get Test Steps",
+    SUMMARY: "Get test steps for a test case by its key and version. Accepts the human-readable key (e.g. 'SCRUM-TC-145') and resolves it to the internal ID automatically."
+  },
+  /** Update Test Case tool */
+  UPDATE_TEST_CASE: {
+    TITLE: "Update Test Case",
+    SUMMARY: "Update an existing test case in QTM4J. Supports auto-resolving human-readable names for priority, status, labels, and components. Labels and components support add/delete operations."
+  }
+};
+const CONFIG_KEYS = {
+  /** API key configuration key */
+  API_KEY: "api_key",
+  /** Base URL configuration key */
+  BASE_URL: "base_url"
+};
+const SCHEMA_DESCRIPTIONS = {
+  /** API key description */
+  API_KEY: "QTM4J API key for authentication",
+  /** Base URL description */
+  BASE_URL: "QTM4J base URL (default: https://qtmcloud.qmetry.com). Can be customized for on-premise installations.",
+  /** Start at description */
+  START_AT: "Zero-indexed starting position for pagination",
+  /** Max results projects description */
+  MAX_RESULTS_PROJECTS: "Maximum number of results per page (1-100)",
+  /** Search text description */
+  SEARCH_TEXT: "Search text for project key or project name",
+  /** QMetry enabled description */
+  QMETRY_ENABLED: "Filter by QMetry enabled status",
+  /** Project object description */
+  PROJECT_OBJECT: "Project object"
+};
+const RESPONSE_FIELDS = {
+  /** Start at field */
+  START_AT: "startAt",
+  /** Max results field */
+  MAX_RESULTS: "maxResults",
+  FIELDS: "fields",
+  SORT: "sort"
+};
+const EMPTY_VALUES = {
+  /** Empty object */
+  OBJECT: {},
+  /** Empty string */
+  STRING: "",
+  /** Zero value */
+  ZERO: 0
+};
+export {
+  API_CONFIG,
+  CLIENT_CONFIG,
+  CONFIG_KEYS,
+  CONTENT_TYPES,
+  EMPTY_VALUES,
+  ENDPOINTS,
+  ERROR_MESSAGES,
+  HTTP_HEADERS,
+  HTTP_METHODS,
+  HTTP_STATUS,
+  PAGINATION,
+  RESPONSE_FIELDS,
+  SCHEMA_DESCRIPTIONS,
+  TOOL_NAMES
+};

package/dist/qtm4j/config/field-resolution.types.js

@@ -0,0 +1,34 @@
+const ResolverKeys = {
+  /**
+   * Fields fetched from the common-attributes API (batch-loaded on project context set).
+   * Values are cached per project and eagerly available for tools.
+   */
+  CommonAttribute: {
+    TESTCASE_STATUS: "testcase_status",
+    TEST_PLAN_STATUS: "testplan_status",
+    TEST_CYCLE_STATUS: "testcycle_status",
+    PRIORITY: "priority",
+    TESTCASE_FOLDER: "testcase_folder"
+  },
+  /**
+   * Fields with dedicated search APIs (fetched on-demand, not batch-loaded).
+   * Resolved lazily when tools reference them — no eager preloading.
+   */
+  SearchableField: {
+    LABEL: "label",
+    COMPONENTS: "components",
+    TEST_CASE_KEY_TO_UID: "testCaseKeyToUid"
+  }
+};
+var InputField = /* @__PURE__ */ ((InputField2) => {
+  InputField2["PRIORITY"] = "priority";
+  InputField2["STATUS"] = "status";
+  InputField2["COMPONENTS"] = "components";
+  InputField2["LABELS"] = "labels";
+  InputField2["FOLDER"] = "folderId";
+  return InputField2;
+})(InputField || {});
+export {
+  InputField,
+  ResolverKeys
+};

package/dist/qtm4j/http/api-client.js

@@ -0,0 +1,123 @@
+import { ToolError } from "../../common/tools.js";
+import { EMPTY_VALUES, ERROR_MESSAGES, HTTP_METHODS, CONTENT_TYPES, HTTP_HEADERS, HTTP_STATUS } from "../config/constants.js";
+import { AuthService } from "./auth-service.js";
+class ApiClient {
+  baseUrl;
+  tokenProvider;
+  constructor(tokenOrProvider, baseUrl) {
+    this.baseUrl = baseUrl.trim().replace(/\/$/, EMPTY_VALUES.STRING);
+    if (typeof tokenOrProvider === "string") {
+      this.tokenProvider = () => tokenOrProvider;
+    } else {
+      this.tokenProvider = tokenOrProvider;
+    }
+  }
+  /**
+   * Get authentication headers for current request
+   * Calls token provider to support request-scoped credentials
+   * @returns Record of HTTP headers including API key
+   * @throws ToolError if token is not available
+   */
+  getHeaders() {
+    const token = this.tokenProvider();
+    if (!token) {
+      throw new ToolError(ERROR_MESSAGES.CLIENT_NOT_CONFIGURED);
+    }
+    return new AuthService(token).getAuthHeaders();
+  }
+  /**
+   * Construct full URL with query parameters
+   * @param endpoint - API endpoint path
+   * @param params - Optional query parameters
+   * @returns Complete URL string
+   */
+  getUrl(endpoint, params) {
+    const url = new URL(this.baseUrl + endpoint);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    return url.toString();
+  }
+  /**
+   * Perform GET request
+   * @param endpoint - API endpoint path
+   * @param params - Optional query parameters
+   * @returns Parsed response data
+   */
+  async get(endpoint, params) {
+    const response = await fetch(this.getUrl(endpoint, params), {
+      method: HTTP_METHODS.GET,
+      headers: this.getHeaders()
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Perform POST request
+   * @param endpoint - API endpoint path
+   * @param body - Request body object
+   * @returns Parsed response data
+   */
+  async post(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: HTTP_METHODS.POST,
+      headers: {
+        ...this.getHeaders(),
+        [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON
+      },
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Perform PUT request
+   * @param endpoint - API endpoint path
+   * @param body - Request body object
+   * @returns Parsed response data
+   */
+  async put(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: HTTP_METHODS.PUT,
+      headers: {
+        ...this.getHeaders(),
+        [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON
+      },
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Validate HTTP response and extract body
+   * Handles various response types: JSON, text, empty responses
+   * @param response - HTTP response object
+   * @returns Parsed response data or error
+   * @throws ToolError if request fails
+   */
+  async validateAndGetResponseBody(response) {
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ToolError(
+        ERROR_MESSAGES.REQUEST_FAILED(response.status, errorText)
+      );
+    }
+    const contentLength = response.headers.get(HTTP_HEADERS.CONTENT_LENGTH);
+    if (response.status === HTTP_STATUS.NO_CONTENT || contentLength === String(EMPTY_VALUES.ZERO)) {
+      return EMPTY_VALUES.OBJECT;
+    }
+    const text = await response.text();
+    if (!text?.trim()) {
+      return EMPTY_VALUES.OBJECT;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { data: text };
+    }
+  }
+}
+export {
+  ApiClient
+};

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

@@ -0,0 +1,23 @@
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../../common/info.js";
+import { CONTENT_TYPES, HTTP_HEADERS } from "../config/constants.js";
+class AuthService {
+  apiKey;
+  constructor(apiKey) {
+    this.apiKey = apiKey.trim();
+  }
+  /**
+   * Get authentication headers for QTM4J API requests
+   * @returns Record of HTTP headers including API key authorization
+   */
+  getAuthHeaders() {
+    return {
+      [HTTP_HEADERS.API_KEY]: this.apiKey,
+      [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON,
+      [HTTP_HEADERS.USER_AGENT]: `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+      [HTTP_HEADERS.ACCEPT]: CONTENT_TYPES.JSON
+    };
+  }
+}
+export {
+  AuthService
+};

package/dist/qtm4j/resolver/cache/cache.js

@@ -0,0 +1,52 @@
+class Cache {
+  trackedKeys = /* @__PURE__ */ new Map();
+  cacheService;
+  constructor(cacheService) {
+    this.cacheService = cacheService;
+  }
+  compositeKey(projectKey, fieldKey) {
+    return `qtm4j:${projectKey}:${fieldKey}`;
+  }
+  get(projectKey, fieldKey) {
+    return this.cacheService.get(
+      this.compositeKey(projectKey, fieldKey)
+    );
+  }
+  set(projectKey, fieldKey, values) {
+    const key = this.compositeKey(projectKey, fieldKey);
+    const existing = this.cacheService.get(key) ?? {};
+    this.cacheService.set(key, { ...existing, ...values });
+    if (!this.trackedKeys.has(projectKey)) {
+      this.trackedKeys.set(projectKey, /* @__PURE__ */ new Set());
+    }
+    this.trackedKeys.get(projectKey).add(key);
+  }
+  has(projectKey, fieldKey) {
+    return this.cacheService.get(this.compositeKey(projectKey, fieldKey)) !== void 0;
+  }
+  clear(projectKey) {
+    if (projectKey) {
+      const keys = this.trackedKeys.get(projectKey);
+      if (keys) {
+        for (const key of keys) {
+          this.cacheService.del(key);
+        }
+        this.trackedKeys.delete(projectKey);
+      }
+    } else {
+      for (const keys of this.trackedKeys.values()) {
+        for (const key of keys) {
+          this.cacheService.del(key);
+        }
+      }
+      this.trackedKeys.clear();
+    }
+  }
+  /** Case-insensitive lookup of a name within a cached field. */
+  matchValue(projectKey, fieldKey, name) {
+    return this.get(projectKey, fieldKey)?.[name.toLowerCase()];
+  }
+}
+export {
+  Cache
+};