@smartbear/mcp 0.23.0 → 0.25.0

package/dist/qtm4j/config/constants.js

@@ -13,8 +13,41 @@ const ENDPOINTS = {
   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 cycle endpoint */
+  UPDATE_TEST_CYCLE: (id) => `${API_CONFIG.API_VERSION}/testcycles/${id}`,
+  /** Create test cycle endpoint */
+  CREATE_TEST_CYCLE: `${API_CONFIG.API_VERSION}/testcycles`,
+  /** Search test cycles endpoint */
+  SEARCH_TEST_CYCLES: `${API_CONFIG.API_VERSION}/testcycles/search`,
   /** Update test case endpoint */
   UPDATE_TEST_CASE: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}`,
+  RESOLVE_TEST_CYCLE_IDS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/testcycles/resolve-ids`,
+  /** Resolve requirement keys → internal Jira issue IDs for a given project */
+  RESOLVE_REQUIREMENT_IDS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/requirement/resolve-ids`,
+  /** Link requirements to test case endpoint */
+  LINK_REQUIREMENTS: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/version/${versionNo}/requirements/link`,
+  /** Unlink requirements from test case endpoint */
+  UNLINK_REQUIREMENTS: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}/requirements/unlink`,
+  /** Link test cases to requirement endpoint */
+  LINK_TESTCASES_TO_REQUIREMENT: (requirementId) => `${API_CONFIG.API_VERSION}/requirements/${requirementId}/testcases/link`,
+  /** Unlink test cases from requirement endpoint */
+  UNLINK_TESTCASES_FROM_REQUIREMENT: (requirementId) => `${API_CONFIG.API_VERSION}/requirements/${requirementId}/testcases/unlink`,
+  /** Get linked requirements for a test case endpoint */
+  GET_LINKED_REQUIREMENTS: (id) => `${API_CONFIG.API_VERSION}/testcases/${id}/requirements`,
+  /** Get linked test cases for a requirement endpoint */
+  GET_LINKED_TESTCASES_FOR_REQUIREMENT: (requirementId) => `${API_CONFIG.API_VERSION}/requirements/${requirementId}/testcases`,
+  /** Link test cases to test cycle endpoint */
+  LINK_TESTCASES_TO_CYCLE: (cycleId) => `${API_CONFIG.API_VERSION}/testcycles/${cycleId}/testcases`,
+  /** Unlink test cases from test cycle endpoint */
+  UNLINK_TESTCASES_FROM_CYCLE: (cycleId) => `${API_CONFIG.API_VERSION}/testcycles/${cycleId}/testcases`,
+  /** Search test cases linked to a test cycle endpoint */
+  SEARCH_LINKED_TESTCASES_IN_CYCLE: (cycleId) => `${API_CONFIG.API_VERSION}/testcycles/${cycleId}/testcases/search`,
+  /** Get linked requirements for a test cycle endpoint */
+  GET_LINKED_REQUIREMENTS_FOR_CYCLE: (cycleId) => `${API_CONFIG.API_VERSION}/testcycles/${cycleId}/requirements`,
+  /** Link requirements to test cycle endpoint */
+  LINK_REQUIREMENTS_TO_CYCLE: (cycleId) => `${API_CONFIG.API_VERSION}/testcycles/${cycleId}/requirements/link`,
+  /** Unlink requirements from test cycle endpoint */
+  UNLINK_REQUIREMENTS_FROM_CYCLE: (cycleId) => `${API_CONFIG.API_VERSION}/testcycles/${cycleId}/requirements/unlink`,
   /** Test steps search endpoint */
   TEST_STEPS: (id, versionNo) => `${API_CONFIG.API_VERSION}/testcases/${id}/versions/${versionNo}/teststeps/search`,
   /** Common attributes endpoint (priority, statuses) */
@@ -22,7 +55,13 @@ const ENDPOINTS = {
   /** 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`
+  COMPONENTS: (projectId) => `${API_CONFIG.API_VERSION}/projects/${projectId}/mcp/components`,
+  /** Automation: initiate result file import — returns pre-signed S3 upload URL + trackingId */
+  AUTOMATION_IMPORT: "/rest/api/automation/importresult",
+  /** Automation: poll import progress by trackingId */
+  AUTOMATION_IMPORT_TRACK: "/rest/api/automation/importresult/track",
+  /** Automation: paginated history of past automation result uploads */
+  AUTOMATION_HISTORY: "/rest/api/automation/importresult/history"
 };
 const HTTP_HEADERS = {
   /** API key header name */
@@ -38,12 +77,15 @@ const HTTP_HEADERS = {
 };
 const CONTENT_TYPES = {
   /** JSON content type */
-  JSON: "application/json"
+  JSON: "application/json",
+  /** Multipart form-data content type (used for S3 automation file uploads) */
+  MULTIPART: "multipart/form-data"
 };
 const HTTP_METHODS = {
   GET: "GET",
   POST: "POST",
-  PUT: "PUT"
+  PUT: "PUT",
+  DELETE: "DELETE"
 };
 const HTTP_STATUS = {
   /** No content status code */
@@ -72,14 +114,24 @@ const PAGINATION = {
   DEFAULT_MAX_RESULTS_TEST_STEPS: 50,
   /** Maximum allowed results per request for test steps */
   MAX_ALLOWED_RESULTS_TEST_STEPS: 100,
+  /** Default maximum results for test cycles */
+  DEFAULT_MAX_RESULTS_TEST_CYCLES: 20,
+  /** Maximum allowed results per request for test cycles */
+  MAX_ALLOWED_RESULTS_TEST_CYCLES: 100,
   /** Minimum allowed results per request */
   MIN_ALLOWED_RESULTS: 1
 };
+const AUTOMATION_LIMITS = {
+  /** Maximum allowed upload file size in bytes (10 MB) */
+  MAX_FILE_SIZE_BYTES: 10 * 1024 * 1024
+};
 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}`
+  REQUEST_FAILED: (status, errorText) => `Request failed with status ${status}: ${errorText}`,
+  /** Automation API key not configured */
+  AUTOMATION_API_KEY_NOT_CONFIGURED: "QTM4J Automation API key not configured. Set the QTM4J_AUTOMATION_API_KEY environment variable or pass the Qtm4j-Automation-Api-Key header."
 };
 const TOOL_NAMES = {
   /** Get Projects tool */
@@ -111,17 +163,117 @@ const TOOL_NAMES = {
   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."
+  },
+  /** Upload Automation Result tool */
+  UPLOAD_AUTOMATION_RESULT: {
+    TITLE: "Upload Automation Result",
+    SUMMARY: "Upload an automation result file to QTM4J and map the results to a test cycle. Supports JUnit XML, TestNG XML, Cucumber JSON, QAF, HP UFT, and SpecFlow formats."
+  },
+  /** Get Automation History tool */
+  GET_AUTOMATION_HISTORY: {
+    TITLE: "Get Automation History",
+    SUMMARY: "Retrieve a paginated history of past automation result uploads for a QTM4J project."
+  },
+  /** Search Test Cycles tool */
+  SEARCH_TEST_CYCLES: {
+    TITLE: "Search Test Cycles",
+    SUMMARY: "Search for test cycles in a QTM4J project by status, owner, folder, date range, or keyword. projectId is injected automatically from the active project context."
+  },
+  /** Create Test Cycle tool */
+  CREATE_TEST_CYCLE: {
+    TITLE: "Create Test Cycle",
+    SUMMARY: "Create a new test cycle in a QTM4J project. Supports auto-resolving human-readable names for priority and status. Always creates in the 'MCP Generated' folder. projectId is injected automatically from the active project context."
+  },
+  /** Update Test Cycle tool */
+  UPDATE_TEST_CYCLE: {
+    TITLE: "Update Test Cycle",
+    SUMMARY: "Update an existing test cycle in QTM4J by its human-readable key (e.g. 'SCRUM-TR-101'). Supports auto-resolving human-readable names for status and priority. Labels and components support add/delete operations. Only the fields you provide are changed — omitted fields are left as-is. projectId is injected automatically from the active project context."
+  },
+  /** Link Requirements tool */
+  LINK_REQUIREMENTS: {
+    TITLE: "Link Requirements to Test Case",
+    SUMMARY: "Link one or more Jira requirements to a test case in QTM4J by requirement keys or JQL filter. Requirement keys are resolved to internal IDs automatically."
+  },
+  /** Unlink Requirements tool */
+  UNLINK_REQUIREMENTS: {
+    TITLE: "Unlink Requirements from Test Case",
+    SUMMARY: "Unlink one or more Jira requirements from a test case in QTM4J by requirement keys, or unlink all requirements at once with unLinkAll."
+  },
+  /** Link Test Cases to Requirement tool */
+  LINK_TESTCASES_TO_REQUIREMENT: {
+    TITLE: "Link Test Cases to Requirement",
+    SUMMARY: "Link test cases to a Jira requirement in QTM4J by test case keys or filter criteria. Test case keys are resolved to internal IDs automatically."
+  },
+  /** Unlink Test Cases from Requirement tool */
+  UNLINK_TESTCASES_FROM_REQUIREMENT: {
+    TITLE: "Unlink Test Cases from Requirement",
+    SUMMARY: "Unlink test cases from a Jira requirement in QTM4J by test case keys or filter criteria. Test case keys are resolved to internal IDs automatically."
+  },
+  /** Get Linked Requirements tool */
+  GET_LINKED_REQUIREMENTS: {
+    TITLE: "Get Linked Requirements",
+    SUMMARY: "Retrieve the Jira requirements linked to a specific test case in QTM4J. Test case key is resolved to internal ID automatically."
+  },
+  /** Get Linked Test Cases for Requirement tool */
+  GET_LINKED_TESTCASES_FOR_REQUIREMENT: {
+    TITLE: "Get Linked Test Cases for Requirement",
+    SUMMARY: "Retrieve the test cases linked to a Jira requirement in QTM4J. Requirement key is resolved to internal ID automatically."
+  },
+  /** Link Test Cases to Test Cycle tool */
+  LINK_TESTCASES_TO_CYCLE: {
+    TITLE: "Link Test Cases to Test Cycle",
+    SUMMARY: "Link test cases to a QTM4J test cycle by test case keys or filter criteria. Test case keys are resolved to internal IDs and latest versions automatically."
+  },
+  /** Unlink Test Cases from Test Cycle tool */
+  UNLINK_TESTCASES_FROM_CYCLE: {
+    TITLE: "Unlink Test Cases from Test Cycle",
+    SUMMARY: "Unlink test cases from a QTM4J test cycle by test case keys, filter criteria, or all at once with unlinkAll."
+  },
+  /** Search Linked Test Cases in Test Cycle tool */
+  SEARCH_LINKED_TESTCASES_IN_CYCLE: {
+    TITLE: "Search Linked Test Cases in Test Cycle",
+    SUMMARY: "Search and filter test case executions linked to a QTM4J test cycle. Supports pagination, field selection, sorting, and rich filter criteria."
+  },
+  /** Get Linked Requirements for Test Cycle tool */
+  GET_LINKED_REQUIREMENTS_FOR_CYCLE: {
+    TITLE: "Get Linked Requirements for Test Cycle",
+    SUMMARY: "Retrieve Jira requirements linked to a QTM4J test cycle. Test cycle key is resolved to internal UID automatically."
+  },
+  /** Link Requirements to Test Cycle tool */
+  LINK_REQUIREMENTS_TO_CYCLE: {
+    TITLE: "Link Requirements to Test Cycle",
+    SUMMARY: "Link one or more Jira requirements to a QTM4J test cycle by requirement keys or JQL filter. Requirement keys are resolved to internal IDs automatically."
+  },
+  /** Unlink Requirements from Test Cycle tool */
+  UNLINK_REQUIREMENTS_FROM_CYCLE: {
+    TITLE: "Unlink Requirements from Test Cycle",
+    SUMMARY: "Unlink one or more Jira requirements from a QTM4J test cycle by requirement keys, or unlink all requirements at once with unLinkAll."
   }
 };
+const TOOLSETS = {
+  /** Test Automation toolset */
+  TEST_AUTOMATION: "Test Automation",
+  /** Test Cases toolset */
+  TEST_CASES: "Test Cases",
+  /** Test Cycle Management toolset */
+  TEST_CYCLES: "Test Cycles",
+  /** Projects toolset */
+  PROJECTS: "Projects",
+  REQUIREMENTS: "Requirements"
+};
 const CONFIG_KEYS = {
   /** API key configuration key */
   API_KEY: "api_key",
+  /** Automation API key configuration key */
+  AUTOMATION_API_KEY: "automation_api_key",
   /** Base URL configuration key */
   BASE_URL: "base_url"
 };
 const SCHEMA_DESCRIPTIONS = {
   /** API key description */
   API_KEY: "QTM4J API key for authentication",
+  /** Automation API key description */
+  AUTOMATION_API_KEY: "QTM4J Automation API key for uploading automation result files. This is a separate key from the regular API key and can be found in QTM4J under Automation settings.",
   /** Base URL description */
   BASE_URL: "QTM4J base URL (default: https://qtmcloud.qmetry.com). Can be customized for on-premise installations.",
   /** Start at description */
@@ -133,8 +285,40 @@ const SCHEMA_DESCRIPTIONS = {
   /** QMetry enabled description */
   QMETRY_ENABLED: "Filter by QMetry enabled status",
   /** Project object description */
-  PROJECT_OBJECT: "Project object"
+  PROJECT_OBJECT: "Project object",
+  /** Automation result file path */
+  AUTOMATION_FILE_PATH: "Path to the automation result file on disk. Filesystem contents can change between turns — always resolve this from a fresh scan, never from a previously seen path. Supported extensions: .xml, .json, .zip",
+  /** Automation result format */
+  AUTOMATION_FORMAT: "Format of the result file. Supported values: cucumber, testng, junit, qaf, hpuft, specflow",
+  /** Test cycle to reuse */
+  AUTOMATION_TEST_CYCLE_TO_REUSE: "Work key of an existing test cycle to reuse (e.g. 'TR-PRJ-1'). If omitted, a new test cycle is created.",
+  /** Automation environment */
+  AUTOMATION_ENVIRONMENT: "Name of the environment on which the test cycle was executed (e.g. 'Chrome', 'Staging'). Defaults to 'No Environment'.",
+  /** Automation build */
+  AUTOMATION_BUILD: "Build name or version for the test cycle execution (e.g. '1.0.0-beta'). Defaults to blank.",
+  /** isZip flag */
+  AUTOMATION_IS_ZIP: "Set to true when uploading a ZIP archive containing result files. Required for QAF format.",
+  /** attachFile flag */
+  AUTOMATION_ATTACH_FILE: "Set to true to upload attachments referenced in execution results.",
+  /** matchTestSteps flag */
+  AUTOMATION_MATCH_TEST_STEPS: "true — match test cases by summary AND test steps. false — match by summary or key only.",
+  /** appendTestName flag */
+  AUTOMATION_APPEND_TEST_NAME: "Applicable to JUnit/TestNG only. Appends suite/test name to method name in test case summary.",
+  /** fields object */
+  AUTOMATION_FIELDS: "Additional fields to set on the test cycle, test case, and/or test case execution created during import.",
+  /** getAutomationHistory — pagination */
+  AUTOMATION_HISTORY_START_AT: "Zero-indexed starting position for pagination (default: 0).",
+  AUTOMATION_HISTORY_MAX_RESULTS: "Maximum number of records to return per page (default: 20, max: 100)."
 };
+const AUTOMATION_RESULT_DIRS = [
+  "target/surefire-reports",
+  "target/failsafe-reports",
+  "build/reports/tests",
+  "build/test-results",
+  "test-results",
+  "reports",
+  "cucumber-reports"
+];
 const RESPONSE_FIELDS = {
   /** Start at field */
   START_AT: "startAt",
@@ -143,6 +327,10 @@ const RESPONSE_FIELDS = {
   FIELDS: "fields",
   SORT: "sort"
 };
+const SORT_DEFAULTS = {
+  /** Default sort expression for test cycle search */
+  TEST_CYCLES: "key:asc"
+};
 const EMPTY_VALUES = {
   /** Empty object */
   OBJECT: {},
@@ -153,6 +341,8 @@ const EMPTY_VALUES = {
 };
 export {
   API_CONFIG,
+  AUTOMATION_LIMITS,
+  AUTOMATION_RESULT_DIRS,
   CLIENT_CONFIG,
   CONFIG_KEYS,
   CONTENT_TYPES,
@@ -165,5 +355,7 @@ export {
   PAGINATION,
   RESPONSE_FIELDS,
   SCHEMA_DESCRIPTIONS,
+  SORT_DEFAULTS,
+  TOOLSETS,
   TOOL_NAMES
 };

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

@@ -8,7 +8,8 @@ const ResolverKeys = {
     TEST_PLAN_STATUS: "testplan_status",
     TEST_CYCLE_STATUS: "testcycle_status",
     PRIORITY: "priority",
-    TESTCASE_FOLDER: "testcase_folder"
+    TESTCASE_FOLDER: "testcase_folder",
+    TEST_CYCLE_FOLDER: "testcycle_folder"
   },
   /**
    * Fields with dedicated search APIs (fetched on-demand, not batch-loaded).
@@ -17,7 +18,9 @@ const ResolverKeys = {
   SearchableField: {
     LABEL: "label",
     COMPONENTS: "components",
-    TEST_CASE_KEY_TO_UID: "testCaseKeyToUid"
+    TEST_CASE_KEY_TO_UID: "testCaseKeyToUid",
+    TEST_CYCLE_KEY_TO_UID: "testCycleKeyToUid",
+    REQUIREMENT_KEY_TO_ID: "requirementKeyToId"
   }
 };
 var InputField = /* @__PURE__ */ ((InputField2) => {

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

@@ -4,13 +4,15 @@ import { AuthService } from "./auth-service.js";
 class ApiClient {
   baseUrl;
   tokenProvider;
-  constructor(tokenOrProvider, baseUrl) {
+  automationTokenProvider;
+  constructor(tokenOrProvider, baseUrl, automationTokenProvider) {
     this.baseUrl = baseUrl.trim().replace(/\/$/, EMPTY_VALUES.STRING);
     if (typeof tokenOrProvider === "string") {
       this.tokenProvider = () => tokenOrProvider;
     } else {
       this.tokenProvider = tokenOrProvider;
     }
+    this.automationTokenProvider = automationTokenProvider;
   }
   /**
    * Get authentication headers for current request
@@ -25,6 +27,17 @@ class ApiClient {
     }
     return new AuthService(token).getAuthHeaders();
   }
+  /**
+   * Get authentication headers using the automation API key.
+   * @throws ToolError if automation API key is not configured
+   */
+  getAutomationHeaders() {
+    const token = this.automationTokenProvider?.();
+    if (!token) {
+      throw new ToolError(ERROR_MESSAGES.AUTOMATION_API_KEY_NOT_CONFIGURED);
+    }
+    return new AuthService(token).getAuthHeaders();
+  }
   /**
    * Construct full URL with query parameters
    * @param endpoint - API endpoint path
@@ -59,10 +72,11 @@ class ApiClient {
    * Perform POST request
    * @param endpoint - API endpoint path
    * @param body - Request body object
+   * @param params - Optional query parameters
    * @returns Parsed response data
    */
-  async post(endpoint, body) {
-    const response = await fetch(this.getUrl(endpoint), {
+  async post(endpoint, body, params) {
+    const response = await fetch(this.getUrl(endpoint, params), {
       method: HTTP_METHODS.POST,
       headers: {
         ...this.getHeaders(),
@@ -89,6 +103,79 @@ class ApiClient {
     });
     return await this.validateAndGetResponseBody(response);
   }
+  /**
+   * Perform GET request using the automation API key (QTM4J_AUTOMATION_API_KEY).
+   * Used for automation endpoints that require the automation key instead of the regular API key.
+   * @param endpoint - API endpoint path
+   * @param params - Optional query parameters
+   * @returns Parsed response data
+   */
+  async getAutomation(endpoint, params) {
+    const response = await fetch(this.getUrl(endpoint, params), {
+      method: HTTP_METHODS.GET,
+      headers: this.getAutomationHeaders()
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Perform POST request using the automation API key (QTM4J_AUTOMATION_API_KEY).
+   * Used for automation import endpoints — same apiKey header as all other APIs,
+   * but the value is the automation key instead of the regular API key.
+   * @param endpoint - API endpoint path
+   * @param body - Request body object
+   * @returns Parsed response data
+   */
+  async postAutomation(endpoint, body) {
+    const url = this.getUrl(endpoint);
+    const requestHeaders = {
+      ...this.getAutomationHeaders(),
+      [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON
+    };
+    const response = await fetch(url, {
+      method: HTTP_METHODS.POST,
+      headers: requestHeaders,
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Perform DELETE request with optional body
+   * @param endpoint - API endpoint path
+   * @param body - Optional request body object
+   * @returns Parsed response data
+   */
+  async delete(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: HTTP_METHODS.DELETE,
+      headers: {
+        ...this.getHeaders(),
+        [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.JSON
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  /**
+   * Upload a file as multipart/form-data using the automation API key.
+   * Content-Type is not set manually — fetch sets it with the correct multipart boundary.
+   * @param uploadUrl - Full URL returned by the automation import initiation step
+   * @param fileBuffer - Raw file contents as a Buffer
+   */
+  async uploadFileMultipart(uploadUrl, fileBuffer) {
+    const response = await fetch(uploadUrl, {
+      method: HTTP_METHODS.PUT,
+      headers: {
+        [HTTP_HEADERS.CONTENT_TYPE]: CONTENT_TYPES.MULTIPART
+      },
+      body: new Uint8Array(fileBuffer)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new ToolError(
+        ERROR_MESSAGES.REQUEST_FAILED(response.status, errorText)
+      );
+    }
+  }
   /**
    * Validate HTTP response and extract body
    * Handles various response types: JSON, text, empty responses

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

@@ -19,7 +19,7 @@ class Cache {
     if (!this.trackedKeys.has(projectKey)) {
       this.trackedKeys.set(projectKey, /* @__PURE__ */ new Set());
     }
-    this.trackedKeys.get(projectKey).add(key);
+    this.trackedKeys.get(projectKey)?.add(key);
   }
   has(projectKey, fieldKey) {
     return this.cacheService.get(this.compositeKey(projectKey, fieldKey)) !== void 0;

package/dist/qtm4j/resolver/resolver-registry.js

@@ -1,7 +1,9 @@
 import { CommonAttributeResolver } from "./resolvers/common-attribute-resolver.js";
 import { ComponentResolver } from "./resolvers/component-resolver.js";
 import { LabelResolver } from "./resolvers/label-resolver.js";
+import { RequirementIdResolver } from "./resolvers/requirement-id-resolver.js";
 import { TestCaseUidResolver } from "./resolvers/test-case-uid-resolver.js";
+import { TestCycleUidResolver } from "./resolvers/test-cycle-uid-resolver.js";
 const ERROR_NO_PROJECT_CONTEXT = "No active project set. Please call set_project_context before performing this operation.";
 class ResolverRegistry {
   resolverByKey;
@@ -16,12 +18,16 @@ class ResolverRegistry {
     this.testCaseUidResolver = new TestCaseUidResolver(apiClient);
     const labelResolver = new LabelResolver(apiClient, cacheService);
     const componentResolver = new ComponentResolver(apiClient, cacheService);
+    const requirementIdResolver = new RequirementIdResolver(apiClient);
+    const testcycleUidResolver = new TestCycleUidResolver(apiClient);
     this.resolverByKey = /* @__PURE__ */ new Map();
     for (const resolver of [
       this.commonAttributes,
       labelResolver,
       componentResolver,
-      this.testCaseUidResolver
+      this.testCaseUidResolver,
+      requirementIdResolver,
+      testcycleUidResolver
     ]) {
       for (const key of resolver.fieldKeys) {
         this.resolverByKey.set(key, resolver);

package/dist/qtm4j/resolver/resolvers/common-attribute-resolver.js

@@ -26,6 +26,7 @@ class CommonAttributeResolver extends Resolver {
     if (id !== void 0) {
       body[inputField] = Number(id);
     } else {
+      delete body[inputField];
       warnings.push(
         `Skipped ${inputField} '${name}' — not available in the current project.`
       );

package/dist/qtm4j/resolver/resolvers/component-resolver.js

@@ -36,6 +36,8 @@ class ComponentResolver extends Resolver {
     }
     if (ids.length > 0) {
       body[inputField] = isArray ? ids : ids[0];
+    } else {
+      delete body[inputField];
     }
   }
   async resolveAndReturn(projectKey, projectId, resolverKey, name) {

package/dist/qtm4j/resolver/resolvers/label-resolver.js

@@ -36,6 +36,8 @@ class LabelResolver extends Resolver {
     }
     if (ids.length > 0) {
       body[inputField] = isArray ? ids : ids[0];
+    } else {
+      delete body[inputField];
     }
   }
   async resolveAndReturn(projectKey, projectId, resolverKey, name) {

package/dist/qtm4j/resolver/resolvers/requirement-id-resolver.js

@@ -0,0 +1,28 @@
+import { ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { Resolver } from "./resolver.js";
+class RequirementIdResolver extends Resolver {
+  fieldKeys = [
+    ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID
+  ];
+  apiClient;
+  constructor(apiClient) {
+    super();
+    this.apiClient = apiClient;
+  }
+  async resolve(_inputField, _resolverKey, _body, _context, _warnings) {
+  }
+  async resolveAndReturn(projectId, keys) {
+    if (keys.length === 0) return {};
+    const response = await this.apiClient.get(
+      ENDPOINTS.RESOLVE_REQUIREMENT_IDS(projectId),
+      { keys: keys.join(",") }
+    );
+    return response;
+  }
+  clearCache(_projectKey) {
+  }
+}
+export {
+  RequirementIdResolver
+};

package/dist/qtm4j/resolver/resolvers/test-cycle-uid-resolver.js

@@ -0,0 +1,28 @@
+import { ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { Resolver } from "./resolver.js";
+class TestCycleUidResolver extends Resolver {
+  fieldKeys = [
+    ResolverKeys.SearchableField.TEST_CYCLE_KEY_TO_UID
+  ];
+  apiClient;
+  constructor(apiClient) {
+    super();
+    this.apiClient = apiClient;
+  }
+  async resolve(_inputField, _resolverKey, _body, _context, _warnings) {
+  }
+  async resolveAndReturn(projectId, keys) {
+    if (keys.length === 0) return {};
+    const response = await this.apiClient.get(
+      ENDPOINTS.RESOLVE_TEST_CYCLE_IDS(projectId),
+      { keys: keys.join(",") }
+    );
+    return response;
+  }
+  clearCache(_projectKey) {
+  }
+}
+export {
+  TestCycleUidResolver
+};

package/dist/qtm4j/schema/automation.schema.js

@@ -0,0 +1,107 @@
+import zod__default from "zod";
+import { SCHEMA_DESCRIPTIONS } from "../config/constants.js";
+const TestCycleFields = zod__default.object({
+  labels: zod__default.array(zod__default.string()).nullable().optional(),
+  components: zod__default.array(zod__default.string()).nullable().optional(),
+  priority: zod__default.string().nullable().optional(),
+  status: zod__default.string().nullable().optional(),
+  summary: zod__default.string().nullable().optional(),
+  description: zod__default.string().nullable().optional(),
+  assignee: zod__default.string().nullable().optional().describe(
+    "Jira Account ID of the assignee. Ask the user to provide their Account ID directly."
+  ),
+  reporter: zod__default.string().nullable().optional().describe(
+    "Jira Account ID of the reporter. Ask the user to provide their Account ID directly."
+  ),
+  folderId: zod__default.number().int().nullable().optional().describe(
+    "Numeric folder ID to place the test cycle in. Right-click a folder in QTM4J and select 'Copy Folder Id' to get this value."
+  ),
+  plannedStartDate: zod__default.string().nullable().optional().describe("Date in 'dd/MMM/yyyy HH:mm' format, e.g. '14/May/2026 10:30'"),
+  plannedEndDate: zod__default.string().nullable().optional().describe("Date in 'dd/MMM/yyyy HH:mm' format, e.g. '14/May/2026 10:30'")
+}).nullable().optional();
+const TestCaseFields = zod__default.object({
+  labels: zod__default.array(zod__default.string()).nullable().optional(),
+  components: zod__default.array(zod__default.string()).nullable().optional(),
+  priority: zod__default.string().nullable().optional(),
+  status: zod__default.string().nullable().optional(),
+  description: zod__default.string().nullable().optional(),
+  precondition: zod__default.string().nullable().optional(),
+  assignee: zod__default.string().nullable().optional().describe(
+    "Jira Account ID of the assignee. Ask the user to provide their Account ID directly."
+  ),
+  reporter: zod__default.string().nullable().optional().describe(
+    "Jira Account ID of the reporter. Ask the user to provide their Account ID directly."
+  ),
+  estimatedTime: zod__default.string().nullable().optional(),
+  folderId: zod__default.number().int().nullable().optional().describe(
+    "Numeric folder ID to place the test cases in. Right-click a folder in QTM4J and select 'Copy Folder Id' to get this value."
+  )
+}).nullable().optional();
+const TestCaseExecutionFields = zod__default.object({
+  comment: zod__default.string().nullable().optional(),
+  actualTime: zod__default.string().nullable().optional(),
+  executionPlannedDate: zod__default.string().nullable().optional(),
+  assignee: zod__default.string().nullable().optional()
+}).nullable().optional();
+const UploadAutomationResultBody = zod__default.object({
+  filePath: zod__default.string().describe(SCHEMA_DESCRIPTIONS.AUTOMATION_FILE_PATH),
+  format: zod__default.enum(["cucumber", "testng", "junit", "qaf", "hpuft", "specflow"]).describe(SCHEMA_DESCRIPTIONS.AUTOMATION_FORMAT),
+  testCycleToReuse: zod__default.string().optional().describe(SCHEMA_DESCRIPTIONS.AUTOMATION_TEST_CYCLE_TO_REUSE),
+  environment: zod__default.string().optional().describe(SCHEMA_DESCRIPTIONS.AUTOMATION_ENVIRONMENT),
+  build: zod__default.string().optional().describe(SCHEMA_DESCRIPTIONS.AUTOMATION_BUILD),
+  isZip: zod__default.boolean().optional().default(false).describe(SCHEMA_DESCRIPTIONS.AUTOMATION_IS_ZIP),
+  attachFile: zod__default.boolean().optional().default(false).describe(SCHEMA_DESCRIPTIONS.AUTOMATION_ATTACH_FILE),
+  matchTestSteps: zod__default.boolean().optional().default(true).describe(SCHEMA_DESCRIPTIONS.AUTOMATION_MATCH_TEST_STEPS),
+  appendTestName: zod__default.boolean().optional().describe(SCHEMA_DESCRIPTIONS.AUTOMATION_APPEND_TEST_NAME),
+  fields: zod__default.object({
+    testCycle: TestCycleFields,
+    testCase: TestCaseFields,
+    testCaseExecution: TestCaseExecutionFields
+  }).optional().describe(SCHEMA_DESCRIPTIONS.AUTOMATION_FIELDS)
+});
+const UploadAutomationResultResponse = zod__default.object({
+  trackingId: zod__default.string(),
+  message: zod__default.string(),
+  filePath: zod__default.string(),
+  format: zod__default.enum(["cucumber", "testng", "junit", "qaf", "hpuft", "specflow"])
+});
+const GetAutomationHistoryBody = zod__default.object({
+  startAt: zod__default.number().int().min(0).optional().default(0).describe(SCHEMA_DESCRIPTIONS.AUTOMATION_HISTORY_START_AT),
+  maxResults: zod__default.number().int().min(1).max(100).optional().default(20).describe(SCHEMA_DESCRIPTIONS.AUTOMATION_HISTORY_MAX_RESULTS)
+});
+const AutomationHistorySummary = zod__default.object({
+  testCycle: zod__default.string().nullable().optional(),
+  testCasesCreated: zod__default.number().nullable().optional(),
+  testCaseVersionsCreated: zod__default.number().nullable().optional(),
+  testCaseVersionsReused: zod__default.number().nullable().optional(),
+  testStepsCreated: zod__default.number().nullable().optional(),
+  testCycleIssueKey: zod__default.string().nullable().optional(),
+  testCycleSummary: zod__default.string().nullable().optional()
+});
+const AutomationHistoryRecord = zod__default.object({
+  trackingId: zod__default.string().nullable().optional(),
+  fileName: zod__default.string().nullable().optional(),
+  format: zod__default.string().nullable().optional(),
+  processStatus: zod__default.string().nullable().optional(),
+  importStatus: zod__default.string().nullable().optional(),
+  startTime: zod__default.string().nullable().optional(),
+  endTime: zod__default.string().nullable().optional(),
+  fileSize: zod__default.number().nullable().optional(),
+  detailedMessage: zod__default.string().nullable().optional(),
+  extraAttributes: zod__default.record(zod__default.string(), zod__default.any()).nullable().optional(),
+  childFileSummaryResponses: zod__default.array(zod__default.any()).nullable().optional(),
+  summary: zod__default.array(AutomationHistorySummary).nullable().optional()
+});
+const GetAutomationHistoryResponse = zod__default.object({
+  startAt: zod__default.number().nullable().optional(),
+  maxResults: zod__default.number().nullable().optional(),
+  total: zod__default.number().nullable().optional(),
+  data: zod__default.array(AutomationHistoryRecord).nullable().optional()
+});
+export {
+  AutomationHistoryRecord,
+  GetAutomationHistoryBody,
+  GetAutomationHistoryResponse,
+  UploadAutomationResultBody,
+  UploadAutomationResultResponse
+};