@browserstack/mcp-server 1.1.9 → 1.2.1

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>;

package/dist/tools/testmanagement-utils/create-lca-steps.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
-import axios from "axios";
-import config from "../../config.js";
-import { formatAxiosError } from "../../lib/error.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { projectIdentifierToId, testCaseIdentifierToDetails, } from "./TCG-utils/api.js";
 import { pollLCAStatus } from "./poll-lca-status.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 /**
  * Schema for creating LCA steps for a test case
  */
@@ -50,12 +49,12 @@ export const CreateLCAStepsSchema = z.object({
 /**
  * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management
  */
-export async function createLCASteps(args, context) {
+export async function createLCASteps(args, context, config) {
     try {
         // Get the project ID from identifier
-        const projectId = await projectIdentifierToId(args.project_identifier);
+        const projectId = await projectIdentifierToId(args.project_identifier, config);
         // Get the test case ID and folder ID from identifier
-        const { testCaseId, folderId } = await testCaseIdentifierToDetails(projectId, args.test_case_identifier);
+        const { testCaseId, folderId } = await testCaseIdentifierToDetails(projectId, args.test_case_identifier, config);
         const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/${testCaseId}/lcnc`;
         const payload = {
             base_url: args.base_url,
@@ -66,67 +65,53 @@ export async function createLCASteps(args, context) {
             version: "v2",
             webhook_path: `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/${testCaseId}/webhooks/lcnc`,
         };
-        const response = await axios.post(url, payload, {
+        await apiClient.post({
+            url,
             headers: {
-                "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                "API-TOKEN": getBrowserStackAuth(config),
                 accept: "application/json, text/plain, */*",
                 "Content-Type": "application/json",
             },
+            body: payload,
         });
-        if (response.status >= 200 && response.status < 300) {
-            // Check if user wants to wait for completion
-            if (!args.wait_for_completion) {
+        // Check if user wants to wait for completion
+        if (!args.wait_for_completion) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                    },
+                    {
+                        type: "text",
+                        text: "LCA build started. Check the BrowserStack Lowcode Automation UI for completion status.",
+                    },
+                ],
+            };
+        }
+        // Start polling for LCA build completion
+        try {
+            const max_wait_minutes = 10; // Maximum wait time in minutes
+            const maxWaitMs = max_wait_minutes * 60 * 1000;
+            const lcaResult = await pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitMs, // max wait time
+            2 * 60 * 1000, // 2 minutes initial wait
+            10 * 1000, // 10 seconds interval
+            config);
+            if (lcaResult && lcaResult.status === "done") {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                            text: `Successfully created LCA steps for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
                         },
                         {
                             type: "text",
-                            text: "LCA build started. Check the BrowserStack Lowcode Automation UI for completion status.",
+                            text: `LCA build completed! Resource URL: ${lcaResult.resource_path}`,
                         },
                     ],
                 };
             }
-            // Start polling for LCA build completion
-            try {
-                const max_wait_minutes = 10; // Maximum wait time in minutes
-                const maxWaitMs = max_wait_minutes * 60 * 1000;
-                const lcaResult = await pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitMs, // max wait time
-                2 * 60 * 1000, // 2 minutes initial wait
-                10 * 1000);
-                if (lcaResult && lcaResult.status === "done") {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Successfully created LCA steps for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
-                            },
-                            {
-                                type: "text",
-                                text: `LCA build completed! Resource URL: ${lcaResult.resource_path}`,
-                            },
-                        ],
-                    };
-                }
-                else {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
-                            },
-                            {
-                                type: "text",
-                                text: `Warning: LCA build did not complete within ${max_wait_minutes} minutes. You can check the status later in the BrowserStack Test Management UI.`,
-                            },
-                        ],
-                    };
-                }
-            }
-            catch (pollError) {
-                console.error("Error during LCA polling:", pollError);
+            else {
                 return {
                     content: [
                         {
@@ -135,14 +120,26 @@ export async function createLCASteps(args, context) {
                         },
                         {
                             type: "text",
-                            text: "Warning: Error occurred while polling for LCA build completion. Check the BrowserStack Test Management UI for status.",
+                            text: `Warning: LCA build did not complete within ${max_wait_minutes} minutes. You can check the status later in the BrowserStack Test Management UI.`,
                         },
                     ],
                 };
             }
         }
-        else {
-            throw new Error(`Unexpected response: ${JSON.stringify(response.data)}`);
+        catch (pollError) {
+            console.error("Error during LCA polling:", pollError);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                    },
+                    {
+                        type: "text",
+                        text: "Warning: Error occurred while polling for LCA build completion. Check the BrowserStack Test Management UI for status.",
+                    },
+                ],
+            };
         }
     }
     catch (error) {
@@ -161,6 +158,18 @@ export async function createLCASteps(args, context) {
                 };
             }
         }
-        return formatAxiosError(error, "Failed to create LCA steps");
+        const msg = error?.response?.data?.message ||
+            error?.response?.data?.error ||
+            error?.message ||
+            String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to create LCA steps: ${msg}`,
+                },
+            ],
+            isError: true,
+        };
     }
 }