@browserstack/mcp-server 1.1.9 → 1.2.0

package/dist/tools/sdk-utils/types.d.ts

@@ -0,0 +1,39 @@
+export declare enum SDKSupportedLanguageEnum {
+    nodejs = "nodejs",
+    python = "python",
+    java = "java",
+    csharp = "csharp"
+}
+export type SDKSupportedLanguage = keyof typeof SDKSupportedLanguageEnum;
+export declare enum SDKSupportedBrowserAutomationFrameworkEnum {
+    playwright = "playwright",
+    selenium = "selenium",
+    cypress = "cypress"
+}
+export type SDKSupportedBrowserAutomationFramework = keyof typeof SDKSupportedBrowserAutomationFrameworkEnum;
+export declare enum SDKSupportedTestingFrameworkEnum {
+    jest = "jest",
+    codeceptjs = "codeceptjs",
+    playwright = "playwright",
+    pytest = "pytest",
+    robot = "robot",
+    behave = "behave",
+    cucumber = "cucumber",
+    nightwatch = "nightwatch",
+    webdriverio = "webdriverio",
+    mocha = "mocha",
+    junit4 = "junit4",
+    junit5 = "junit5",
+    testng = "testng",
+    serenity = "serenity",
+    cypress = "cypress",
+    nunit = "nunit",
+    mstest = "mstest",
+    xunit = "xunit",
+    specflow = "specflow",
+    reqnroll = "reqnroll"
+}
+export type SDKSupportedTestingFramework = keyof typeof SDKSupportedTestingFrameworkEnum;
+export type ConfigMapping = Record<SDKSupportedLanguageEnum, Partial<Record<SDKSupportedBrowserAutomationFrameworkEnum, Partial<Record<SDKSupportedTestingFrameworkEnum, {
+    instructions: (username: string, accessKey: string) => string;
+}>>>>>;

package/dist/tools/sdk-utils/types.js

@@ -26,6 +26,7 @@ export var SDKSupportedTestingFrameworkEnum;
     SDKSupportedTestingFrameworkEnum["junit4"] = "junit4";
     SDKSupportedTestingFrameworkEnum["junit5"] = "junit5";
     SDKSupportedTestingFrameworkEnum["testng"] = "testng";
+    SDKSupportedTestingFrameworkEnum["serenity"] = "serenity";
     SDKSupportedTestingFrameworkEnum["cypress"] = "cypress";
     SDKSupportedTestingFrameworkEnum["nunit"] = "nunit";
     SDKSupportedTestingFrameworkEnum["mstest"] = "mstest";

package/dist/tools/selfheal-utils/selfheal.d.ts

@@ -0,0 +1,11 @@
+interface SelectorMapping {
+    originalSelector: string;
+    healedSelector: string;
+    context: {
+        before: string;
+        after: string;
+    };
+}
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function getSelfHealSelectors(sessionId: string, config: BrowserStackConfig): Promise<SelectorMapping[]>;
+export {};

package/dist/tools/selfheal-utils/selfheal.js

@@ -1,17 +1,21 @@
 import { assertOkResponse } from "../../lib/utils.js";
-import config from "../../config.js";
-export async function getSelfHealSelectors(sessionId) {
-    const credentials = `${config.browserstackUsername}:${config.browserstackAccessKey}`;
-    const auth = Buffer.from(credentials).toString("base64");
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { apiClient } from "../../lib/apiClient.js";
+export async function getSelfHealSelectors(sessionId, config) {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
     const url = `https://api.browserstack.com/automate/sessions/${sessionId}/logs`;
-    const response = await fetch(url, {
+    const response = await apiClient.get({
+        url,
         headers: {
             "Content-Type": "application/json",
             Authorization: `Basic ${auth}`,
         },
     });
     await assertOkResponse(response, "session logs");
-    const logText = await response.text();
+    const logText = typeof response.data === "string"
+        ? response.data
+        : JSON.stringify(response.data);
     return extractHealedSelectors(logText);
 }
 function extractHealedSelectors(logText) {

package/dist/tools/selfheal.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../lib/types.js";
+export declare function fetchSelfHealSelectorTool(args: {
+    sessionId: string;
+}, config: BrowserStackConfig): Promise<CallToolResult>;
+export default function addSelfHealTools(server: McpServer, config: BrowserStackConfig): void;

package/dist/tools/selfheal.js

@@ -3,9 +3,9 @@ import { getSelfHealSelectors } from "./selfheal-utils/selfheal.js";
 import logger from "../logger.js";
 import { trackMCP } from "../lib/instrumentation.js";
 // Tool function that fetches self-healing selectors
-export async function fetchSelfHealSelectorTool(args) {
+export async function fetchSelfHealSelectorTool(args, config) {
     try {
-        const selectors = await getSelfHealSelectors(args.sessionId);
+        const selectors = await getSelfHealSelectors(args.sessionId, config);
         return {
             content: [
                 {
@@ -22,16 +22,16 @@ export async function fetchSelfHealSelectorTool(args) {
     }
 }
 // Registers the fetchSelfHealSelector tool with the MCP server
-export default function addSelfHealTools(server) {
+export default function addSelfHealTools(server, config) {
     server.tool("fetchSelfHealedSelectors", "Retrieves AI-generated, self-healed selectors for a BrowserStack Automate session to resolve flaky tests caused by dynamic DOM changes.", {
         sessionId: z.string().describe("The session ID of the test run"),
     }, async (args) => {
         try {
-            trackMCP("fetchSelfHealedSelectors", server.server.getClientVersion());
-            return await fetchSelfHealSelectorTool(args);
+            trackMCP("fetchSelfHealedSelectors", server.server.getClientVersion(), undefined, config);
+            return await fetchSelfHealSelectorTool(args, config);
         }
         catch (error) {
-            trackMCP("fetchSelfHealedSelectors", server.server.getClientVersion(), error);
+            trackMCP("fetchSelfHealedSelectors", server.server.getClientVersion(), error, config);
             const errorMessage = error instanceof Error ? error.message : "Unknown error";
             return {
                 content: [

package/dist/tools/testmanagement-utils/TCG-utils/api.d.ts

@@ -0,0 +1,34 @@
+import { DefaultFieldMaps, Scenario, CreateTestCasesFromFileArgs } from "./types.js";
+import { BrowserStackConfig } from "../../../lib/types.js";
+/**
+ * Fetch default and custom form fields for a project.
+ */
+export declare function fetchFormFields(projectId: string, config: BrowserStackConfig): Promise<{
+    default_fields: any;
+    custom_fields: any;
+}>;
+/**
+ * Trigger AI-based test case generation for a document.
+ */
+export declare function triggerTestCaseGeneration(document: string, documentId: number, folderId: string, projectId: string, source: string, config: BrowserStackConfig): Promise<string>;
+/**
+ * Initiate a fetch for test-case details; returns the traceRequestId for polling.
+ */
+export declare function fetchTestCaseDetails(documentId: number, folderId: string, projectId: string, testCaseIds: string[], source: string, config: BrowserStackConfig): Promise<string>;
+/**
+ * Poll for a given traceRequestId until all test-case details are returned.
+ */
+export declare function pollTestCaseDetails(traceRequestId: string, config: BrowserStackConfig): Promise<Record<string, any>>;
+/**
+ * Poll for scenarios & testcases, trigger detail fetches, then poll all details in parallel.
+ */
+export declare function pollScenariosTestDetails(args: CreateTestCasesFromFileArgs, traceId: string, context: any, documentId: number, source: string, config: BrowserStackConfig): Promise<Record<string, Scenario>>;
+/**
+ * Bulk-create generated test cases in BrowserStack.
+ */
+export declare function bulkCreateTestCases(scenariosMap: Record<string, Scenario>, projectId: string, folderId: string, fieldMaps: DefaultFieldMaps, booleanFieldId: number | undefined, traceId: string, context: any, documentId: number, config: BrowserStackConfig): Promise<string>;
+export declare function projectIdentifierToId(projectId: string, config: BrowserStackConfig): Promise<string>;
+export declare function testCaseIdentifierToDetails(projectId: string, testCaseIdentifier: string, config: BrowserStackConfig): Promise<{
+    testCaseId: string;
+    folderId: string;
+}>;

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

@@ -1,14 +1,15 @@
-import axios from "axios";
+import { apiClient } from "../../../lib/apiClient.js";
 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";
+import { getBrowserStackAuth } from "../../../lib/get-auth.js";
 /**
  * Fetch default and custom form fields for a project.
  */
-export async function fetchFormFields(projectId) {
-    const res = await axios.get(FORM_FIELDS_URL(projectId), {
+export async function fetchFormFields(projectId, config) {
+    const res = await apiClient.get({
+        url: FORM_FIELDS_URL(projectId),
         headers: {
-            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "API-TOKEN": getBrowserStackAuth(config),
         },
     });
     return res.data;
@@ -16,44 +17,48 @@ export async function fetchFormFields(projectId) {
 /**
  * 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`,
-    }, {
+export async function triggerTestCaseGeneration(document, documentId, folderId, projectId, source, config) {
+    const res = await apiClient.post({
+        url: TCG_TRIGGER_URL,
         headers: {
-            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "API-TOKEN": getBrowserStackAuth(config),
             "Content-Type": "application/json",
             "request-source": source,
         },
+        body: {
+            document,
+            documentId,
+            folderId,
+            projectId,
+            source,
+            webhookUrl: `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/webhooks/tcg`,
+        },
     });
     if (res.status !== 200) {
-        throw new Error(`Trigger failed: ${res.statusText}`);
+        throw new Error(`Trigger failed: ${res.statusText || res.status}`);
     }
     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) {
+export async function fetchTestCaseDetails(documentId, folderId, projectId, testCaseIds, source, config) {
     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,
-    }, {
+    const res = await apiClient.post({
+        url: FETCH_DETAILS_URL,
         headers: {
-            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "API-TOKEN": getBrowserStackAuth(config),
             "request-source": source,
             "Content-Type": "application/json",
         },
+        body: {
+            document_id: documentId,
+            folder_id: folderId,
+            project_id: projectId,
+            test_case_ids: testCaseIds,
+        },
     });
     if (res.data.data.success !== true) {
         throw new Error(`Fetch details failed: ${res.data.data.message}`);
@@ -63,16 +68,18 @@ export async function fetchTestCaseDetails(documentId, folderId, projectId, test
 /**
  * Poll for a given traceRequestId until all test-case details are returned.
  */
-export async function pollTestCaseDetails(traceRequestId) {
+export async function pollTestCaseDetails(traceRequestId, config) {
     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)}`, {}, {
+        const poll = await apiClient.post({
+            url: `${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceRequestId)}`,
             headers: {
-                "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                "API-TOKEN": getBrowserStackAuth(config),
             },
+            body: {},
         });
         if (!poll.data.data.success) {
             throw new Error(`Polling failed: ${poll.data.data.message}`);
@@ -96,7 +103,7 @@ export async function pollTestCaseDetails(traceRequestId) {
 /**
  * Poll for scenarios & testcases, trigger detail fetches, then poll all details in parallel.
  */
-export async function pollScenariosTestDetails(args, traceId, context, documentId, source) {
+export async function pollScenariosTestDetails(args, traceId, context, documentId, source, config) {
     const { folderId, projectReferenceId } = args;
     const scenariosMap = {};
     const detailPromises = [];
@@ -105,14 +112,16 @@ export async function pollScenariosTestDetails(args, traceId, context, documentI
     await new Promise((resolve, reject) => {
         const intervalId = setInterval(async () => {
             try {
-                const poll = await axios.post(`${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceId)}`, {}, {
+                const poll = await apiClient.post({
+                    url: `${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceId)}`,
                     headers: {
-                        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                        "API-TOKEN": getBrowserStackAuth(config),
                     },
+                    body: {},
                 });
                 if (poll.status !== 200) {
                     clearInterval(intervalId);
-                    reject(new Error(`Polling error: ${poll.statusText}`));
+                    reject(new Error(`Polling error: ${poll.statusText || poll.status}`));
                     return;
                 }
                 for (const msg of poll.data.data.message) {
@@ -140,8 +149,8 @@ export async function pollScenariosTestDetails(args, traceId, context, documentI
                                     ? [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));
+                            const reqId = await fetchTestCaseDetails(documentId, folderId, projectReferenceId, ids, source, config);
+                            detailPromises.push(pollTestCaseDetails(reqId, config));
                             scenariosMap[sc.id] ||= {
                                 id: sc.id,
                                 name: sc.name,
@@ -189,7 +198,7 @@ export async function pollScenariosTestDetails(args, traceId, context, documentI
 /**
  * Bulk-create generated test cases in BrowserStack.
  */
-export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fieldMaps, booleanFieldId, traceId, context, documentId) {
+export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fieldMaps, booleanFieldId, traceId, context, documentId, config) {
     const results = {};
     const total = Object.keys(scenariosMap).length;
     let doneCount = 0;
@@ -203,11 +212,13 @@ export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fie
             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, {
+            const resp = await apiClient.post({
+                url: BULK_CREATE_URL(projectId, folderId),
                 headers: {
-                    "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                    "API-TOKEN": getBrowserStackAuth(config),
                     "Content-Type": "application/json",
                 },
+                body: payload,
             });
             results[id] = resp.data;
             await context.sendNotification({
@@ -239,16 +250,17 @@ export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fie
     const resultString = `Total of ${testCaseCount} test cases created in ${total} scenarios.`;
     return resultString;
 }
-export async function projectIdentifierToId(projectId) {
+export async function projectIdentifierToId(projectId, config) {
     const url = `https://test-management.browserstack.com/api/v1/projects/?q=${projectId}`;
-    const response = await axios.get(url, {
+    const response = await apiClient.get({
+        url,
         headers: {
-            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "API-TOKEN": getBrowserStackAuth(config),
             accept: "application/json, text/plain, */*",
         },
     });
     if (response.data.success !== true) {
-        throw new Error(`Failed to fetch project ID: ${response.statusText}`);
+        throw new Error(`Failed to fetch project ID: ${response.statusText || response.status}`);
     }
     for (const project of response.data.projects) {
         if (project.identifier === projectId) {
@@ -257,16 +269,17 @@ export async function projectIdentifierToId(projectId) {
     }
     throw new Error(`Project with identifier ${projectId} not found.`);
 }
-export async function testCaseIdentifierToDetails(projectId, testCaseIdentifier) {
+export async function testCaseIdentifierToDetails(projectId, testCaseIdentifier, config) {
     const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/search?q[query]=${testCaseIdentifier}`;
-    const response = await axios.get(url, {
+    const response = await apiClient.get({
+        url,
         headers: {
-            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "API-TOKEN": getBrowserStackAuth(config),
             accept: "application/json, text/plain, */*",
         },
     });
     if (response.data.success !== true) {
-        throw new Error(`Failed to fetch test case details: ${response.statusText}`);
+        throw new Error(`Failed to fetch test case details: ${response.statusText || response.status}`);
     }
     // Check if test_cases array exists and has items
     if (!response.data.test_cases ||

package/dist/tools/testmanagement-utils/TCG-utils/config.d.ts

@@ -0,0 +1,5 @@
+export declare const TCG_TRIGGER_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/suggest-test-cases";
+export declare const TCG_POLL_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/test-cases-polling";
+export declare const FETCH_DETAILS_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/fetch-test-case-details";
+export declare const FORM_FIELDS_URL: (projectId: string) => string;
+export declare const BULK_CREATE_URL: (projectId: string, folderId: string) => string;

package/dist/tools/testmanagement-utils/TCG-utils/helpers.d.ts

@@ -0,0 +1,13 @@
+import { DefaultFieldMaps } from "./types.js";
+/**
+ * Build mappings for default fields for priority, status, and case type.
+ */
+export declare function buildDefaultFieldMaps(defaultFields: any): DefaultFieldMaps;
+/**
+ * Find a boolean custom field ID if present.
+ */
+export declare function findBooleanFieldId(customFields: any[]): number | undefined;
+/**
+ * Construct payload for creating a single test case in bulk.
+ */
+export declare function createTestCasePayload(tc: any, scenarioId: string, folderId: string, fieldMaps: DefaultFieldMaps, documentId: number, booleanFieldId?: number, traceId?: string): Record<string, any>;

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

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 /**
  * Build mappings for default fields for priority, status, and case type.
  */
@@ -41,7 +42,7 @@ export function createTestCasePayload(tc, scenarioId, folderId, fieldMaps, docum
                 rich_text_id: null,
                 scenario: scenarioId,
                 test_case_count: tc.test_case_count || 1,
-                uuid: tc.uuid || crypto.randomUUID?.() || "unknown-uuid",
+                uuid: tc.uuid || randomUUID() || "unknown-uuid",
                 "x-bstack-traceRequestId": traceId,
             },
         }),

package/dist/tools/testmanagement-utils/TCG-utils/types.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const CreateTestCasesFromFileSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    folderId: z.ZodString;
+    projectReferenceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    documentId: string;
+    folderId: string;
+    projectReferenceId: string;
+}, {
+    documentId: string;
+    folderId: string;
+    projectReferenceId: string;
+}>;
+export type CreateTestCasesFromFileArgs = z.infer<typeof CreateTestCasesFromFileSchema>;
+export interface DefaultFieldMaps {
+    priority: Record<string, number>;
+    status: Record<string, number>;
+    caseType: Record<string, number>;
+}
+export interface Scenario {
+    id: string;
+    name: string;
+    testcases: any[];
+    traceId?: string;
+}

package/dist/tools/testmanagement-utils/add-test-result.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for adding a test result to a test run.
+ */
+export declare const AddTestResultSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    test_run_id: z.ZodString;
+    test_result: z.ZodObject<{
+        status: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: string;
+        description?: string | undefined;
+    }, {
+        status: string;
+        description?: string | undefined;
+    }>;
+    test_case_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    project_identifier: string;
+    test_run_id: string;
+    test_result: {
+        status: string;
+        description?: string | undefined;
+    };
+    test_case_id: string;
+}, {
+    project_identifier: string;
+    test_run_id: string;
+    test_result: {
+        status: string;
+        description?: string | undefined;
+    };
+    test_case_id: string;
+}>;
+export type AddTestResultArgs = z.infer<typeof AddTestResultSchema>;
+/**
+ * Adds a test result to a specific test run via BrowserStack Test Management API.
+ */
+export declare function addTestResult(rawArgs: AddTestResultArgs, config: BrowserStackConfig): Promise<CallToolResult>;

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

@@ -1,7 +1,6 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js";
 /**
  * Schema for adding a test result to a test run.
  */
@@ -26,7 +25,7 @@ export const AddTestResultSchema = z.object({
 /**
  * Adds a test result to a specific test run via BrowserStack Test Management API.
  */
-export async function addTestResult(rawArgs) {
+export async function addTestResult(rawArgs, config) {
     try {
         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`;
@@ -34,12 +33,15 @@ export async function addTestResult(rawArgs) {
             test_result: args.test_result,
             test_case_id: args.test_case_id,
         };
-        const response = await axios.post(url, body, {
-            auth: {
-                username: config.browserstackUsername,
-                password: config.browserstackAccessKey,
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const response = await apiClient.post({
+            url,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
             },
-            headers: { "Content-Type": "application/json" },
+            body,
         });
         const data = response.data;
         if (!data.success) {
@@ -56,6 +58,17 @@ export async function addTestResult(rawArgs) {
         };
     }
     catch (err) {
-        return formatAxiosError(err, "Failed to add test result to test run");
+        const msg = err?.response?.data?.message ||
+            err?.response?.data?.error ||
+            err?.message ||
+            String(err);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to add test result to test run: ${msg}`,
+                },
+            ],
+        };
     }
 }

package/dist/tools/testmanagement-utils/create-lca-steps.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for creating LCA steps for a test case
+ */
+export declare const CreateLCAStepsSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    test_case_identifier: z.ZodString;
+    base_url: z.ZodString;
+    credentials: z.ZodOptional<z.ZodObject<{
+        username: z.ZodString;
+        password: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        username: string;
+        password: string;
+    }, {
+        username: string;
+        password: string;
+    }>>;
+    local_enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    test_name: z.ZodString;
+    test_case_details: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        preconditions: z.ZodString;
+        test_case_steps: z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            result: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            step: string;
+            result: string;
+        }, {
+            step: string;
+            result: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    }, {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    }>;
+    wait_for_completion: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    project_identifier: string;
+    test_case_identifier: string;
+    base_url: string;
+    local_enabled: boolean;
+    test_name: string;
+    test_case_details: {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    };
+    wait_for_completion: boolean;
+    credentials?: {
+        username: string;
+        password: string;
+    } | undefined;
+}, {
+    project_identifier: string;
+    test_case_identifier: string;
+    base_url: string;
+    test_name: string;
+    test_case_details: {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    };
+    credentials?: {
+        username: string;
+        password: string;
+    } | undefined;
+    local_enabled?: boolean | undefined;
+    wait_for_completion?: boolean | undefined;
+}>;
+export type CreateLCAStepsArgs = z.infer<typeof CreateLCAStepsSchema>;
+/**
+ * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management
+ */
+export declare function createLCASteps(args: CreateLCAStepsArgs, context: any, config: BrowserStackConfig): Promise<CallToolResult>;