@testkase/mcp-server 2.0.12 → 2.1.0

package/build/index.js

@@ -3,854 +3,1160 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
-// Get configuration from environment variables
 const config = {
     apiBaseUrl: process.env.TESTKASE_API_BASE_URL || "https://apiqa.testkase.com",
     patToken: process.env.TESTKASE_PAT_TOKEN,
 };
-// Cached organization data (fetched once from PAT token)
-let cachedOrganizationId = null;
-// Cached project ID (set when user works on a project)
-let cachedProjectId = null;
-// Helper to get organization ID (fetches and caches on first call)
-async function getOrganizationId(providedOrgId) {
-    // If explicitly provided, use it
-    if (providedOrgId) {
-        return providedOrgId;
+// ─── Auth helpers (reused from v1) ───────────────────────────────────────────
+function validateAuth() {
+    if (!config.patToken) {
+        throw new Error("Authentication required. Please set TESTKASE_PAT_TOKEN environment variable. " +
+            "Generate a Personal Access Token (PAT) from your TestKase account settings.");
     }
-    // If cached, return cached value
-    if (cachedOrganizationId !== null) {
-        return cachedOrganizationId;
+    if (!config.patToken.startsWith("xyz_")) {
+        throw new Error("Invalid PAT token format. TestKase PAT tokens must start with 'xyz_' prefix. " +
+            "Please generate a valid PAT from your TestKase account settings.");
     }
-    // Fetch from API using PAT token
+}
+function getApiHeaders() {
+    return {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.patToken}`,
+    };
+}
+// ─── Cached org ID (auto-resolved from PAT, never a tool param) ─────────────
+let cachedOrganizationId = null;
+async function getOrganizationId() {
+    if (cachedOrganizationId !== null)
+        return cachedOrganizationId;
     validateAuth();
     try {
-        const response = await axios.get(`${config.apiBaseUrl}/api/v1/organizations/my-organization`, {
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${config.patToken}`,
-            },
-        });
+        const response = await axios.get(`${config.apiBaseUrl}/api/v1/organizations/my-organization`, { headers: getApiHeaders() });
         const orgData = response.data?.data || response.data;
         if (orgData?.organization_id) {
-            const orgId = orgData.organization_id;
-            cachedOrganizationId = orgId;
-            return orgId;
+            cachedOrganizationId = orgData.organization_id;
+            return cachedOrganizationId;
         }
         throw new Error("Could not determine organization from PAT token");
     }
     catch (error) {
-        throw new Error("Failed to fetch organization. Please provide organizationId or check your PAT token.");
+        if (error instanceof Error && error.message.includes("Could not determine"))
+            throw error;
+        throw new Error("Failed to fetch organization. Check your PAT token.");
     }
 }
-// Helper to get project ID (uses cached value if available)
-function getProjectId(providedProjectId) {
-    // If explicitly provided, cache it and use it
-    if (providedProjectId) {
-        cachedProjectId = providedProjectId;
-        return providedProjectId;
+// ─── API call helper ─────────────────────────────────────────────────────────
+async function callApi(method, path, options = {}) {
+    validateAuth();
+    const orgId = options.skipOrgId ? undefined : await getOrganizationId();
+    const queryParams = new URLSearchParams();
+    if (orgId)
+        queryParams.append("organizationId", orgId.toString());
+    if (options.query) {
+        for (const [key, val] of Object.entries(options.query)) {
+            if (val !== undefined && val !== null && val !== "") {
+                queryParams.append(key, String(val));
+            }
+        }
     }
-    // If cached, return cached value
-    if (cachedProjectId !== null) {
-        return cachedProjectId;
+    const qs = queryParams.toString();
+    const url = `${config.apiBaseUrl}/api/v1/${path}${qs ? `?${qs}` : ""}`;
+    const response = await axios({
+        method,
+        url,
+        headers: getApiHeaders(),
+        ...(options.body !== undefined && { data: options.body }),
+    });
+    return response.data;
+}
+// ─── Error handler (reused) ──────────────────────────────────────────────────
+function handleApiError(error) {
+    if (axios.isAxiosError(error)) {
+        const e = error;
+        let msg = `API request failed: ${e.message}`;
+        if (e.response) {
+            msg += `\nStatus: ${e.response.status}`;
+            msg += `\nResponse: ${JSON.stringify(e.response.data)}`;
+        }
+        return new Error(msg);
     }
-    throw new Error("No active project set. You MUST first: 1) Call get_my_projects to list projects, " +
-        "2) ASK the user which project they want to work with, " +
-        "3) Call set_active_project with the user's chosen project ID. " +
-        "Do NOT select a project automatically.");
+    return error;
 }
-// Helper to set active project (for explicit project switching)
-function setActiveProject(projectId) {
-    cachedProjectId = projectId;
+// ─── JSON response helper ────────────────────────────────────────────────────
+function jsonResponse(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
 }
-// Tool definitions
-const GET_TESTCASES_TOOL = {
-    name: "get_testcases",
-    description: "Retrieve testcases from the active project. Returns list with title, status, priority, etc. " +
-        "Supports search and filters. Call get_my_projects first if no active project is set.",
+// ─── Param normalizer (handles camelCase / snake_case) ───────────────────────
+function p(args, ...names) {
+    for (const n of names) {
+        if (args[n] !== undefined)
+            return args[n];
+    }
+    return undefined;
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// TOOL DEFINITIONS (11 tools)
+// ═══════════════════════════════════════════════════════════════════════════════
+const LIST_PROJECTS_TOOL = {
+    name: "list_projects",
+    description: "List all projects the authenticated user has access to. " +
+        "Use this first to find a projectId, then pass it to other tools.",
     inputSchema: {
         type: "object",
         properties: {
-            search: { type: "string", description: "Search term to filter by title or summary" },
+            search: { type: "string", description: "Search by project name or ID" },
             page: { type: "number", description: "Page number (default: 1)" },
             limit: { type: "number", description: "Items per page (default: 20)" },
-            filters: { type: "string", description: "JSON filters. Example: {\"status\":[\"active\"],\"priority\":[\"high\"]}" },
         },
         required: [],
     },
 };
-const GET_TESTCASE_DETAIL_TOOL = {
-    name: "get_testcase_detail",
-    description: "Get full details of a testcase including test steps and attachments.",
+const GET_PROJECT_STRUCTURE_TOOL = {
+    name: "get_project_structure",
+    description: "Get the structure of a project: folders, labels, and/or team members. " +
+        "Useful to discover folder IDs, label names, and member IDs before creating or updating items.",
     inputSchema: {
         type: "object",
         properties: {
-            testcaseId: { type: "string", description: "The testcase ID" },
+            projectId: { type: "string", description: "Project ID (e.g. PRJ-1001)" },
+            section: {
+                type: "string",
+                enum: ["TESTCASE", "TEST_CYCLE", "TEST_PLAN"],
+                description: "Folder section (default: TESTCASE)",
+            },
+            include: {
+                type: "string",
+                description: "Comma-separated list of what to include: folders,labels,members (default: all)",
+            },
         },
-        required: ["testcaseId"],
+        required: ["projectId"],
     },
 };
-const GET_FOLDERS_TOOL = {
-    name: "get_folders",
-    description: "Get folder structure of the active project. Use folder IDs when creating testcases.",
+const SEARCH_TESTCASES_TOOL = {
+    name: "search_testcases",
+    description: "Search and list test cases in a project. Supports text search, filters, sorting, and pagination.",
     inputSchema: {
         type: "object",
         properties: {
-            search: { type: "string", description: "Search term to filter folders" },
+            projectId: { type: "string", description: "Project ID" },
+            search: { type: "string", description: "Search text (title or summary)" },
+            filters: {
+                type: "string",
+                description: 'JSON string of filters. Example: {"status":["active"],"priority":["high","critical"]}',
+            },
+            page: { type: "number", description: "Page number (default: 1)" },
+            limit: { type: "number", description: "Items per page (default: 20)" },
+            sortBy: { type: "string", description: "Field to sort by (e.g. created_at, title)" },
+            sortOrder: { type: "string", enum: ["asc", "desc"], description: "Sort direction" },
         },
-        required: [],
-    },
-};
-const GET_LABELS_TOOL = {
-    name: "get_labels",
-    description: "Get all labels available in the active project for categorizing testcases.",
-    inputSchema: {
-        type: "object",
-        properties: {},
-        required: [],
-    },
-};
-const GET_MY_PROJECTS_TOOL = {
-    name: "get_my_projects",
-    description: "IMPORTANT: Call this FIRST. Lists all projects. " +
-        "ALWAYS ASK the user which project to use, then call set_active_project with their choice.",
-    inputSchema: {
-        type: "object",
-        properties: {},
-        required: [],
+        required: ["projectId"],
     },
 };
-const CREATE_TESTCASE_TOOL = {
-    name: "create_testcase",
-    description: "Create a new testcase in the active project.",
+const GET_TESTCASE_TOOL = {
+    name: "get_testcase",
+    description: "Get full details of a single test case including test steps and attachments.",
     inputSchema: {
         type: "object",
         properties: {
-            title: { type: "string", description: "Testcase title (required)" },
-            summary: { type: "string", description: "Description/summary" },
-            priority: { type: "string", description: "low, medium, high, or critical" },
-            folder_id: { type: "string", description: "Folder ID from get_folders" },
-            test_steps: { type: "string", description: "JSON array: [{\"step\":\"...\",\"expected_result\":\"...\"}]" },
+            projectId: { type: "string", description: "Project ID" },
+            testcaseId: { type: "string", description: "Test case ID (e.g. TEST-123)" },
         },
-        required: ["title"],
+        required: ["projectId", "testcaseId"],
     },
 };
-const CREATE_BULK_TESTCASE_TOOL = {
-    name: "create_bulk_testcase",
-    description: "Create multiple testcases at once in the active project.",
+const MANAGE_TESTCASE_TOOL = {
+    name: "manage_testcase",
+    description: "Create, bulk create, update, or delete test cases. " +
+        "Set 'action' to: create, create_bulk, update, or delete.",
     inputSchema: {
         type: "object",
         properties: {
-            testcases: { type: "string", description: "JSON array of testcases, each with title, summary, priority, test_steps" },
+            projectId: { type: "string", description: "Project ID" },
+            action: {
+                type: "string",
+                enum: ["create", "create_bulk", "update", "delete"],
+                description: "Action to perform",
+            },
+            // create params
+            title: { type: "string", description: "[create] Test case title" },
+            summary: { type: "string", description: "[create] Description/summary" },
+            priority: {
+                type: "string",
+                description: "[create] Priority: low, medium, high, or critical",
+            },
+            folder_id: { type: "string", description: "[create] Folder ID to place the test case in" },
+            labels: {
+                type: "string",
+                description: "[create] Comma-separated label names",
+            },
+            test_steps: {
+                type: "string",
+                description: '[create] JSON array of test steps: [{"step":"...","expected_result":"..."}]',
+            },
+            // create_bulk params
+            testcases: {
+                type: "string",
+                description: "[create_bulk] JSON array of test cases, each with title, summary, priority, folder_id, test_steps",
+            },
+            // update params
+            ids: {
+                type: "string",
+                description: "[update/delete] Comma-separated test case IDs",
+            },
+            field: {
+                type: "string",
+                description: "[update] Field name to update (title, summary, priority, status, etc.)",
+            },
+            value: { type: "string", description: "[update] New value for the field" },
         },
-        required: ["testcases"],
+        required: ["projectId", "action"],
     },
 };
-const UPDATE_TESTCASE_FIELD_TOOL = {
-    name: "update_testcase_field",
-    description: "Update a field for one or multiple testcases.",
+const MANAGE_FOLDER_TOOL = {
+    name: "manage_folder",
+    description: "Create, rename, move, or delete folders. Works across all sections (TESTCASE, TEST_CYCLE, TEST_PLAN).",
     inputSchema: {
         type: "object",
         properties: {
-            ids: { type: "string", description: "Comma-separated testcase IDs" },
-            field: { type: "string", description: "Field name (title, summary, priority, status, etc.)" },
-            value: { type: "string", description: "New value" },
+            projectId: { type: "string", description: "Project ID" },
+            action: {
+                type: "string",
+                enum: ["create", "rename", "move", "delete"],
+                description: "Action to perform",
+            },
+            section: {
+                type: "string",
+                enum: ["TESTCASE", "TEST_CYCLE", "TEST_PLAN"],
+                description: "Folder section (default: TESTCASE)",
+            },
+            name: { type: "string", description: "[create/rename] Folder name (max 50 chars)" },
+            folderId: {
+                type: "number",
+                description: "[rename/move/delete] ID of the folder to modify",
+            },
+            parentId: {
+                type: "number",
+                description: "[create] Parent folder ID for subfolder. [move] New parent ID (null for root).",
+            },
         },
-        required: ["ids", "field", "value"],
+        required: ["projectId", "action"],
     },
 };
-const DELETE_TESTCASE_TOOL = {
-    name: "delete_testcase",
-    description: "Delete one or multiple testcases. ALWAYS confirm with user before deleting.",
+const SEARCH_TEST_CYCLES_TOOL = {
+    name: "search_test_cycles",
+    description: "List and search test cycles in a project with execution progress.",
     inputSchema: {
         type: "object",
         properties: {
-            ids: { type: "string", description: "Comma-separated testcase IDs to delete" },
+            projectId: { type: "string", description: "Project ID" },
+            search: { type: "string", description: "Search by title" },
+            folderId: { type: "number", description: "Filter by folder ID" },
+            status: { type: "string", description: "Filter by status (open, closed, etc.)" },
+            page: { type: "number", description: "Page number (default: 1)" },
+            limit: { type: "number", description: "Items per page (default: 20)" },
         },
-        required: ["ids"],
+        required: ["projectId"],
     },
 };
-const CREATE_FOLDER_TOOL = {
-    name: "create_folder",
-    description: "Create a new folder in the active project for organizing testcases.",
+const MANAGE_TEST_CYCLE_TOOL = {
+    name: "manage_test_cycle",
+    description: "Manage test cycles: create, update, delete, get details, list/link/unlink/assign test cases. " +
+        "Set 'action' to: create, update, delete, get_details, get_testcases, link_testcases, unlink_testcases, assign_testcases.",
     inputSchema: {
         type: "object",
         properties: {
-            name: { type: "string", description: "Folder name (max 50 characters)" },
-            parentId: { type: "number", description: "Parent folder ID for subfolder (optional)" },
+            projectId: { type: "string", description: "Project ID" },
+            action: {
+                type: "string",
+                enum: [
+                    "create",
+                    "update",
+                    "delete",
+                    "get_details",
+                    "get_testcases",
+                    "link_testcases",
+                    "unlink_testcases",
+                    "assign_testcases",
+                ],
+                description: "Action to perform",
+            },
+            // Identifiers
+            cycleId: {
+                type: "string",
+                description: "Test cycle ID (e.g. TCYCLE-1). Required for update/delete/get_details/get_testcases/link/unlink/assign.",
+            },
+            // create/update fields
+            title: { type: "string", description: "[create/update] Cycle title" },
+            summary: { type: "string", description: "[create/update] Description" },
+            status: {
+                type: "string",
+                description: "[create/update] Status: open, closed, in progress",
+            },
+            planned_start_date: {
+                type: "string",
+                description: "[create/update] Start date (YYYY-MM-DD)",
+            },
+            planned_end_date: {
+                type: "string",
+                description: "[create/update] End date (YYYY-MM-DD)",
+            },
+            folder_id: {
+                type: "number",
+                description: "[create/update] Folder ID",
+            },
+            // delete
+            ids: {
+                type: "string",
+                description: "[delete] Comma-separated cycle IDs to delete",
+            },
+            // link/unlink/assign
+            testcase_ids: {
+                type: "string",
+                description: "[link_testcases/unlink_testcases/assign_testcases] Comma-separated test case IDs",
+            },
+            assignee_id: {
+                type: "number",
+                description: "[assign_testcases] User ID to assign",
+            },
+            // get_testcases params
+            search: { type: "string", description: "[get_testcases] Search text" },
+            page: { type: "number", description: "[get_testcases] Page number" },
+            limit: { type: "number", description: "[get_testcases] Items per page" },
         },
-        required: ["name"],
+        required: ["projectId", "action"],
     },
 };
-const CREATE_LABEL_TOOL = {
-    name: "create_label",
-    description: "Create new labels in the active project for categorizing testcases.",
+const EXECUTE_TESTS_TOOL = {
+    name: "execute_tests",
+    description: "Record test execution results for test cases in a test cycle. " +
+        "Pass a single result or an array of results. " +
+        "Valid execution statuses: pass, fail, blocked, not_executed, in_progress.",
     inputSchema: {
         type: "object",
         properties: {
-            values: { type: "string", description: "Comma-separated label names" },
+            projectId: { type: "string", description: "Project ID" },
+            cycleId: { type: "string", description: "Test cycle ID (e.g. TCYCLE-1)" },
+            results: {
+                type: "string",
+                description: 'JSON array of results: [{"testcase_id":"TEST-1","execution_status":"pass","actual_result":"Worked","environment":"staging"}]. ' +
+                    "Each object must have testcase_id and execution_status. actual_result and environment are optional.",
+            },
         },
-        required: ["values"],
+        required: ["projectId", "cycleId", "results"],
     },
 };
-const GET_USER_PROFILE_TOOL = {
-    name: "get_user_profile",
-    description: "Get current logged-in user profile information",
+const MANAGE_TEST_PLAN_TOOL = {
+    name: "manage_test_plan",
+    description: "Manage test plans: create, update, delete, list, get details, link/unlink cycles, get cycles, get test cases. " +
+        "Set 'action' to: create, update, delete, list, get_details, link_cycles, unlink_cycles, get_cycles, get_testcases.",
     inputSchema: {
         type: "object",
-        properties: {},
-        required: [],
+        properties: {
+            projectId: { type: "string", description: "Project ID" },
+            action: {
+                type: "string",
+                enum: [
+                    "create",
+                    "update",
+                    "delete",
+                    "list",
+                    "get_details",
+                    "link_cycles",
+                    "unlink_cycles",
+                    "get_cycles",
+                    "get_testcases",
+                ],
+                description: "Action to perform",
+            },
+            // Identifier
+            planId: {
+                type: "string",
+                description: "Test plan ID (e.g. TPLAN-1). Required for update/delete/get_details/link_cycles/unlink_cycles/get_cycles/get_testcases.",
+            },
+            // create/update fields
+            title: { type: "string", description: "[create/update] Plan title" },
+            summary: { type: "string", description: "[create/update] Description" },
+            status: { type: "string", description: "[create/update] Status" },
+            planned_start_date: {
+                type: "string",
+                description: "[create/update] Start date (YYYY-MM-DD)",
+            },
+            planned_end_date: {
+                type: "string",
+                description: "[create/update] End date (YYYY-MM-DD)",
+            },
+            folder_id: { type: "number", description: "[create/update] Folder ID" },
+            // delete
+            ids: {
+                type: "string",
+                description: "[delete] Comma-separated plan IDs to delete",
+            },
+            // link/unlink cycles
+            cycle_ids: {
+                type: "string",
+                description: "[link_cycles/unlink_cycles] Comma-separated test cycle IDs",
+            },
+            // list/get_cycles/get_testcases pagination
+            search: { type: "string", description: "[list/get_cycles/get_testcases] Search text" },
+            page: { type: "number", description: "[list/get_cycles/get_testcases] Page number" },
+            limit: { type: "number", description: "[list/get_cycles/get_testcases] Items per page" },
+        },
+        required: ["projectId", "action"],
     },
 };
-const SET_ACTIVE_PROJECT_TOOL = {
-    name: "set_active_project",
-    description: "Set active project AFTER user chooses from get_my_projects. All other tools use this project.",
+const GET_REPORT_TOOL = {
+    name: "get_report",
+    description: "Get reports and analytics for a project. Covers execution, coverage, trends, team, defects, and AI insights. " +
+        "Available report types: execution_summary, execution_by_cycle, execution_by_tester, execution_by_priority, " +
+        "execution_by_environment, execution_by_folder, requirement_coverage, traceability_matrix, " +
+        "failed_requirements, uncovered_requirements, testcase_coverage, unlinked_testcases, " +
+        "defects_by_folder, tester_workload, testcase_distribution, " +
+        "execution_trend, execution_burnup, execution_burndown, test_creation, cycle_comparison, " +
+        "scorecard_by_folder, scorecard_by_tester, created_vs_executed, execution_by_automation, " +
+        "defects_by_cycle, defects_by_tester, requirement_coverage_trend, " +
+        "flaky_tests, release_readiness, risk_heatmap_folder, risk_heatmap_feature, " +
+        "testcase_quality, predictive_failure, smart_prioritization, tester_effectiveness, " +
+        "stale_tests, defect_hotspots, cycle_health, suite_optimization, " +
+        "requirement_risk_matrix, execution_velocity, project_health.",
     inputSchema: {
         type: "object",
         properties: {
-            projectId: { type: "string", description: "Project ID chosen by user" },
+            projectId: { type: "string", description: "Project ID" },
+            report_type: {
+                type: "string",
+                description: "Report type (see description for full list)",
+            },
+            test_cycle_ids: {
+                type: "string",
+                description: "Comma-separated test cycle IDs to filter by",
+            },
+            test_plan_ids: {
+                type: "string",
+                description: "Comma-separated test plan IDs to filter by",
+            },
+            startDate: { type: "string", description: "Start date filter (YYYY-MM-DD)" },
+            endDate: { type: "string", description: "End date filter (YYYY-MM-DD)" },
+            granularity: {
+                type: "string",
+                enum: ["day", "week", "month"],
+                description: "Granularity for trend reports",
+            },
+            // cycle_comparison specific
+            cycle_ids: {
+                type: "string",
+                description: "[cycle_comparison] Comma-separated cycle IDs to compare",
+            },
         },
-        required: ["projectId"],
+        required: ["projectId", "report_type"],
     },
 };
-const GET_ACTIVE_PROJECT_TOOL = {
-    name: "get_active_project",
-    description: "Get the currently active project ID that is being used for operations",
-    inputSchema: {
-        type: "object",
-        properties: {},
-        required: [],
-    },
+// ═══════════════════════════════════════════════════════════════════════════════
+// REPORT TYPE → ENDPOINT MAPPING
+// ═══════════════════════════════════════════════════════════════════════════════
+const REPORT_TYPE_MAP = {
+    // Execution
+    execution_summary: "execution/summary",
+    execution_by_cycle: "execution/by-cycle",
+    execution_by_tester: "execution/by-tester",
+    execution_by_priority: "execution/by-priority",
+    execution_by_environment: "execution/by-environment",
+    execution_by_folder: "execution/by-folder",
+    // Coverage
+    requirement_coverage: "coverage/requirement-coverage",
+    traceability_matrix: "coverage/traceability-matrix",
+    failed_requirements: "coverage/failed-requirements",
+    uncovered_requirements: "coverage/uncovered-requirements",
+    testcase_coverage: "coverage/testcase-coverage",
+    unlinked_testcases: "coverage/unlinked-testcases",
+    // Defects
+    defects_by_folder: "defects/by-folder",
+    // Team
+    tester_workload: "team/tester-workload",
+    testcase_distribution: "team/testcase-distribution",
+    // Trends
+    execution_trend: "trends/execution-trend",
+    execution_burnup: "trends/execution-burnup",
+    execution_burndown: "trends/execution-burndown",
+    test_creation: "trends/test-creation",
+    cycle_comparison: "trends/cycle-comparison",
+    scorecard_by_folder: "trends/scorecard-by-folder",
+    scorecard_by_tester: "trends/scorecard-by-tester",
+    created_vs_executed: "trends/created-vs-executed",
+    execution_by_automation: "trends/execution-by-automation",
+    defects_by_cycle: "trends/defects-by-cycle",
+    defects_by_tester: "trends/defects-by-tester",
+    requirement_coverage_trend: "trends/requirement-coverage-trend",
+    // AI Insights
+    flaky_tests: "ai/flaky-tests",
+    release_readiness: "ai/release-readiness",
+    risk_heatmap_folder: "ai/risk-heatmap-folder",
+    risk_heatmap_feature: "ai/risk-heatmap-feature",
+    testcase_quality: "ai/testcase-quality",
+    predictive_failure: "ai/predictive-failure",
+    smart_prioritization: "ai/smart-prioritization",
+    tester_effectiveness: "ai/tester-effectiveness",
+    stale_tests: "ai/stale-tests",
+    defect_hotspots: "ai/defect-hotspots",
+    cycle_health: "ai/cycle-health",
+    suite_optimization: "ai/suite-optimization",
+    requirement_risk_matrix: "ai/requirement-risk-matrix",
+    execution_velocity: "ai/execution-velocity",
+    project_health: "ai/project-health",
 };
-// Create server instance
-const server = new Server({
-    name: "testkase-mcp-server",
-    version: "1.0.0",
-}, {
-    capabilities: {
-        tools: {},
-    },
-});
-// List available tools (14 tools)
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            GET_MY_PROJECTS_TOOL,
-            SET_ACTIVE_PROJECT_TOOL,
-            GET_ACTIVE_PROJECT_TOOL,
-            GET_TESTCASES_TOOL,
-            GET_TESTCASE_DETAIL_TOOL,
-            CREATE_TESTCASE_TOOL,
-            CREATE_BULK_TESTCASE_TOOL,
-            UPDATE_TESTCASE_FIELD_TOOL,
-            DELETE_TESTCASE_TOOL,
-            GET_FOLDERS_TOOL,
-            CREATE_FOLDER_TOOL,
-            GET_LABELS_TOOL,
-            CREATE_LABEL_TOOL,
-            GET_USER_PROFILE_TOOL,
-        ],
-    };
-});
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    try {
-        if (name === "get_my_projects") {
-            return await handleGetMyProjects(args);
-        }
-        else if (name === "set_active_project") {
-            return await handleSetActiveProject(args);
-        }
-        else if (name === "get_active_project") {
-            return await handleGetActiveProject();
-        }
-        else if (name === "get_testcases") {
-            return await handleGetTestcases(args);
+// ═══════════════════════════════════════════════════════════════════════════════
+// TOOL HANDLERS
+// ═══════════════════════════════════════════════════════════════════════════════
+// 1. list_projects
+async function handleListProjects(args) {
+    const data = await callApi("get", "projects/user/my-projects", {
+        query: {
+            search: p(args, "search"),
+            page: p(args, "page"),
+            limit: p(args, "limit"),
+        },
+    });
+    return jsonResponse(data);
+}
+// 2. get_project_structure
+async function handleGetProjectStructure(args) {
+    const projectId = p(args, "projectId", "project_id");
+    if (!projectId)
+        throw new Error("projectId is required");
+    const section = p(args, "section") || "TESTCASE";
+    const includeRaw = p(args, "include") || "folders,labels,members";
+    const includes = includeRaw.split(",").map((s) => s.trim().toLowerCase());
+    const orgId = await getOrganizationId();
+    const result = {};
+    const promises = [];
+    if (includes.includes("folders")) {
+        promises.push(callApi("get", "folders/get-folders", {
+            query: { projectId, section },
+        }).then((data) => {
+            result.folders = data;
+        }));
+    }
+    if (includes.includes("labels")) {
+        promises.push(callApi("get", `projects/labels/get-label/${projectId}`).then((data) => {
+            result.labels = data;
+        }));
+    }
+    if (includes.includes("members")) {
+        promises.push(callApi("get", `projects/${projectId}/team-members`).then((data) => {
+            result.members = data;
+        }));
+    }
+    await Promise.all(promises);
+    return jsonResponse(result);
+}
+// 3. search_testcases
+async function handleSearchTestcases(args) {
+    const projectId = p(args, "projectId", "project_id");
+    if (!projectId)
+        throw new Error("projectId is required");
+    const data = await callApi("get", `projects/testcases/get-testcase/${projectId}`, {
+        query: {
+            search: p(args, "search"),
+            filters: p(args, "filters"),
+            page: p(args, "page"),
+            limit: p(args, "limit"),
+            sortBy: p(args, "sortBy", "sort_by"),
+            sortOrder: p(args, "sortOrder", "sort_order"),
+        },
+    });
+    return jsonResponse(data);
+}
+// 4. get_testcase
+async function handleGetTestcase(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const testcaseId = p(args, "testcaseId", "testcase_id", "id");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!testcaseId)
+        throw new Error("testcaseId is required");
+    const data = await callApi("get", `projects/testcases/get-testcase-detail/${projectId}/${testcaseId}`);
+    return jsonResponse(data);
+}
+// 5. manage_testcase
+async function handleManageTestcase(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const action = p(args, "action");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!action)
+        throw new Error("action is required");
+    const orgId = await getOrganizationId();
+    switch (action) {
+        case "create": {
+            const title = p(args, "title", "name");
+            if (!title)
+                throw new Error("title is required for create action");
+            const testcaseData = { title };
+            if (p(args, "summary", "description"))
+                testcaseData.summary = p(args, "summary", "description");
+            if (p(args, "priority"))
+                testcaseData.priority = p(args, "priority");
+            if (p(args, "folder_id", "folderId"))
+                testcaseData.folder_id = p(args, "folder_id", "folderId");
+            const labelsRaw = p(args, "labels");
+            if (labelsRaw) {
+                testcaseData.labels =
+                    typeof labelsRaw === "string"
+                        ? labelsRaw.split(",").map((l) => l.trim())
+                        : labelsRaw;
+            }
+            // Parse test_steps
+            const stepsRaw = p(args, "test_steps", "testSteps", "steps");
+            const testSteps = stepsRaw
+                ? typeof stepsRaw === "string"
+                    ? JSON.parse(stepsRaw)
+                    : stepsRaw
+                : null;
+            // Step 1: Create testcase
+            const createResult = await callApi("post", `projects/testcases/create-testcase/${projectId}`, { body: testcaseData });
+            // Step 2: Add test steps if provided
+            const created = createResult?.data || createResult;
+            const tcId = created?.id || created?.testcaseId;
+            if (testSteps && Array.isArray(testSteps) && testSteps.length > 0 && tcId) {
+                await callApi("post", `projects/testcases/teststeps/${projectId}/${tcId}`, {
+                    body: { steps: testSteps },
+                });
+            }
+            return jsonResponse(createResult);
         }
-        else if (name === "get_testcase_detail") {
-            return await handleGetTestcaseDetail(args);
+        case "create_bulk": {
+            const rawTestcases = p(args, "testcases", "test_cases", "items");
+            if (!rawTestcases)
+                throw new Error("testcases is required for create_bulk action");
+            const testcases = typeof rawTestcases === "string" ? JSON.parse(rawTestcases) : rawTestcases;
+            // Separate test_steps for post-creation
+            const withSteps = testcases.map((tc) => {
+                const normalized = { title: tc.title || tc.name };
+                if (tc.summary || tc.description)
+                    normalized.summary = tc.summary || tc.description;
+                if (tc.priority)
+                    normalized.priority = tc.priority;
+                if (tc.folder_id || tc.folderId)
+                    normalized.folder_id = tc.folder_id || tc.folderId;
+                return {
+                    testcase: normalized,
+                    test_steps: tc.test_steps || tc.testSteps || tc.steps,
+                };
+            });
+            const cleanTestcases = withSteps.map((t) => t.testcase);
+            const bulkResult = await callApi("post", `projects/testcases/create-bulk-testcase/${projectId}`, { body: { testcases: cleanTestcases } });
+            // Add test steps for each created testcase
+            const results = bulkResult?.results || [];
+            let stepsCreated = 0;
+            for (let i = 0; i < results.length; i++) {
+                const r = results[i];
+                const steps = withSteps[i]?.test_steps;
+                if (r.status === "success" && steps?.length) {
+                    const tcId = r.testcaseId || r.id;
+                    if (tcId) {
+                        try {
+                            await callApi("post", `projects/testcases/teststeps/${projectId}/${tcId}`, {
+                                body: { steps },
+                            });
+                            stepsCreated++;
+                        }
+                        catch {
+                            // Non-fatal: steps failed but testcase was created
+                        }
+                    }
+                }
+            }
+            return jsonResponse({ ...bulkResult, steps_created_for: stepsCreated });
         }
-        else if (name === "create_testcase") {
-            return await handleCreateTestcase(args);
+        case "update": {
+            const ids = p(args, "ids", "testcase_ids", "testcaseIds");
+            const field = p(args, "field", "field_name", "fieldName");
+            const value = p(args, "value", "field_value", "fieldValue", "new_value");
+            if (!ids)
+                throw new Error("ids is required for update action");
+            if (!field)
+                throw new Error("field is required for update action");
+            if (value === undefined)
+                throw new Error("value is required for update action");
+            const idList = typeof ids === "string" ? ids.split(",").map((s) => s.trim()) : ids;
+            const data = await callApi("patch", `projects/testcases/update-field/${projectId}`, {
+                body: { ids: idList, field, value },
+            });
+            return jsonResponse(data);
         }
-        else if (name === "create_bulk_testcase") {
-            return await handleCreateBulkTestcase(args);
+        case "delete": {
+            const ids = p(args, "ids", "testcase_ids", "testcaseIds");
+            if (!ids)
+                throw new Error("ids is required for delete action");
+            const idList = typeof ids === "string" ? ids.split(",").map((s) => s.trim()) : ids;
+            const data = await callApi("delete", `projects/testcases/delete-testcase/${projectId}`, {
+                body: { ids: idList },
+            });
+            return jsonResponse(data);
         }
-        else if (name === "update_testcase_field") {
-            return await handleUpdateTestcaseField(args);
+        default:
+            throw new Error(`Unknown action: ${action}. Use: create, create_bulk, update, delete`);
+    }
+}
+// 6. manage_folder
+async function handleManageFolder(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const action = p(args, "action");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!action)
+        throw new Error("action is required");
+    const section = p(args, "section") || "TESTCASE";
+    const orgId = await getOrganizationId();
+    switch (action) {
+        case "create": {
+            const name = p(args, "name", "folder_name");
+            if (!name)
+                throw new Error("name is required for create action");
+            const body = {
+                organizationId: orgId,
+                projectId,
+                section,
+                name,
+            };
+            const parentId = p(args, "parentId", "parent_id");
+            if (parentId)
+                body.parentId = parentId;
+            const data = await callApi("post", "folders/create-folders", { body, skipOrgId: true });
+            return jsonResponse(data);
         }
-        else if (name === "delete_testcase") {
-            return await handleDeleteTestcase(args);
+        case "rename": {
+            const folderId = p(args, "folderId", "folder_id", "id");
+            const name = p(args, "name", "folder_name");
+            if (!folderId)
+                throw new Error("folderId is required for rename action");
+            if (!name)
+                throw new Error("name is required for rename action");
+            const data = await callApi("patch", `folders/${folderId}`, {
+                query: { projectId, section },
+                body: { name },
+            });
+            return jsonResponse(data);
         }
-        else if (name === "get_folders") {
-            return await handleGetFolders(args);
+        case "move": {
+            const folderId = p(args, "folderId", "folder_id", "id");
+            if (!folderId)
+                throw new Error("folderId is required for move action");
+            const parentId = p(args, "parentId", "parent_id");
+            const data = await callApi("patch", `folders/${folderId}/move`, {
+                query: { projectId, section },
+                body: { parentId: parentId ?? null },
+            });
+            return jsonResponse(data);
         }
-        else if (name === "create_folder") {
-            return await handleCreateFolder(args);
+        case "delete": {
+            const folderId = p(args, "folderId", "folder_id", "id");
+            if (!folderId)
+                throw new Error("folderId is required for delete action");
+            const data = await callApi("delete", `folders/delete/${folderId}`, {
+                query: { projectId, section },
+            });
+            return jsonResponse(data);
         }
-        else if (name === "get_labels") {
-            return await handleGetLabels(args);
+        default:
+            throw new Error(`Unknown action: ${action}. Use: create, rename, move, delete`);
+    }
+}
+// 7. search_test_cycles
+async function handleSearchTestCycles(args) {
+    const projectId = p(args, "projectId", "project_id");
+    if (!projectId)
+        throw new Error("projectId is required");
+    const data = await callApi("get", `projects/test-cycles/get-test-cycles/${projectId}`, {
+        query: {
+            search: p(args, "search"),
+            folderId: p(args, "folderId", "folder_id"),
+            status: p(args, "status"),
+            page: p(args, "page"),
+            limit: p(args, "limit"),
+        },
+    });
+    return jsonResponse(data);
+}
+// 8. manage_test_cycle
+async function handleManageTestCycle(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const action = p(args, "action");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!action)
+        throw new Error("action is required");
+    switch (action) {
+        case "create": {
+            const title = p(args, "title");
+            if (!title)
+                throw new Error("title is required for create action");
+            const body = { title };
+            if (p(args, "summary"))
+                body.summary = p(args, "summary");
+            if (p(args, "status"))
+                body.status = p(args, "status");
+            if (p(args, "planned_start_date", "plannedStartDate"))
+                body.planned_start_date = p(args, "planned_start_date", "plannedStartDate");
+            if (p(args, "planned_end_date", "plannedEndDate"))
+                body.planned_end_date = p(args, "planned_end_date", "plannedEndDate");
+            if (p(args, "folder_id", "folderId"))
+                body.folder_id = p(args, "folder_id", "folderId");
+            const data = await callApi("post", `projects/test-cycles/create-test-cycle/${projectId}`, { body });
+            return jsonResponse(data);
         }
-        else if (name === "create_label") {
-            return await handleCreateLabel(args);
+        case "update": {
+            const cycleId = p(args, "cycleId", "cycle_id", "id");
+            if (!cycleId)
+                throw new Error("cycleId is required for update action");
+            const body = { id: cycleId };
+            if (p(args, "title"))
+                body.title = p(args, "title");
+            if (p(args, "summary"))
+                body.summary = p(args, "summary");
+            if (p(args, "status"))
+                body.status = p(args, "status");
+            if (p(args, "planned_start_date", "plannedStartDate"))
+                body.planned_start_date = p(args, "planned_start_date", "plannedStartDate");
+            if (p(args, "planned_end_date", "plannedEndDate"))
+                body.planned_end_date = p(args, "planned_end_date", "plannedEndDate");
+            if (p(args, "folder_id", "folderId"))
+                body.folder_id = p(args, "folder_id", "folderId");
+            const data = await callApi("post", `projects/test-cycles/create-test-cycle/${projectId}`, { body });
+            return jsonResponse(data);
         }
-        else if (name === "get_user_profile") {
-            return await handleGetUserProfile(args);
+        case "delete": {
+            const ids = p(args, "ids", "cycleId", "cycle_id");
+            if (!ids)
+                throw new Error("ids (or cycleId) is required for delete action");
+            const idList = typeof ids === "string" ? ids.split(",").map((s) => s.trim()) : ids;
+            const data = await callApi("delete", `projects/test-cycles/delete-test-cycle/${projectId}`, { body: { ids: idList } });
+            return jsonResponse(data);
         }
-        throw new Error(`Unknown tool: ${name}`);
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error.message}`,
-                    },
-                ],
-                isError: true,
-            };
+        case "get_details": {
+            const cycleId = p(args, "cycleId", "cycle_id", "id");
+            if (!cycleId)
+                throw new Error("cycleId is required for get_details action");
+            const data = await callApi("get", `projects/test-cycles/get-test-cycle-details/${projectId}/${cycleId}`);
+            return jsonResponse(data);
         }
-        throw error;
-    }
-});
-// Handler for get_testcases tool
-async function handleGetTestcases(args) {
-    validateAuth();
-    // Get project and organization IDs (from args or cached)
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    // Build query parameters
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    if (args.page !== undefined)
-        queryParams.append("page", args.page.toString());
-    if (args.limit !== undefined)
-        queryParams.append("limit", args.limit.toString());
-    if (args.selectAll !== undefined)
-        queryParams.append("selectAll", args.selectAll.toString());
-    if (args.columns)
-        queryParams.append("columns", args.columns);
-    if (args.filters)
-        queryParams.append("filters", args.filters);
-    if (args.search)
-        queryParams.append("search", args.search);
-    if (args.searchType)
-        queryParams.append("searchType", args.searchType);
-    if (args.sortBy)
-        queryParams.append("sortBy", args.sortBy);
-    if (args.sortOrder)
-        queryParams.append("sortOrder", args.sortOrder);
-    if (args.create_start_date)
-        queryParams.append("create_start_date", args.create_start_date);
-    if (args.create_end_date)
-        queryParams.append("create_end_date", args.create_end_date);
-    if (args.updated_start_date)
-        queryParams.append("updated_start_date", args.updated_start_date);
-    if (args.updated_end_date)
-        queryParams.append("updated_end_date", args.updated_end_date);
-    // Construct API URL
-    const url = `${config.apiBaseUrl}/api/v1/projects/testcases/get-testcase/${projectId}?${queryParams.toString()}`;
-    // Prepare headers with PAT token
-    // The PAT token is sent as Bearer token and will be validated by TestKase's JwtAuthGuard
-    // which checks for 'xyz_' prefix and validates against the PAT database
-    const headers = {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${config.patToken}`,
-    };
-    try {
-        // Make API request
-        const response = await axios.get(url, { headers });
-        // Format the response
-        const data = response.data;
-        let resultText = `# Testcases for Project ${args.projectId}\n\n`;
-        if (data.data && Array.isArray(data.data)) {
-            resultText += `**Total Results:** ${data.total || data.data.length}\n`;
-            if (data.page)
-                resultText += `**Page:** ${data.page}\n`;
-            if (data.limit)
-                resultText += `**Limit:** ${data.limit}\n`;
-            resultText += `\n## Testcases (${data.data.length} items)\n\n`;
-            data.data.forEach((testcase, index) => {
-                resultText += `### ${index + 1}. ${testcase.title || "Untitled"}\n`;
-                resultText += `- **ID:** ${testcase.id}\n`;
-                if (testcase.status)
-                    resultText += `- **Status:** ${testcase.status}\n`;
-                if (testcase.priority)
-                    resultText += `- **Priority:** ${testcase.priority}\n`;
-                if (testcase.automated !== undefined)
-                    resultText += `- **Automated:** ${testcase.automated}\n`;
-                if (testcase.summary)
-                    resultText += `- **Summary:** ${testcase.summary}\n`;
-                if (testcase.owner_id)
-                    resultText += `- **Owner ID:** ${testcase.owner_id}\n`;
-                if (testcase.folder_id)
-                    resultText += `- **Folder ID:** ${testcase.folder_id}\n`;
-                if (testcase.created_at)
-                    resultText += `- **Created:** ${testcase.created_at}\n`;
-                if (testcase.updated_at)
-                    resultText += `- **Updated:** ${testcase.updated_at}\n`;
-                if (testcase.labels && Array.isArray(testcase.labels) && testcase.labels.length > 0) {
-                    resultText += `- **Labels:** ${testcase.labels.join(", ")}\n`;
-                }
-                if (testcase.features && Array.isArray(testcase.features) && testcase.features.length > 0) {
-                    resultText += `- **Features:** ${testcase.features.join(", ")}\n`;
-                }
-                resultText += `\n`;
+        case "get_testcases": {
+            const cycleId = p(args, "cycleId", "cycle_id", "id");
+            if (!cycleId)
+                throw new Error("cycleId is required for get_testcases action");
+            const data = await callApi("get", `projects/test-cycles/testcases/${projectId}/${cycleId}`, {
+                query: {
+                    search: p(args, "search"),
+                    page: p(args, "page"),
+                    limit: p(args, "limit"),
+                },
             });
+            return jsonResponse(data);
         }
-        else {
-            resultText += "No testcases found or unexpected response format.\n\n";
-            resultText += `**Raw Response:**\n\`\`\`json\n${JSON.stringify(data, null, 2)}\n\`\`\`\n`;
+        case "link_testcases": {
+            const cycleId = p(args, "cycleId", "cycle_id", "id");
+            const tcIds = p(args, "testcase_ids", "testcaseIds");
+            if (!cycleId)
+                throw new Error("cycleId is required for link_testcases action");
+            if (!tcIds)
+                throw new Error("testcase_ids is required for link_testcases action");
+            const idList = typeof tcIds === "string" ? tcIds.split(",").map((s) => s.trim()) : tcIds;
+            const data = await callApi("post", `projects/test-cycles/testcases/link/${projectId}/${cycleId}`, { body: { testcase_ids: idList } });
+            return jsonResponse(data);
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: resultText,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        if (axios.isAxiosError(error)) {
-            const axiosError = error;
-            let errorMessage = `API request failed: ${axiosError.message}`;
-            if (axiosError.response) {
-                errorMessage += `\nStatus: ${axiosError.response.status}`;
-                errorMessage += `\nResponse: ${JSON.stringify(axiosError.response.data)}`;
-            }
-            throw new Error(errorMessage);
+        case "unlink_testcases": {
+            const cycleId = p(args, "cycleId", "cycle_id", "id");
+            const tcIds = p(args, "testcase_ids", "testcaseIds");
+            if (!cycleId)
+                throw new Error("cycleId is required for unlink_testcases action");
+            if (!tcIds)
+                throw new Error("testcase_ids is required for unlink_testcases action");
+            const idList = typeof tcIds === "string" ? tcIds.split(",").map((s) => s.trim()) : tcIds;
+            const data = await callApi("delete", `projects/test-cycles/testcases/unlink/${projectId}/${cycleId}`, { body: { testcase_ids: idList } });
+            return jsonResponse(data);
         }
-        throw error;
-    }
-}
-// Handler for get_testcase_detail tool
-async function handleGetTestcaseDetail(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    // Handle different param names AI might use
-    const testcaseId = args.testcaseId || args.testcase_id || args.id;
-    if (!testcaseId) {
-        throw new Error("testcaseId is required");
-    }
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/testcases/get-testcase-detail/${projectId}/${testcaseId}?${queryParams.toString()}`;
-    try {
-        const response = await axios.get(url, {
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${config.patToken}`,
-            },
-        });
-        const data = response.data;
-        return formatResponse(data, `Testcase Detail: ${testcaseId}`);
-    }
-    catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for get_folders tool
-async function handleGetFolders(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    queryParams.append("projectId", projectId);
-    queryParams.append("section", "TESTCASE");
-    if (args.search) {
-        queryParams.append("search", args.search);
-    }
-    const url = `${config.apiBaseUrl}/api/v1/folders/get-folders?${queryParams.toString()}`;
-    try {
-        const response = await axios.get(url, {
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${config.patToken}`,
-            },
-        });
-        const data = response.data;
-        return formatResponse(data, `Folders for Project: ${args.projectId}`);
-    }
-    catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for get_labels tool
-async function handleGetLabels(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/labels/get-label/${projectId}?${queryParams.toString()}`;
-    try {
-        const response = await axios.get(url, {
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${config.patToken}`,
-            },
-        });
-        const data = response.data;
-        return formatResponse(data, `Labels for Project: ${args.projectId}`);
-    }
-    catch (error) {
-        throw handleApiError(error);
+        case "assign_testcases": {
+            const cycleId = p(args, "cycleId", "cycle_id", "id");
+            const tcIds = p(args, "testcase_ids", "testcaseIds");
+            const assigneeId = p(args, "assignee_id", "assigneeId");
+            if (!cycleId)
+                throw new Error("cycleId is required for assign_testcases action");
+            if (!tcIds)
+                throw new Error("testcase_ids is required for assign_testcases action");
+            if (!assigneeId)
+                throw new Error("assignee_id is required for assign_testcases action");
+            const idList = typeof tcIds === "string" ? tcIds.split(",").map((s) => s.trim()) : tcIds;
+            const data = await callApi("patch", `projects/test-cycles/testcases/assign/${projectId}/${cycleId}`, { body: { testcase_ids: idList, assignee_id: assigneeId } });
+            return jsonResponse(data);
+        }
+        default:
+            throw new Error(`Unknown action: ${action}. Use: create, update, delete, get_details, get_testcases, link_testcases, unlink_testcases, assign_testcases`);
     }
 }
-// Handler for get_my_projects tool
-async function handleGetMyProjects(args) {
-    validateAuth();
-    const queryParams = new URLSearchParams();
-    if (args.page)
-        queryParams.append("page", args.page.toString());
-    if (args.limit)
-        queryParams.append("limit", args.limit.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/user/my-projects?${queryParams.toString()}`;
-    try {
-        const response = await axios.get(url, {
-            headers: {
-                "Content-Type": "application/json",
-                "Authorization": `Bearer ${config.patToken}`,
-            },
-        });
-        const data = response.data;
-        return formatResponse(data, "My Projects");
+// 9. execute_tests
+async function handleExecuteTests(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const cycleId = p(args, "cycleId", "cycle_id");
+    const resultsRaw = p(args, "results");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!cycleId)
+        throw new Error("cycleId is required");
+    if (!resultsRaw)
+        throw new Error("results is required");
+    const results = typeof resultsRaw === "string" ? JSON.parse(resultsRaw) : resultsRaw;
+    if (!Array.isArray(results) || results.length === 0) {
+        throw new Error("results must be a non-empty array");
     }
-    catch (error) {
-        throw handleApiError(error);
+    // Single result → use PATCH update-execution endpoint
+    if (results.length === 1) {
+        const r = results[0];
+        const testcaseId = r.testcase_id || r.testcaseId;
+        if (!testcaseId)
+            throw new Error("testcase_id is required in each result");
+        const body = {
+            execution_status: r.execution_status || r.executionStatus,
+        };
+        if (r.actual_result || r.actualResult)
+            body.actual_result = r.actual_result || r.actualResult;
+        if (r.environment)
+            body.environment = r.environment;
+        const data = await callApi("patch", `projects/test-cycles/testcases/update-execution/${projectId}/${cycleId}/${testcaseId}`, { body });
+        return jsonResponse(data);
     }
+    // Multiple results → use POST execute-bulk endpoint
+    const bulkResults = results.map((r) => ({
+        testcase_id: r.testcase_id || r.testcaseId,
+        execution_status: r.execution_status || r.executionStatus,
+        ...(r.actual_result || r.actualResult
+            ? { actual_result: r.actual_result || r.actualResult }
+            : {}),
+        ...(r.environment ? { environment: r.environment } : {}),
+    }));
+    const data = await callApi("post", `projects/test-cycles/execute-bulk/${projectId}/${cycleId}`, { body: { results: bulkResults } });
+    return jsonResponse(data);
 }
-// Handler for create_testcase tool (handles test_steps internally)
-async function handleCreateTestcase(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    // Extract and parse test_steps (JSON string) before sending to API
-    const { test_steps: test_steps_raw, testSteps, labels: labels_raw, ...restArgs } = args;
-    // Handle different param names AI might use
-    const test_steps_input = test_steps_raw || testSteps;
-    const test_steps = test_steps_input ? (typeof test_steps_input === 'string' ? JSON.parse(test_steps_input) : test_steps_input) : null;
-    // Build testcaseData with normalized field names
-    const testcaseData = {};
-    // Title (required)
-    testcaseData.title = restArgs.title || restArgs.name || restArgs.testcase_title;
-    if (!testcaseData.title)
-        throw new Error("title is required");
-    // Summary/description
-    if (restArgs.summary || restArgs.description) {
-        testcaseData.summary = restArgs.summary || restArgs.description;
-    }
-    // Priority
-    if (restArgs.priority) {
-        testcaseData.priority = restArgs.priority;
-    }
-    // Folder ID - handle both snake_case and camelCase
-    const folderId = restArgs.folder_id || restArgs.folderId;
-    if (folderId) {
-        testcaseData.folder_id = folderId;
-    }
-    // Parse labels from comma-separated string
-    if (labels_raw) {
-        testcaseData.labels = typeof labels_raw === 'string' ? labels_raw.split(',').map((l) => l.trim()) : labels_raw;
-    }
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/testcases/create-testcase/${projectId}?${queryParams.toString()}`;
-    try {
-        // Step 1: Create testcase
-        const response = await axios.post(url, testcaseData, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-        });
-        const createdTestcase = response.data?.data || response.data;
-        const testcaseId = createdTestcase?.id || createdTestcase?.testcaseId;
-        // Step 2: If test_steps provided, create them
-        if (test_steps && Array.isArray(test_steps) && test_steps.length > 0 && testcaseId) {
-            const stepsUrl = `${config.apiBaseUrl}/api/v1/projects/testcases/teststeps/${projectId}/${testcaseId}?organizationId=${organizationId}`;
-            await axios.post(stepsUrl, { steps: test_steps }, {
-                headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
+// 10. manage_test_plan
+async function handleManageTestPlan(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const action = p(args, "action");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!action)
+        throw new Error("action is required");
+    switch (action) {
+        case "create": {
+            const title = p(args, "title");
+            if (!title)
+                throw new Error("title is required for create action");
+            const body = { title };
+            if (p(args, "summary"))
+                body.summary = p(args, "summary");
+            if (p(args, "status"))
+                body.status = p(args, "status");
+            if (p(args, "planned_start_date", "plannedStartDate"))
+                body.planned_start_date = p(args, "planned_start_date", "plannedStartDate");
+            if (p(args, "planned_end_date", "plannedEndDate"))
+                body.planned_end_date = p(args, "planned_end_date", "plannedEndDate");
+            if (p(args, "folder_id", "folderId"))
+                body.folder_id = p(args, "folder_id", "folderId");
+            const data = await callApi("post", `projects/test-plans/create-test-plan/${projectId}`, { body });
+            return jsonResponse(data);
+        }
+        case "update": {
+            const planId = p(args, "planId", "plan_id", "id");
+            if (!planId)
+                throw new Error("planId is required for update action");
+            const body = { id: planId };
+            if (p(args, "title"))
+                body.title = p(args, "title");
+            if (p(args, "summary"))
+                body.summary = p(args, "summary");
+            if (p(args, "status"))
+                body.status = p(args, "status");
+            if (p(args, "planned_start_date", "plannedStartDate"))
+                body.planned_start_date = p(args, "planned_start_date", "plannedStartDate");
+            if (p(args, "planned_end_date", "plannedEndDate"))
+                body.planned_end_date = p(args, "planned_end_date", "plannedEndDate");
+            if (p(args, "folder_id", "folderId"))
+                body.folder_id = p(args, "folder_id", "folderId");
+            const data = await callApi("post", `projects/test-plans/create-test-plan/${projectId}`, { body });
+            return jsonResponse(data);
+        }
+        case "delete": {
+            const ids = p(args, "ids", "planId", "plan_id");
+            if (!ids)
+                throw new Error("ids (or planId) is required for delete action");
+            const idList = typeof ids === "string" ? ids.split(",").map((s) => s.trim()) : ids;
+            const data = await callApi("delete", `projects/test-plans/delete-test-plan/${projectId}`, { body: { ids: idList } });
+            return jsonResponse(data);
+        }
+        case "list": {
+            const data = await callApi("get", `projects/test-plans/get-test-plans/${projectId}`, {
+                query: {
+                    search: p(args, "search"),
+                    page: p(args, "page"),
+                    limit: p(args, "limit"),
+                },
             });
+            return jsonResponse(data);
         }
-        return formatResponse(response.data, "Testcase Created" + (test_steps?.length ? ` with ${test_steps.length} test steps` : ""));
-    }
-    catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for create_bulk_testcase tool (handles test_steps internally)
-async function handleCreateBulkTestcase(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    // Handle different param names AI might use
-    const rawTestcases = args.testcases || args.test_cases || args.items;
-    if (!rawTestcases)
-        throw new Error("testcases is required (JSON array of testcases)");
-    const testcases = typeof rawTestcases === 'string' ? JSON.parse(rawTestcases) : rawTestcases;
-    // Normalize each testcase and separate test_steps for later processing
-    const testcasesWithSteps = testcases.map((tc) => {
-        // Normalize field names for each testcase
-        const normalized = {
-            title: tc.title || tc.name || tc.testcase_title,
-        };
-        if (tc.summary || tc.description)
-            normalized.summary = tc.summary || tc.description;
-        if (tc.priority)
-            normalized.priority = tc.priority;
-        if (tc.folder_id || tc.folderId)
-            normalized.folder_id = tc.folder_id || tc.folderId;
-        return {
-            testcase: normalized,
-            test_steps: tc.test_steps || tc.testSteps || tc.steps,
-        };
-    });
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/testcases/create-bulk-testcase/${projectId}?${queryParams.toString()}`;
-    try {
-        // Step 1: Create all testcases (without steps)
-        const cleanTestcases = testcasesWithSteps.map((t) => t.testcase);
-        const response = await axios.post(url, { testcases: cleanTestcases }, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-        });
-        const results = response.data?.results || [];
-        // Step 2: Create test steps for each successfully created testcase
-        let stepsCreated = 0;
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            const steps = testcasesWithSteps[i]?.test_steps;
-            if (result.status === 'success' && steps && Array.isArray(steps) && steps.length > 0) {
-                const testcaseId = result.testcaseId || result.id;
-                if (testcaseId) {
-                    try {
-                        const stepsUrl = `${config.apiBaseUrl}/api/v1/projects/testcases/teststeps/${projectId}/${testcaseId}?organizationId=${organizationId}`;
-                        await axios.post(stepsUrl, { steps }, {
-                            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-                        });
-                        stepsCreated++;
-                    }
-                    catch (e) {
-                        // Log but don't fail the whole operation
-                        console.error(`Failed to create steps for testcase ${testcaseId}`);
-                    }
-                }
-            }
+        case "get_details": {
+            const planId = p(args, "planId", "plan_id", "id");
+            if (!planId)
+                throw new Error("planId is required for get_details action");
+            const data = await callApi("get", `projects/test-plans/get-test-plan-details/${projectId}/${planId}`);
+            return jsonResponse(data);
         }
-        return formatResponse(response.data, `Bulk Testcases Created (${stepsCreated} with test steps)`);
-    }
-    catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for update_testcase_field tool
-async function handleUpdateTestcaseField(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    // Handle different param names AI might use
-    const ids = args.ids || args.testcase_ids || args.testcaseIds;
-    const field = args.field || args.field_name || args.fieldName;
-    const value = args.value || args.field_value || args.fieldValue || args.new_value;
-    if (!ids)
-        throw new Error("ids is required (comma-separated testcase IDs)");
-    if (!field)
-        throw new Error("field is required");
-    if (value === undefined)
-        throw new Error("value is required");
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/testcases/update-field/${projectId}?${queryParams.toString()}`;
-    try {
-        const response = await axios.patch(url, {
-            ids: ids.split(','),
-            field: field,
-            value: value,
-        }, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-        });
-        return formatResponse(response.data, "Testcase Field Updated");
-    }
-    catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for delete_testcase tool
-async function handleDeleteTestcase(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    // Handle different param names AI might use
-    const ids = args.ids || args.testcase_ids || args.testcaseIds;
-    if (!ids)
-        throw new Error("ids is required (comma-separated testcase IDs)");
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/testcases/delete-testcase/${projectId}?${queryParams.toString()}`;
-    try {
-        const response = await axios.delete(url, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-            data: { ids: ids.split(',') },
-        });
-        return formatResponse(response.data, "Testcase Deleted");
-    }
-    catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for create_folder tool
-async function handleCreateFolder(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    const url = `${config.apiBaseUrl}/api/v1/folders/create-folders`;
-    // Handle different param names AI might use
-    const folderName = args.name || args.folder_name;
-    if (!folderName) {
-        throw new Error("Folder name is required. Provide 'name' parameter.");
-    }
-    const parentId = args.parentId || args.parent_id;
-    const body = {
-        organizationId: organizationId,
-        projectId: projectId,
-        section: "TESTCASE",
-        name: folderName,
-        ...(parentId && { parentId: parentId }),
-    };
-    try {
-        const response = await axios.post(url, body, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-        });
-        return formatResponse(response.data, "Folder Created");
-    }
-    catch (error) {
-        throw handleApiError(error);
+        case "link_cycles": {
+            const planId = p(args, "planId", "plan_id", "id");
+            const cycleIds = p(args, "cycle_ids", "cycleIds");
+            if (!planId)
+                throw new Error("planId is required for link_cycles action");
+            if (!cycleIds)
+                throw new Error("cycle_ids is required for link_cycles action");
+            const idList = typeof cycleIds === "string" ? cycleIds.split(",").map((s) => s.trim()) : cycleIds;
+            const data = await callApi("post", `projects/test-plans/testcycles/link/${projectId}/${planId}`, { body: { test_cycle_ids: idList } });
+            return jsonResponse(data);
+        }
+        case "unlink_cycles": {
+            const planId = p(args, "planId", "plan_id", "id");
+            const cycleIds = p(args, "cycle_ids", "cycleIds");
+            if (!planId)
+                throw new Error("planId is required for unlink_cycles action");
+            if (!cycleIds)
+                throw new Error("cycle_ids is required for unlink_cycles action");
+            const idList = typeof cycleIds === "string" ? cycleIds.split(",").map((s) => s.trim()) : cycleIds;
+            const data = await callApi("delete", `projects/test-plans/testcycles/unlink/${projectId}/${planId}`, { body: { test_cycle_ids: idList } });
+            return jsonResponse(data);
+        }
+        case "get_cycles": {
+            const planId = p(args, "planId", "plan_id", "id");
+            if (!planId)
+                throw new Error("planId is required for get_cycles action");
+            const data = await callApi("get", `projects/test-plans/testcycles/list/${projectId}/${planId}`, {
+                query: {
+                    search: p(args, "search"),
+                    page: p(args, "page"),
+                    limit: p(args, "limit"),
+                },
+            });
+            return jsonResponse(data);
+        }
+        case "get_testcases": {
+            const planId = p(args, "planId", "plan_id", "id");
+            if (!planId)
+                throw new Error("planId is required for get_testcases action");
+            const data = await callApi("get", `projects/test-plans/testcases/list/${projectId}/${planId}`, {
+                query: {
+                    search: p(args, "search"),
+                    page: p(args, "page"),
+                    limit: p(args, "limit"),
+                },
+            });
+            return jsonResponse(data);
+        }
+        default:
+            throw new Error(`Unknown action: ${action}. Use: create, update, delete, list, get_details, link_cycles, unlink_cycles, get_cycles, get_testcases`);
     }
 }
-// Handler for create_label tool
-async function handleCreateLabel(args) {
-    validateAuth();
-    const projectId = getProjectId(args.projectId);
-    const organizationId = await getOrganizationId(args.organizationId);
-    const queryParams = new URLSearchParams();
-    queryParams.append("organizationId", organizationId.toString());
-    const url = `${config.apiBaseUrl}/api/v1/projects/labels/create/${projectId}?${queryParams.toString()}`;
-    // Handle different param names AI might use
-    const rawValues = args.values || args.labels || args.label_names || args.names;
-    if (!rawValues)
-        throw new Error("values is required (comma-separated label names)");
-    // Parse values from comma-separated string
-    const values = typeof rawValues === 'string' ? rawValues.split(',').map((v) => v.trim()) : rawValues;
-    try {
-        const response = await axios.post(url, { values }, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-        });
-        return formatResponse(response.data, "Label Created");
-    }
-    catch (error) {
-        throw handleApiError(error);
+// 11. get_report
+async function handleGetReport(args) {
+    const projectId = p(args, "projectId", "project_id");
+    const reportType = p(args, "report_type", "reportType");
+    if (!projectId)
+        throw new Error("projectId is required");
+    if (!reportType)
+        throw new Error("report_type is required");
+    const endpointPath = REPORT_TYPE_MAP[reportType];
+    if (!endpointPath) {
+        throw new Error(`Unknown report_type: ${reportType}. Valid types: ${Object.keys(REPORT_TYPE_MAP).join(", ")}`);
     }
+    const query = {};
+    // Common filters
+    if (p(args, "test_cycle_ids", "testCycleIds"))
+        query.test_cycle_ids = p(args, "test_cycle_ids", "testCycleIds");
+    if (p(args, "test_plan_ids", "testPlanIds"))
+        query.test_plan_ids = p(args, "test_plan_ids", "testPlanIds");
+    if (p(args, "startDate", "start_date"))
+        query.startDate = p(args, "startDate", "start_date");
+    if (p(args, "endDate", "end_date"))
+        query.endDate = p(args, "endDate", "end_date");
+    if (p(args, "granularity"))
+        query.granularity = p(args, "granularity");
+    // cycle_comparison specific
+    if (p(args, "cycle_ids", "cycleIds"))
+        query.cycle_ids = p(args, "cycle_ids", "cycleIds");
+    const data = await callApi("get", `projects/reports/${endpointPath}/${projectId}`, {
+        query,
+    });
+    return jsonResponse(data);
 }
-// Handler for get_user_profile tool
-async function handleGetUserProfile(args) {
-    validateAuth();
-    const url = `${config.apiBaseUrl}/api/v1/auth/me`;
+// ═══════════════════════════════════════════════════════════════════════════════
+// SERVER SETUP
+// ═══════════════════════════════════════════════════════════════════════════════
+const server = new Server({ name: "testkase-mcp-server", version: "2.1.0" }, { capabilities: { tools: {} } });
+// List all 11 tools
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        LIST_PROJECTS_TOOL,
+        GET_PROJECT_STRUCTURE_TOOL,
+        SEARCH_TESTCASES_TOOL,
+        GET_TESTCASE_TOOL,
+        MANAGE_TESTCASE_TOOL,
+        MANAGE_FOLDER_TOOL,
+        SEARCH_TEST_CYCLES_TOOL,
+        MANAGE_TEST_CYCLE_TOOL,
+        EXECUTE_TESTS_TOOL,
+        MANAGE_TEST_PLAN_TOOL,
+        GET_REPORT_TOOL,
+    ],
+}));
+// Route tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
     try {
-        const response = await axios.get(url, {
-            headers: { "Content-Type": "application/json", "Authorization": `Bearer ${config.patToken}` },
-        });
-        return formatResponse(response.data, "User Profile");
+        switch (name) {
+            case "list_projects":
+                return await handleListProjects(args);
+            case "get_project_structure":
+                return await handleGetProjectStructure(args);
+            case "search_testcases":
+                return await handleSearchTestcases(args);
+            case "get_testcase":
+                return await handleGetTestcase(args);
+            case "manage_testcase":
+                return await handleManageTestcase(args);
+            case "manage_folder":
+                return await handleManageFolder(args);
+            case "search_test_cycles":
+                return await handleSearchTestCycles(args);
+            case "manage_test_cycle":
+                return await handleManageTestCycle(args);
+            case "execute_tests":
+                return await handleExecuteTests(args);
+            case "manage_test_plan":
+                return await handleManageTestPlan(args);
+            case "get_report":
+                return await handleGetReport(args);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
     }
     catch (error) {
-        throw handleApiError(error);
-    }
-}
-// Handler for set_active_project tool
-async function handleSetActiveProject(args) {
-    // Handle different param names AI might use
-    const projectId = args.projectId || args.project_id;
-    if (!projectId) {
-        throw new Error("projectId is required");
-    }
-    setActiveProject(projectId);
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Active project set to: ${projectId}\n\nYou can now use other tools without specifying projectId.`,
-            },
-        ],
-    };
-}
-// Handler for get_active_project tool
-async function handleGetActiveProject() {
-    const projectId = cachedProjectId;
-    if (!projectId) {
+        const err = error instanceof Error ? error : handleApiError(error);
         return {
-            content: [
-                {
-                    type: "text",
-                    text: "No active project is set. Use set_active_project or specify projectId in your next command.",
-                },
-            ],
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
         };
     }
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Current active project: ${projectId}`,
-            },
-        ],
-    };
-}
-// Helper function to validate authentication
-function validateAuth() {
-    if (!config.patToken) {
-        throw new Error("Authentication required. Please set TESTKASE_PAT_TOKEN environment variable. " +
-            "Generate a Personal Access Token (PAT) from your TestKase account settings.");
-    }
-    if (!config.patToken.startsWith("xyz_")) {
-        throw new Error("Invalid PAT token format. TestKase PAT tokens must start with 'xyz_' prefix. " +
-            "Please generate a valid PAT from your TestKase account settings.");
-    }
-}
-// Helper function to format API response
-function formatResponse(data, title) {
-    let resultText = `# ${title}\n\n`;
-    resultText += "```json\n";
-    resultText += JSON.stringify(data, null, 2);
-    resultText += "\n```\n";
-    return {
-        content: [
-            {
-                type: "text",
-                text: resultText,
-            },
-        ],
-    };
-}
-// Helper function to handle API errors
-function handleApiError(error) {
-    if (axios.isAxiosError(error)) {
-        const axiosError = error;
-        let errorMessage = `API request failed: ${axiosError.message}`;
-        if (axiosError.response) {
-            errorMessage += `\nStatus: ${axiosError.response.status}`;
-            errorMessage += `\nResponse: ${JSON.stringify(axiosError.response.data)}`;
-        }
-        return new Error(errorMessage);
-    }
-    return error;
-}
-// Start the server
+});
+// Start
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("TestKase MCP Server running on stdio");
+    console.error("TestKase MCP Server v2.1.0 running on stdio (11 tools)");
 }
 main().catch((error) => {
     console.error("Fatal error in main():", error);