@smartbear/mcp 0.23.0 → 0.25.0

package/dist/qtm4j/schema/update-test-cycle.schema.js

@@ -0,0 +1,54 @@
+import * as zod from "zod";
+const MetadataAddDelete = zod.object({
+  add: zod.array(zod.string()).optional().describe(
+    "Names to add (e.g., ['Regression', 'Smoke']). Auto-resolved to IDs."
+  ),
+  delete: zod.array(zod.string()).optional().describe("Names to remove (e.g., ['Sprint1']). Auto-resolved to IDs.")
+}).describe(
+  "Add or remove entries by name. Both add and delete are optional — omit either to skip that operation."
+);
+const DATETIME_REGEX = /^\d{2}\/[A-Za-z]{3}\/\d{4} \d{2}:\d{2}$/;
+const DATETIME_DESCRIPTION = "Format: 'dd/MMM/yyyy HH:mm' e.g. '15/May/2026 09:00'. Month must be capitalised (May not may). Pass null to clear the existing value.";
+const UpdateTestCycleBody = zod.object({
+  key: zod.string().describe(
+    "Test cycle key in the format '{PROJECT_KEY}-TR-{number}', e.g. 'SCRUM-TR-101'. Used directly as the API path parameter."
+  ),
+  summary: zod.string().min(1, "Summary cannot be blank.").max(255, "Summary must not exceed 255 characters.").optional().describe("Updated test cycle name / title. Max 255 characters."),
+  description: zod.string().max(65535, "Description must not exceed 65,535 characters.").nullable().optional().describe(
+    "Updated description. Pass null to clear the existing value. Max 65 535 characters."
+  ),
+  status: zod.string().nullable().optional().describe(
+    "Status name (e.g., 'To Do', 'In Progress', 'Done'). Auto-resolved to ID. Use values from set_project_context response. Pass null to clear."
+  ),
+  priority: zod.string().nullable().optional().describe(
+    "Priority name (e.g., 'High', 'Medium', 'Low'). Auto-resolved to ID. Use values from set_project_context response. Pass null to clear."
+  ),
+  plannedStartDate: zod.string().regex(
+    DATETIME_REGEX,
+    "Invalid format. Use dd/MMM/yyyy HH:mm e.g. 15/May/2026 09:00"
+  ).nullable().optional().describe(DATETIME_DESCRIPTION),
+  plannedEndDate: zod.string().regex(
+    DATETIME_REGEX,
+    "Invalid format. Use dd/MMM/yyyy HH:mm e.g. 30/May/2026 18:00"
+  ).nullable().optional().describe(DATETIME_DESCRIPTION),
+  assignee: zod.string().nullable().optional().describe(
+    "Assignee Jira account ID (e.g., '5b10a2844c20165700ede21f'). Pass null to unassign."
+  ),
+  reporter: zod.string().nullable().optional().describe(
+    "Reporter Jira account ID (e.g., '5b10a2844c20165700ede21f'). Pass null to clear."
+  ),
+  labels: MetadataAddDelete.optional().describe(
+    "Labels to add or remove by name. Each name is auto-resolved to its ID."
+  ),
+  components: MetadataAddDelete.optional().describe(
+    "Components to add or remove by name. Each name is auto-resolved to its ID."
+  )
+});
+const UpdateTestCycleResponse = zod.object({
+  key: zod.string().describe("Human-readable key of the updated test cycle"),
+  updated: zod.literal(true).describe("Confirms the update was applied")
+});
+export {
+  UpdateTestCycleBody,
+  UpdateTestCycleResponse
+};

package/dist/qtm4j/tool/project/get-projects.js

@@ -1,9 +1,10 @@
 import { Tool } from "../../../common/tools.js";
-import { TOOL_NAMES, RESPONSE_FIELDS, PAGINATION, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, RESPONSE_FIELDS, PAGINATION, ENDPOINTS } from "../../config/constants.js";
 import { GetProjectsResponse, GetProjectsBody } from "../../schema/project.schema.js";
 class GetProjects extends Tool {
   specification = {
     title: TOOL_NAMES.GET_PROJECTS.TITLE,
+    toolset: TOOLSETS.PROJECTS,
     summary: TOOL_NAMES.GET_PROJECTS.SUMMARY,
     readOnly: true,
     idempotent: true,

package/dist/qtm4j/tool/project/set-project-context.js

@@ -1,5 +1,5 @@
 import { Tool, ToolError } from "../../../common/tools.js";
-import { TOOL_NAMES, ENDPOINTS, PAGINATION, RESPONSE_FIELDS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS, PAGINATION, RESPONSE_FIELDS } from "../../config/constants.js";
 import { SetProjectContextResponse, SetProjectContextBody, GetProjectsResponse } from "../../schema/project.schema.js";
 const PROJECT_SEARCH_MAX_RESULTS = 10;
 const ERRORS = {
@@ -9,6 +9,7 @@ const ERRORS = {
 class SetProjectContext extends Tool {
   specification = {
     title: TOOL_NAMES.SET_PROJECT_CONTEXT.TITLE,
+    toolset: TOOLSETS.PROJECTS,
     summary: TOOL_NAMES.SET_PROJECT_CONTEXT.SUMMARY,
     readOnly: false,
     idempotent: true,

package/dist/qtm4j/tool/requirement/get-linked-testcases.js

@@ -0,0 +1,93 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { GetLinkedTestCasesForRequirementBody } from "../../schema/linked-items.schema.js";
+import { SearchTestCaseResponse } from "../../schema/get-test-case.schema.js";
+class GetLinkedTestCasesForRequirement extends Tool {
+  specification = {
+    title: TOOL_NAMES.GET_LINKED_TESTCASES_FOR_REQUIREMENT.TITLE,
+    summary: TOOL_NAMES.GET_LINKED_TESTCASES_FOR_REQUIREMENT.SUMMARY,
+    readOnly: true,
+    idempotent: true,
+    toolset: TOOLSETS.REQUIREMENTS,
+    inputSchema: GetLinkedTestCasesForRequirementBody,
+    outputSchema: SearchTestCaseResponse,
+    purpose: "Retrieve all test cases linked to a specific Jira requirement in QTM4J. The requirement's human-readable key (e.g. 'SCRUM-1') is resolved to the internal Jira issue ID automatically. Returns a paginated list of linked test cases with their metadata. Use the filter to narrow results by status, priority, labels, folder, and more. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Check which test cases cover a Jira story or bug",
+      "Audit requirement traceability — find all test cases for a given requirement",
+      "Filter linked test cases by status or priority before a release",
+      "Retrieve test case keys to use in update or link operations"
+    ],
+    examples: [
+      {
+        description: "Get all test cases linked to a requirement",
+        parameters: { requirementKey: "SCRUM-1" },
+        expectedOutput: "Paginated list of linked test cases"
+      },
+      {
+        description: "Get high priority linked test cases",
+        parameters: {
+          requirementKey: "SCRUM-5",
+          filter: { priority: ["High"] },
+          fields: "key,summary,status,priority",
+          sort: "key:asc"
+        },
+        expectedOutput: "Filtered high-priority test cases linked to requirement"
+      },
+      {
+        description: "Paginate through linked test cases",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          maxResults: 20,
+          startAt: 20
+        },
+        expectedOutput: "Second page of linked test cases"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "REQUIREMENT KEY FORMAT: '{PROJECT_KEY}-{number}' — e.g. 'SCRUM-1'.",
+      "projectId in filter is auto-filled from the active project context — do not set it manually.",
+      "Use the fields param to limit response size — only request fields you need.",
+      "Paginate using startAt — increment by maxResults until startAt >= total.",
+      "filter.testCaseStatus can be 'active', 'archived', or 'deleted' to filter by archive state."
+    ],
+    outputDescription: "Paginated response with total, startAt, maxResults, and data array of linked test case objects."
+  };
+  handle = async (rawArgs) => {
+    const args = GetLinkedTestCasesForRequirementBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, [args.requirementKey]);
+    const reqEntry = reqMap[args.requirementKey];
+    if (!reqEntry) {
+      throw new ToolError(
+        `Requirement '${args.requirementKey}' not found in project '${context.projectKey}'. Verify the key is a valid Jira issue key.`
+      );
+    }
+    const requirementId = Number(reqEntry.id);
+    const queryParams = {
+      fields: args.fields,
+      maxResults: args.maxResults,
+      startAt: args.startAt,
+      sort: args.sort
+    };
+    const body = {};
+    if (args.filter) {
+      body.filter = { ...args.filter, projectId: context.projectId };
+    }
+    const response = await this.client.getApiClient().post(
+      ENDPOINTS.GET_LINKED_TESTCASES_FOR_REQUIREMENT(requirementId),
+      body,
+      queryParams
+    );
+    return {
+      structuredContent: SearchTestCaseResponse.parse(response),
+      content: []
+    };
+  };
+}
+export {
+  GetLinkedTestCasesForRequirement
+};

package/dist/qtm4j/tool/requirement/link-testcases.js

@@ -0,0 +1,107 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { RequirementTestCaseLinkResponse, LinkTestCasesToRequirementBody } from "../../schema/requirements.schema.js";
+class LinkTestCasesToRequirement extends Tool {
+  specification = {
+    title: TOOL_NAMES.LINK_TESTCASES_TO_REQUIREMENT.TITLE,
+    summary: TOOL_NAMES.LINK_TESTCASES_TO_REQUIREMENT.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    toolset: TOOLSETS.REQUIREMENTS,
+    inputSchema: LinkTestCasesToRequirementBody,
+    outputSchema: RequirementTestCaseLinkResponse,
+    purpose: "Link test cases to a Jira requirement in QTM4J using the requirement's human-readable key. Test cases can be specified by their keys (e.g. 'SCRUM-TC-1'), which are resolved to internal IDs and latest versions automatically. Alternatively, use a filter object to select test cases by criteria such as status, priority, labels, or folder. The active project ID is injected automatically into the filter. Test cases that cannot be linked are reported in warnings. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Link specific test cases to a Jira story or bug by requirement key",
+      "Build traceability between Jira requirements and QTM4J test cases",
+      "Link all test cases matching a filter to a requirement",
+      "Associate test cases with a requirement as part of sprint planning"
+    ],
+    examples: [
+      {
+        description: "Link two test cases by key",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          testCaseKeys: ["SCRUM-TC-10", "SCRUM-TC-11"]
+        },
+        expectedOutput: "Test cases linked to requirement SCRUM-1"
+      },
+      {
+        description: "Link test cases matching a filter",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          filter: { priority: ["High"], status: ["To Do"] }
+        },
+        expectedOutput: "Filtered test cases linked to requirement"
+      },
+      {
+        description: "Link test cases in a specific folder",
+        parameters: {
+          requirementKey: "SCRUM-5",
+          filter: { folderId: 42, withChild: true },
+          sort: "key:asc"
+        },
+        expectedOutput: "Folder test cases linked to requirement"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "REQUIREMENT KEY FORMAT: '{PROJECT_KEY}-{number}' — e.g. 'SCRUM-1'.",
+      "TEST CASE KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "Provide either testCaseKeys or filter — not both.",
+      "projectId in filter is auto-filled from the active project context — do not set it manually.",
+      "filter.excludeRequirementId excludes test cases already linked to that requirement ID.",
+      "If a test case key cannot be resolved, it is reported in warnings and other test cases are still linked."
+    ],
+    outputDescription: "Confirmation with the requirement key and linked: true. Warnings included if any test cases could not be resolved or linked."
+  };
+  handle = async (rawArgs) => {
+    const args = LinkTestCasesToRequirementBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const warnings = [];
+    const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, [args.requirementKey]);
+    const reqEntry = reqMap[args.requirementKey];
+    if (!reqEntry) {
+      throw new ToolError(
+        `Requirement '${args.requirementKey}' not found in project '${context.projectKey}'. Verify the key is a valid Jira issue key.`
+      );
+    }
+    const requirementId = Number(reqEntry.id);
+    const body = {};
+    if (args.testCaseKeys?.length) {
+      const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, args.testCaseKeys);
+      const testcases = [];
+      for (const tcKey of args.testCaseKeys) {
+        const resolved = uidMap[tcKey];
+        if (resolved) {
+          testcases.push({
+            id: resolved.uid,
+            versionNo: resolved.latestVersion
+          });
+        } else {
+          warnings.push(
+            `Test case '${tcKey}' could not be resolved and was skipped.`
+          );
+        }
+      }
+      if (testcases.length > 0) body.testcases = testcases;
+    }
+    if (args.filter) {
+      body.filter = { ...args.filter, projectId: context.projectId };
+    }
+    if (args.sort) body.sort = args.sort;
+    await this.client.getApiClient().post(ENDPOINTS.LINK_TESTCASES_TO_REQUIREMENT(requirementId), body);
+    return {
+      structuredContent: RequirementTestCaseLinkResponse.parse({
+        requirementKey: args.requirementKey,
+        linked: true
+      }),
+      content: warnings.length > 0 ? [{ type: "text", text: `Note: ${warnings.join(" | ")}` }] : []
+    };
+  };
+}
+export {
+  LinkTestCasesToRequirement
+};

package/dist/qtm4j/tool/requirement/unlink-testcases.js

@@ -0,0 +1,97 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOLSETS, TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { ResolverKeys } from "../../config/field-resolution.types.js";
+import { RequirementTestCaseLinkResponse, UnlinkTestCasesFromRequirementBody } from "../../schema/requirements.schema.js";
+class UnlinkTestCasesFromRequirement extends Tool {
+  specification = {
+    title: TOOL_NAMES.UNLINK_TESTCASES_FROM_REQUIREMENT.TITLE,
+    summary: TOOL_NAMES.UNLINK_TESTCASES_FROM_REQUIREMENT.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    toolset: TOOLSETS.REQUIREMENTS,
+    inputSchema: UnlinkTestCasesFromRequirementBody,
+    outputSchema: RequirementTestCaseLinkResponse,
+    purpose: "Unlink test cases from a Jira requirement in QTM4J using the requirement's human-readable key. Test cases can be specified by their keys (e.g. 'SCRUM-TC-1'), which are resolved to internal IDs and latest versions automatically. Alternatively, use a filter object to select test cases to unlink by criteria. The active project ID is injected automatically into the filter. Test cases that cannot be unlinked are reported in warnings. PREREQUISITE: set_project_context must be called before this tool.",
+    useCases: [
+      "Remove specific test cases from a Jira requirement",
+      "Unlink test cases matching a filter from a requirement",
+      "Clean up stale or incorrect test case links on a requirement",
+      "Remove traceability links as part of sprint cleanup"
+    ],
+    examples: [
+      {
+        description: "Unlink specific test cases by key",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          testCaseKeys: ["SCRUM-TC-10", "SCRUM-TC-11"]
+        },
+        expectedOutput: "Test cases unlinked from requirement SCRUM-1"
+      },
+      {
+        description: "Unlink test cases matching a filter",
+        parameters: {
+          requirementKey: "SCRUM-1",
+          filter: { status: ["Done"], labels: ["Deprecated"] }
+        },
+        expectedOutput: "Filtered test cases unlinked from requirement"
+      }
+    ],
+    hints: [
+      "PREREQUISITE: set_project_context must be called before this tool. NEVER auto-select a project.",
+      "REQUIREMENT KEY FORMAT: '{PROJECT_KEY}-{number}' — e.g. 'SCRUM-1'.",
+      "TEST CASE KEY FORMAT: '{PROJECT_KEY}-TC-{number}' — e.g. 'SCRUM-TC-145'.",
+      "Provide either testCaseKeys or filter — not both.",
+      "projectId in filter is auto-filled from the active project context — do not set it manually.",
+      "filter.excludeTestCases can be used to exclude specific test cases when using filter-based unlinking.",
+      "If a test case key cannot be resolved, it is reported in warnings and other test cases are still unlinked."
+    ],
+    outputDescription: "Confirmation with the requirement key and unlinked: true. Warnings included if any test cases could not be resolved or unlinked."
+  };
+  handle = async (rawArgs) => {
+    const args = UnlinkTestCasesFromRequirementBody.parse(rawArgs);
+    const fieldResolver = this.client.getResolverRegistry();
+    const context = fieldResolver.requireProjectContext();
+    const warnings = [];
+    const reqMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.REQUIREMENT_KEY_TO_ID).resolveAndReturn(context.projectId, [args.requirementKey]);
+    const reqEntry = reqMap[args.requirementKey];
+    if (!reqEntry) {
+      throw new ToolError(
+        `Requirement '${args.requirementKey}' not found in project '${context.projectKey}'. Verify the key is a valid Jira issue key.`
+      );
+    }
+    const requirementId = Number(reqEntry.id);
+    const body = {};
+    if (args.testCaseKeys?.length) {
+      const uidMap = await fieldResolver.getResolver(ResolverKeys.SearchableField.TEST_CASE_KEY_TO_UID).resolveAndReturn(context.projectId, args.testCaseKeys);
+      const testcases = [];
+      for (const tcKey of args.testCaseKeys) {
+        const resolved = uidMap[tcKey];
+        if (resolved) {
+          testcases.push({
+            id: resolved.uid,
+            versionNo: resolved.latestVersion
+          });
+        } else {
+          warnings.push(
+            `Test case '${tcKey}' could not be resolved and was skipped.`
+          );
+        }
+      }
+      if (testcases.length > 0) body.testcases = testcases;
+    }
+    if (args.filter) {
+      body.filter = { ...args.filter, projectId: context.projectId };
+    }
+    await this.client.getApiClient().delete(ENDPOINTS.UNLINK_TESTCASES_FROM_REQUIREMENT(requirementId), body);
+    return {
+      structuredContent: RequirementTestCaseLinkResponse.parse({
+        requirementKey: args.requirementKey,
+        unlinked: true
+      }),
+      content: warnings.length > 0 ? [{ type: "text", text: `Note: ${warnings.join(" | ")}` }] : []
+    };
+  };
+}
+export {
+  UnlinkTestCasesFromRequirement
+};

package/dist/qtm4j/tool/test-automation/get-automation-history.js

@@ -0,0 +1,70 @@
+import { Tool } from "../../../common/tools.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS } from "../../config/constants.js";
+import { GetAutomationHistoryResponse, GetAutomationHistoryBody } from "../../schema/automation.schema.js";
+class GetAutomationHistory extends Tool {
+  specification = {
+    title: TOOL_NAMES.GET_AUTOMATION_HISTORY.TITLE,
+    toolset: TOOLSETS.TEST_AUTOMATION,
+    summary: TOOL_NAMES.GET_AUTOMATION_HISTORY.SUMMARY,
+    readOnly: true,
+    idempotent: true,
+    inputSchema: GetAutomationHistoryBody,
+    outputSchema: GetAutomationHistoryResponse,
+    purpose: "Retrieve a paginated list of past automation result uploads from QTM4J. Use this to review upload history, check upload statuses, and audit past CI/CD automation runs. No set_project_context call is required.",
+    useCases: [
+      "Review past automation result uploads for a project",
+      "Check the status of recent automation imports",
+      "Audit CI/CD automation upload history",
+      "Paginate through all historical automation uploads"
+    ],
+    examples: [
+      {
+        description: "Get the first page of automation upload history (default page size 20)",
+        parameters: {},
+        expectedOutput: "Paginated list of automation history records with upload status and metadata"
+      },
+      {
+        description: "Get the second page of automation upload history",
+        parameters: {
+          startAt: 20,
+          maxResults: 20
+        },
+        expectedOutput: "Next 20 automation history records"
+      },
+      {
+        description: "Get up to 50 records starting from the beginning",
+        parameters: {
+          startAt: 0,
+          maxResults: 50
+        },
+        expectedOutput: "Up to 50 automation history records"
+      }
+    ],
+    hints: [
+      "NO PROJECT CONTEXT REQUIRED: Do NOT call set_project_context and do NOT ask the user for a project key, project ID, or any other project details. This tool works independently.",
+      "PAGINATION: startAt is zero-indexed (default: 0), maxResults controls page size (default: 20, max: 100). Increment startAt by maxResults to fetch the next page.",
+      "Returns an empty data array (not an error) when no history records exist.",
+      "DISPLAY FORMAT: Show '1–N of <total>' above all cards. Render each record as a card separated by --- dividers. Each card has two sections:\n\nPRIMARY SECTION (always first): heading with status emoji (✅ SUCCESS / ❌ FAILED) + test cycle key and name; then format, start→end time, message, summary stats (test cases/versions created/reused/test steps), tracking ID.\n\nEXTRA DETAILS SECTION (at the bottom of the card, under a 'Details' sub-label): any remaining non-null fields from the record such as fileSize, extraAttributes values, etc.\n\nSkip any field that is null, missing, or false. NEVER show the raw fileName. NEVER use a table."
+    ],
+    outputDescription: "Paginated list of automation import history. Each record includes: format, processStatus, importStatus, startTime, endTime, trackingId, detailedMessage, and a summary array. summary[0] contains: testCycleIssueKey, testCycleSummary, testCasesCreated, testCaseVersionsCreated, testCaseVersionsReused, testStepsCreated. Render as individual cards separated by dividers, NOT a table. Show '1–N of total' count above. Never show raw fileName."
+  };
+  handle = async (rawArgs) => {
+    const args = GetAutomationHistoryBody.parse(rawArgs);
+    const apiClient = this.client.getApiClient();
+    const response = await apiClient.getAutomation(
+      ENDPOINTS.AUTOMATION_HISTORY,
+      {
+        startAt: args.startAt,
+        maxResults: args.maxResults
+      }
+    );
+    const result = GetAutomationHistoryResponse.parse(response);
+    return {
+      structuredContent: result,
+      content: []
+    };
+  };
+}
+export {
+  GetAutomationHistory
+};

package/dist/qtm4j/tool/test-automation/upload-automation-result.js

@@ -0,0 +1,144 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { TOOL_NAMES, TOOLSETS, AUTOMATION_RESULT_DIRS, AUTOMATION_LIMITS, ENDPOINTS } from "../../config/constants.js";
+import { UploadAutomationResultResponse, UploadAutomationResultBody } from "../../schema/automation.schema.js";
+const SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".xml", ".json", ".zip"]);
+class UploadAutomationResult extends Tool {
+  specification = {
+    title: TOOL_NAMES.UPLOAD_AUTOMATION_RESULT.TITLE,
+    toolset: TOOLSETS.TEST_AUTOMATION,
+    summary: TOOL_NAMES.UPLOAD_AUTOMATION_RESULT.SUMMARY,
+    readOnly: false,
+    idempotent: false,
+    inputSchema: UploadAutomationResultBody,
+    outputSchema: UploadAutomationResultResponse,
+    purpose: `Upload an automation result file from disk to QTM4J and map results to a test cycle. No set_project_context call is required — this tool works independently of any project context. When the user asks to upload or import automation results, search these directories: ${AUTOMATION_RESULT_DIRS.join(", ")}. Infer the format from the file name where possible; confirm with the user only when the format is ambiguous. Returns a trackingId to track the asynchronous import progress.`,
+    useCases: [
+      "Upload automation results to QTM4J",
+      "Import test results from a CI/CD pipeline run",
+      "Link test results to an existing test cycle",
+      "Create a new test cycle from automation results",
+      "Upload JUnit, TestNG, Cucumber, QAF, HP UFT, or SpecFlow result files"
+    ],
+    examples: [
+      {
+        description: "User says 'upload my test results to QTM4J' — scan workspace, find single result file, confirm and upload",
+        parameters: {
+          filePath: "./target/surefire-reports/TEST-results.xml",
+          format: "junit"
+        },
+        expectedOutput: "trackingId returned; import processing started in QTM4J"
+      },
+      {
+        description: "User wants results linked to an existing test cycle",
+        parameters: {
+          filePath: "./reports/cucumber.json",
+          format: "cucumber",
+          testCycleToReuse: "TR-PRJ-5",
+          environment: "Chrome",
+          build: "2.1.0"
+        },
+        expectedOutput: "Results mapped to test cycle TR-PRJ-5"
+      },
+      {
+        description: "Upload QAF ZIP and set test cycle metadata",
+        parameters: {
+          filePath: "./results/qaf-results.zip",
+          format: "qaf",
+          isZip: true,
+          fields: {
+            testCycle: {
+              summary: "Regression Run 2024-Q1",
+              labels: ["regression"],
+              priority: "High"
+            }
+          }
+        },
+        expectedOutput: "ZIP uploaded; test cycle created with summary, labels, and priority"
+      },
+      {
+        description: "User provides an unrecognised priority value — do NOT silently map to a similar word; ask the user first",
+        parameters: {
+          filePath: "./reports/cucumber.json",
+          format: "cucumber",
+          fields: { testCycle: { priority: "critical" } }
+        },
+        expectedOutput: "Tool is NOT called yet. Inform the user that 'critical' was not recognised as a valid priority and ask them to confirm the correct value (e.g. from the available options). Do not map 'critical' to 'Blocker' or any other value without explicit user confirmation."
+      }
+    ],
+    hints: [
+      "NO PROJECT CONTEXT REQUIRED: Do NOT call set_project_context and do NOT ask the user for a project key, project ID, or any other project details. This tool works independently — never prompt the user for project information.",
+      `FILE DISCOVERY: Always do a fresh scan — never reuse a path from a previous turn. If no path is provided, search in order: ${AUTOMATION_RESULT_DIRS.join(", ")}. If exactly one file is found, show the path and inferred format to the user and confirm before uploading. If multiple files are found, list them all and wait for the user to pick one. If nothing is found, ask for the path. Never pick or upload silently.`,
+      "FORMAT INFERENCE: .json → cucumber (unambiguous). For .xml, infer from the file name — 'junit'/'surefire' → junit, 'testng' → testng, 'specflow' → specflow, 'hpuft'/'uft' → hpuft. For .zip, ALWAYS set isZip: true, but do NOT assume qaf — the zip could contain junit, testng, or cucumber results; if the format cannot be determined from the file name, ask the user. If the file name gives no clear signal for .xml either, ask the user to confirm the format.",
+      "TEST CYCLE: Only ask for testCycleToReuse if the user explicitly wants to link to an existing cycle. If not mentioned, omit it — QTM4J creates a new test cycle automatically.",
+      "DATE FORMAT: plannedStartDate and plannedEndDate in fields.testCycle MUST be formatted as 'dd/MMM/yyyy HH:mm' (e.g. '14/May/2026 10:30'). Convert any user-provided date (ISO, natural language, relative) to this exact format before sending.",
+      "FOLDER ID: folderId is a numeric ID. Apply it ONLY to the level the user specifies; if unspecified, default to fields.testCycle only — never copy it to both levels. Get the ID from the user directly (right-click folder in QTM4J → 'Copy Folder Id').",
+      "ASSIGNEE / REPORTER: assignee and reporter in fields.testCycle and fields.testCase require a Jira Account ID (not a display name or email). Ask the user to provide their Account ID directly.",
+      "FIELD MAPPING CONFIRMATION: Apply formatting transformations (case correction, date/time conversion) automatically. Only ask for user confirmation when you cannot find a recognised match and need to substitute an unrecognised value with a guessed alternative — never silently substitute in that case.",
+      "TRACKING: Import processing is asynchronous. To check status, call get_automation_history and find the record whose trackingId matches the one returned from this tool."
+    ],
+    outputDescription: "trackingId to poll import status, a message from the API, the filePath uploaded, and the format used."
+  };
+  handle = async (rawArgs) => {
+    const args = UploadAutomationResultBody.parse(rawArgs);
+    const { filePath, format, isZip, fields, ...rest } = args;
+    const ext = extname(filePath).toLowerCase();
+    if (!SUPPORTED_EXTENSIONS.has(ext)) {
+      throw new ToolError(
+        `Unsupported file extension '${ext}'. Supported extensions: .xml, .json, .zip`
+      );
+    }
+    if (format === "qaf" && !isZip) {
+      throw new ToolError(
+        "QAF format requires a ZIP file. Set isZip: true and provide a .zip file."
+      );
+    }
+    let fileBuffer;
+    try {
+      fileBuffer = await readFile(filePath);
+    } catch (err) {
+      throw new ToolError(
+        `Could not read file at '${filePath}': ${err.message}`
+      );
+    }
+    if (fileBuffer.byteLength > AUTOMATION_LIMITS.MAX_FILE_SIZE_BYTES) {
+      const sizeMB = (fileBuffer.byteLength / (1024 * 1024)).toFixed(2);
+      throw new ToolError(
+        `File is too large (${sizeMB} MB). Maximum allowed size is 10 MB.`
+      );
+    }
+    const apiClient = this.client.getApiClient();
+    const importBody = {
+      format,
+      isZip: isZip ?? false,
+      ...rest,
+      ...fields ? { fields } : {}
+    };
+    const initResponse = await apiClient.postAutomation(
+      ENDPOINTS.AUTOMATION_IMPORT,
+      importBody
+    );
+    const uploadUrl = initResponse?.url;
+    const trackingId = initResponse?.trackingId;
+    if (!uploadUrl || !trackingId) {
+      throw new ToolError(
+        "QTM4J did not return a valid upload URL. Check your API key and project configuration."
+      );
+    }
+    await apiClient.uploadFileMultipart(uploadUrl, fileBuffer);
+    const result = {
+      trackingId,
+      message: initResponse.message ?? "File uploaded successfully. Import is processing.",
+      filePath,
+      format
+    };
+    return {
+      structuredContent: UploadAutomationResultResponse.parse(result),
+      content: []
+    };
+  };
+}
+export {
+  UploadAutomationResult
+};

package/dist/qtm4j/tool/test-case/create-test-case.js

@@ -1,5 +1,5 @@
 import { Tool } from "../../../common/tools.js";
-import { TOOL_NAMES, ENDPOINTS } from "../../config/constants.js";
+import { TOOL_NAMES, TOOLSETS, ENDPOINTS } from "../../config/constants.js";
 import { ResolverKeys, InputField } from "../../config/field-resolution.types.js";
 import { CreateTestCaseResponse, CreateTestCaseBody } from "../../schema/test-case.schema.js";
 const FIELD_CONFIG = {
@@ -13,6 +13,7 @@ class CreateTestCase extends Tool {
   // ─── Tool Specification ────────────────────────────────────────────────────
   specification = {
     title: TOOL_NAMES.CREATE_TEST_CASE.TITLE,
+    toolset: TOOLSETS.TEST_CASES,
     summary: TOOL_NAMES.CREATE_TEST_CASE.SUMMARY,
     readOnly: false,
     idempotent: false,