@browserstack/mcp-server 1.0.13 → 1.0.15

package/dist/tools/testmanagement-utils/TCG-utils/api.js

@@ -0,0 +1,259 @@
+import axios from "axios";
+import { TCG_TRIGGER_URL, TCG_POLL_URL, FETCH_DETAILS_URL, FORM_FIELDS_URL, BULK_CREATE_URL, } from "./config.js";
+import { createTestCasePayload } from "./helpers.js";
+import config from "../../../config.js";
+/**
+ * Fetch default and custom form fields for a project.
+ */
+export async function fetchFormFields(projectId) {
+    const res = await axios.get(FORM_FIELDS_URL(projectId), {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+        },
+    });
+    return res.data;
+}
+/**
+ * Trigger AI-based test case generation for a document.
+ */
+export async function triggerTestCaseGeneration(document, documentId, folderId, projectId, source) {
+    const res = await axios.post(TCG_TRIGGER_URL, {
+        document,
+        documentId,
+        folderId,
+        projectId,
+        source,
+        webhookUrl: `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/webhooks/tcg`,
+    }, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "Content-Type": "application/json",
+            "request-source": source,
+        },
+    });
+    if (res.status !== 200) {
+        throw new Error(`Trigger failed: ${res.statusText}`);
+    }
+    return res.data["x-bstack-traceRequestId"];
+}
+/**
+ * Initiate a fetch for test-case details; returns the traceRequestId for polling.
+ */
+export async function fetchTestCaseDetails(documentId, folderId, projectId, testCaseIds, source) {
+    if (testCaseIds.length === 0) {
+        throw new Error("No testCaseIds provided to fetchTestCaseDetails");
+    }
+    const res = await axios.post(FETCH_DETAILS_URL, {
+        document_id: documentId,
+        folder_id: folderId,
+        project_id: projectId,
+        test_case_ids: testCaseIds,
+    }, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "request-source": source,
+            "Content-Type": "application/json",
+        },
+    });
+    if (res.data.data.success !== true) {
+        throw new Error(`Fetch details failed: ${res.data.data.message}`);
+    }
+    return res.data.request_trace_id;
+}
+/**
+ * Poll for a given traceRequestId until all test-case details are returned.
+ */
+export async function pollTestCaseDetails(traceRequestId) {
+    const detailMap = {};
+    let done = false;
+    while (!done) {
+        // add a bit of jitter to avoid synchronized polling storms
+        await new Promise((r) => setTimeout(r, 10000 + Math.random() * 5000));
+        const poll = await axios.post(`${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceRequestId)}`, {}, {
+            headers: {
+                "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            },
+        });
+        if (!poll.data.data.success) {
+            throw new Error(`Polling failed: ${poll.data.data.message}`);
+        }
+        for (const msg of poll.data.data.message) {
+            if (msg.type === "termination") {
+                done = true;
+            }
+            if (msg.type === "testcase_details") {
+                for (const test of msg.data.testcase_details) {
+                    detailMap[test.id] = {
+                        steps: test.steps,
+                        preconditions: test.preconditions,
+                    };
+                }
+            }
+        }
+    }
+    return detailMap;
+}
+/**
+ * Poll for scenarios & testcases, trigger detail fetches, then poll all details in parallel.
+ */
+export async function pollScenariosTestDetails(args, traceId, context, documentId, source) {
+    const { folderId, projectReferenceId } = args;
+    const scenariosMap = {};
+    const detailPromises = [];
+    let iteratorCount = 0;
+    // Promisify interval-style polling using a wrapper
+    await new Promise((resolve, reject) => {
+        const intervalId = setInterval(async () => {
+            try {
+                const poll = await axios.post(`${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceId)}`, {}, {
+                    headers: {
+                        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                    },
+                });
+                if (poll.status !== 200) {
+                    clearInterval(intervalId);
+                    reject(new Error(`Polling error: ${poll.statusText}`));
+                    return;
+                }
+                for (const msg of poll.data.data.message) {
+                    if (msg.type === "scenario") {
+                        msg.data.scenarios.forEach((sc) => {
+                            scenariosMap[sc.id] = { id: sc.id, name: sc.name, testcases: [] };
+                        });
+                        const count = Object.keys(scenariosMap).length;
+                        await context.sendNotification({
+                            method: "notifications/progress",
+                            params: {
+                                progressToken: context._meta?.progressToken ?? traceId,
+                                progress: count,
+                                total: count,
+                                message: `Fetched ${count} scenarios`,
+                            },
+                        });
+                    }
+                    if (msg.type === "testcase") {
+                        const sc = msg.data.scenario;
+                        if (sc) {
+                            const array = Array.isArray(msg.data.testcases)
+                                ? msg.data.testcases
+                                : msg.data.testcases
+                                    ? [msg.data.testcases]
+                                    : [];
+                            const ids = array.map((tc) => tc.id || tc.test_case_id);
+                            const reqId = await fetchTestCaseDetails(documentId, folderId, projectReferenceId, ids, source);
+                            detailPromises.push(pollTestCaseDetails(reqId));
+                            scenariosMap[sc.id] ||= {
+                                id: sc.id,
+                                name: sc.name,
+                                testcases: [],
+                                traceId,
+                            };
+                            scenariosMap[sc.id].testcases.push(...array);
+                            iteratorCount++;
+                            const total = Object.keys(scenariosMap).length;
+                            await context.sendNotification({
+                                method: "notifications/progress",
+                                params: {
+                                    progressToken: context._meta?.progressToken ?? traceId,
+                                    progress: iteratorCount,
+                                    total,
+                                    message: `Fetched ${array.length} test cases for scenario ${iteratorCount} out of ${total}`,
+                                },
+                            });
+                        }
+                    }
+                    if (msg.type === "termination") {
+                        clearInterval(intervalId);
+                        resolve();
+                    }
+                }
+            }
+            catch (err) {
+                clearInterval(intervalId);
+                reject(err);
+            }
+        }, 10000); // 10 second interval
+    });
+    // once all detail fetches are triggered, wait for them to complete
+    const detailsList = await Promise.all(detailPromises);
+    const allDetails = detailsList.reduce((acc, cur) => ({ ...acc, ...cur }), {});
+    // attach the fetched detail objects back to each testcase
+    for (const scenario of Object.values(scenariosMap)) {
+        scenario.testcases = scenario.testcases.map((tc) => ({
+            ...tc,
+            ...(allDetails[tc.id || tc.test_case_id] ?? {}),
+        }));
+    }
+    return scenariosMap;
+}
+/**
+ * Bulk-create generated test cases in BrowserStack.
+ */
+export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fieldMaps, booleanFieldId, traceId, context, documentId) {
+    const results = {};
+    const total = Object.keys(scenariosMap).length;
+    let doneCount = 0;
+    let testCaseCount = 0;
+    for (const { id, testcases } of Object.values(scenariosMap)) {
+        const testCaseLength = testcases.length;
+        testCaseCount += testCaseLength;
+        if (testCaseLength === 0)
+            continue;
+        const payload = {
+            test_cases: testcases.map((tc) => createTestCasePayload(tc, id, folderId, fieldMaps, documentId, booleanFieldId, traceId)),
+        };
+        try {
+            const resp = await axios.post(BULK_CREATE_URL(projectId, folderId), payload, {
+                headers: {
+                    "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            results[id] = resp.data;
+            await context.sendNotification({
+                method: "notifications/progress",
+                params: {
+                    progressToken: context._meta?.progressToken ?? "bulk-create",
+                    message: `Bulk create done for scenario ${doneCount} of ${total}`,
+                    total,
+                    progress: doneCount,
+                },
+            });
+        }
+        catch (error) {
+            //send notification
+            await context.sendNotification({
+                method: "notifications/progress",
+                params: {
+                    progressToken: context._meta?.progressToken ?? traceId,
+                    message: `Bulk create failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    total,
+                    progress: doneCount,
+                },
+            });
+            //continue to next scenario
+            continue;
+        }
+        doneCount++;
+    }
+    const resultString = `Total of ${testCaseCount} test cases created in ${total} scenarios.`;
+    return resultString;
+}
+export async function projectIdentifierToId(projectId) {
+    const url = `https://test-management.browserstack.com/api/v1/projects/?q=${projectId}`;
+    const response = await axios.get(url, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            accept: "application/json, text/plain, */*",
+        },
+    });
+    if (response.data.success !== true) {
+        throw new Error(`Failed to fetch project ID: ${response.statusText}`);
+    }
+    for (const project of response.data.projects) {
+        if (project.identifier === projectId) {
+            return project.id;
+        }
+    }
+    throw new Error(`Project with identifier ${projectId} not found.`);
+}

package/dist/tools/testmanagement-utils/TCG-utils/config.js

@@ -0,0 +1,5 @@
+export const TCG_TRIGGER_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/suggest-test-cases";
+export const TCG_POLL_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/test-cases-polling";
+export const FETCH_DETAILS_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/fetch-test-case-details";
+export const FORM_FIELDS_URL = (projectId) => `https://test-management.browserstack.com/api/v1/projects/${projectId}/form-fields-v2`;
+export const BULK_CREATE_URL = (projectId, folderId) => `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/bulk-test-cases`;

package/dist/tools/testmanagement-utils/TCG-utils/helpers.js

@@ -0,0 +1,53 @@
+/**
+ * Build mappings for default fields for priority, status, and case type.
+ */
+export function buildDefaultFieldMaps(defaultFields) {
+    const priority = Object.fromEntries(defaultFields.priority.values.map((v) => [
+        v.name.toLowerCase(),
+        v.value,
+    ]));
+    const status = Object.fromEntries(defaultFields.status.values.map((v) => [v.internal_name, v.value]));
+    const caseType = Object.fromEntries(defaultFields.case_type.values.map((v) => [v.internal_name, v.value]));
+    return { priority, status, caseType };
+}
+/**
+ * Find a boolean custom field ID if present.
+ */
+export function findBooleanFieldId(customFields) {
+    const boolField = customFields.find((f) => f.field_type === "field_boolean");
+    return boolField?.id;
+}
+/**
+ * Construct payload for creating a single test case in bulk.
+ */
+export function createTestCasePayload(tc, scenarioId, folderId, fieldMaps, documentId, booleanFieldId, traceId) {
+    const pri = tc.priority ?? "Medium";
+    const stat = fieldMaps.status["active"];
+    const ct = fieldMaps.caseType["functional"];
+    return {
+        attachments: [documentId],
+        name: tc.name,
+        description: tc.description,
+        test_case_folder_id: folderId,
+        priority: pri,
+        status: stat,
+        case_type: ct,
+        automation_status: "not_automated",
+        fetch_ai_test_case_details: true,
+        template: "test_case_steps",
+        metadata: JSON.stringify({
+            ai_prompt: {
+                attachment_id: documentId,
+                rich_text_id: null,
+                scenario: scenarioId,
+                test_case_count: tc.test_case_count || 1,
+                uuid: tc.uuid || crypto.randomUUID?.() || "unknown-uuid",
+                "x-bstack-traceRequestId": traceId,
+            },
+        }),
+        tags: ["AI Generated", "MCP Generated"],
+        custom_fields: booleanFieldId ? { [booleanFieldId]: false } : undefined,
+        test_case_steps: tc.steps,
+        preconditions: tc.preconditions,
+    };
+}

package/dist/tools/testmanagement-utils/TCG-utils/types.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const CreateTestCasesFromFileSchema = z.object({
+    documentId: z.string().describe("Internal document identifier"),
+    folderId: z.string().describe("BrowserStack folder ID"),
+    projectReferenceId: z
+        .string()
+        .describe("The BrowserStack project reference ID is a unique identifier found in the project URL within the BrowserStack Test Management Platform. This ID is also returned by the Upload Document tool."),
+});

package/dist/tools/testmanagement-utils/add-test-result.js

@@ -1,50 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddTestResultSchema = void 0;
-exports.addTestResult = addTestResult;
-const axios_1 = __importDefault(require("axios"));
-const config_1 = __importDefault(require("../../config"));
-const zod_1 = require("zod");
-const error_1 = require("../../lib/error");
+import axios from "axios";
+import config from "../../config.js";
+import { z } from "zod";
+import { formatAxiosError } from "../../lib/error.js";
 /**
  * Schema for adding a test result to a test run.
  */
-exports.AddTestResultSchema = zod_1.z.object({
-    project_identifier: zod_1.z
+export const AddTestResultSchema = z.object({
+    project_identifier: z
         .string()
-        .describe("Identifier of the project (e.g., PR-12345)"),
-    test_run_id: zod_1.z.string().describe("Identifier of the test run (e.g., TR-678)"),
-    test_result: zod_1.z.object({
-        status: zod_1.z
+        .describe("Identifier of the project (Starts with 'PR-')"),
+    test_run_id: z.string().describe("Identifier of the test run (e.g., TR-678)"),
+    test_result: z.object({
+        status: z
             .string()
             .describe("Status of the test result, e.g., 'passed', 'failed'."),
-        description: zod_1.z
+        description: z
             .string()
             .optional()
             .describe("Optional description of the test result."),
     }),
-    test_case_id: zod_1.z
+    test_case_id: z
         .string()
         .describe("Identifier of the test case, e.g., 'TC-13'."),
 });
 /**
  * Adds a test result to a specific test run via BrowserStack Test Management API.
  */
-async function addTestResult(rawArgs) {
+export async function addTestResult(rawArgs) {
     try {
-        const args = exports.AddTestResultSchema.parse(rawArgs);
+        const args = AddTestResultSchema.parse(rawArgs);
         const url = `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(args.project_identifier)}/test-runs/${encodeURIComponent(args.test_run_id)}/results`;
         const body = {
             test_result: args.test_result,
             test_case_id: args.test_case_id,
         };
-        const response = await axios_1.default.post(url, body, {
+        const response = await axios.post(url, body, {
             auth: {
-                username: config_1.default.browserstackUsername,
-                password: config_1.default.browserstackAccessKey,
+                username: config.browserstackUsername,
+                password: config.browserstackAccessKey,
             },
             headers: { "Content-Type": "application/json" },
         });
@@ -63,6 +56,6 @@ async function addTestResult(rawArgs) {
         };
     }
     catch (err) {
-        return (0, error_1.formatAxiosError)(err, "Failed to add test result to test run");
+        return formatAxiosError(err, "Failed to add test result to test run");
     }
 }

package/dist/tools/testmanagement-utils/create-project-folder.js

@@ -1,34 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateProjFoldSchema = void 0;
-exports.createProjectOrFolder = createProjectOrFolder;
-const axios_1 = __importDefault(require("axios"));
-const config_1 = __importDefault(require("../../config"));
-const zod_1 = require("zod");
-const error_1 = require("../../lib/error"); // or correct path
+import axios from "axios";
+import config from "../../config.js";
+import { z } from "zod";
+import { formatAxiosError } from "../../lib/error.js"; // or correct path
 // Schema for combined project/folder creation
-exports.CreateProjFoldSchema = zod_1.z.object({
-    project_name: zod_1.z
+export const CreateProjFoldSchema = z.object({
+    project_name: z
         .string()
         .optional()
         .describe("Name of the project to create."),
-    project_description: zod_1.z
+    project_description: z
         .string()
         .optional()
         .describe("Description for the new project."),
-    project_identifier: zod_1.z
+    project_identifier: z
         .string()
         .optional()
         .describe("Existing project identifier to use for folder creation."),
-    folder_name: zod_1.z.string().optional().describe("Name of the folder to create."),
-    folder_description: zod_1.z
+    folder_name: z.string().optional().describe("Name of the folder to create."),
+    folder_description: z
         .string()
         .optional()
         .describe("Description for the new folder."),
-    parent_id: zod_1.z
+    parent_id: z
         .number()
         .optional()
         .describe("Parent folder ID; if omitted, folder is created at root."),
@@ -36,8 +29,8 @@ exports.CreateProjFoldSchema = zod_1.z.object({
 /**
  * Creates a project and/or folder in BrowserStack Test Management.
  */
-async function createProjectOrFolder(args) {
-    const { project_name, project_description, project_identifier, folder_name, folder_description, parent_id, } = exports.CreateProjFoldSchema.parse(args);
+export async function createProjectOrFolder(args) {
+    const { project_name, project_description, project_identifier, folder_name, folder_description, parent_id, } = CreateProjFoldSchema.parse(args);
     if (!project_name && !project_identifier && !folder_name) {
         throw new Error("Provide project_name (to create project), or project_identifier and folder_name (to create folder).");
     }
@@ -45,10 +38,10 @@ async function createProjectOrFolder(args) {
     // Step 1: Create project if project_name provided
     if (project_name) {
         try {
-            const res = await axios_1.default.post("https://test-management.browserstack.com/api/v2/projects", { project: { name: project_name, description: project_description } }, {
+            const res = await axios.post("https://test-management.browserstack.com/api/v2/projects", { project: { name: project_name, description: project_description } }, {
                 auth: {
-                    username: config_1.default.browserstackUsername,
-                    password: config_1.default.browserstackAccessKey,
+                    username: config.browserstackUsername,
+                    password: config.browserstackAccessKey,
                 },
                 headers: { "Content-Type": "application/json" },
             });
@@ -59,7 +52,7 @@ async function createProjectOrFolder(args) {
             projId = res.data.project.identifier;
         }
         catch (err) {
-            return (0, error_1.formatAxiosError)(err, "Failed to create project..");
+            return formatAxiosError(err, "Failed to create project..");
         }
     }
     // Step 2: Create folder if folder_name provided
@@ -67,7 +60,7 @@ async function createProjectOrFolder(args) {
         if (!projId)
             throw new Error("Cannot create folder without project_identifier.");
         try {
-            const res = await axios_1.default.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(projId)}/folders`, {
+            const res = await axios.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(projId)}/folders`, {
                 folder: {
                     name: folder_name,
                     description: folder_description,
@@ -75,8 +68,8 @@ async function createProjectOrFolder(args) {
                 },
             }, {
                 auth: {
-                    username: config_1.default.browserstackUsername,
-                    password: config_1.default.browserstackAccessKey,
+                    username: config.browserstackUsername,
+                    password: config.browserstackAccessKey,
                 },
                 headers: { "Content-Type": "application/json" },
             });
@@ -95,7 +88,7 @@ async function createProjectOrFolder(args) {
             };
         }
         catch (err) {
-            return (0, error_1.formatAxiosError)(err, "Failed to create folder.");
+            return formatAxiosError(err, "Failed to create folder.");
         }
     }
     // Only project was created

package/dist/tools/testmanagement-utils/create-testcase.js

@@ -1,64 +1,56 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateTestCaseSchema = void 0;
-exports.sanitizeArgs = sanitizeArgs;
-exports.createTestCase = createTestCase;
-const axios_1 = __importDefault(require("axios"));
-const config_1 = __importDefault(require("../../config"));
-const zod_1 = require("zod");
-const error_1 = require("../../lib/error"); // or correct
-exports.CreateTestCaseSchema = zod_1.z.object({
-    project_identifier: zod_1.z
+import axios from "axios";
+import config from "../../config.js";
+import { z } from "zod";
+import { formatAxiosError } from "../../lib/error.js"; // or correct
+export const CreateTestCaseSchema = z.object({
+    project_identifier: z
         .string()
         .describe("The ID of the BrowserStack project where the test case should be created. If no project identifier is provided, ask the user if they would like to create a new project using the createProjectOrFolder tool."),
-    folder_id: zod_1.z
+    folder_id: z
         .string()
         .describe("The ID of the folder within the project where the test case should be created. If not provided, ask the user if they would like to create a new folder using the createProjectOrFolder tool."),
-    name: zod_1.z.string().describe("Name of the test case."),
-    description: zod_1.z
+    name: z.string().describe("Name of the test case."),
+    description: z
         .string()
         .optional()
         .describe("Brief description of the test case."),
-    owner: zod_1.z
+    owner: z
         .string()
         .email()
         .describe("Email of the test case owner.")
         .optional(),
-    preconditions: zod_1.z
+    preconditions: z
         .string()
         .optional()
         .describe("Any preconditions (HTML allowed)."),
-    test_case_steps: zod_1.z
-        .array(zod_1.z.object({
-        step: zod_1.z.string().describe("Action to perform in this step."),
-        result: zod_1.z.string().describe("Expected result of this step."),
+    test_case_steps: z
+        .array(z.object({
+        step: z.string().describe("Action to perform in this step."),
+        result: z.string().describe("Expected result of this step."),
     }))
         .describe("List of steps and expected results."),
-    issues: zod_1.z
-        .array(zod_1.z.string())
+    issues: z
+        .array(z.string())
         .optional()
         .describe("List of the linked Jira, Asana or Azure issues ID's. This should be strictly in array format not the string of json."),
-    issue_tracker: zod_1.z
+    issue_tracker: z
         .object({
-        name: zod_1.z
+        name: z
             .string()
             .describe("Issue tracker name,  For example, use jira for Jira, azure for Azure DevOps, or asana for Asana."),
-        host: zod_1.z.string().url().describe("Base URL of the issue tracker."),
+        host: z.string().url().describe("Base URL of the issue tracker."),
     })
         .optional(),
-    tags: zod_1.z
-        .array(zod_1.z.string())
+    tags: z
+        .array(z.string())
         .optional()
         .describe("Tags to attach to the test case. This should be strictly in array format not the string of json"),
-    custom_fields: zod_1.z
-        .record(zod_1.z.string(), zod_1.z.string())
+    custom_fields: z
+        .record(z.string(), z.string())
         .optional()
         .describe("Map of custom field names to values."),
 });
-function sanitizeArgs(args) {
+export function sanitizeArgs(args) {
     const cleaned = { ...args };
     if (cleaned.description === null)
         delete cleaned.description;
@@ -74,13 +66,13 @@ function sanitizeArgs(args) {
     }
     return cleaned;
 }
-async function createTestCase(params) {
+export async function createTestCase(params) {
     const body = { test_case: params };
     try {
-        const response = await axios_1.default.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(params.project_identifier)}/folders/${encodeURIComponent(params.folder_id)}/test-cases`, body, {
+        const response = await axios.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(params.project_identifier)}/folders/${encodeURIComponent(params.folder_id)}/test-cases`, body, {
             auth: {
-                username: config_1.default.browserstackUsername,
-                password: config_1.default.browserstackAccessKey,
+                username: config.browserstackUsername,
+                password: config.browserstackAccessKey,
             },
             headers: { "Content-Type": "application/json" },
         });
@@ -110,6 +102,6 @@ async function createTestCase(params) {
     }
     catch (err) {
         // Delegate to our centralized Axios error formatter
-        return (0, error_1.formatAxiosError)(err, "Failed to create test case");
+        return formatAxiosError(err, "Failed to create test case");
     }
 }