@browserstack/mcp-server 1.1.9 → 1.2.1

package/dist/tools/testmanagement-utils/create-project-folder.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare const CreateProjFoldSchema: z.ZodObject<{
+    project_name: z.ZodOptional<z.ZodString>;
+    project_description: z.ZodOptional<z.ZodString>;
+    project_identifier: z.ZodOptional<z.ZodString>;
+    folder_name: z.ZodOptional<z.ZodString>;
+    folder_description: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    project_name?: string | undefined;
+    project_description?: string | undefined;
+    project_identifier?: string | undefined;
+    folder_name?: string | undefined;
+    folder_description?: string | undefined;
+    parent_id?: number | undefined;
+}, {
+    project_name?: string | undefined;
+    project_description?: string | undefined;
+    project_identifier?: string | undefined;
+    folder_name?: string | undefined;
+    folder_description?: string | undefined;
+    parent_id?: number | undefined;
+}>;
+type CreateProjFoldArgs = z.infer<typeof CreateProjFoldSchema>;
+/**
+ * Creates a project and/or folder in BrowserStack Test Management.
+ */
+export declare function createProjectOrFolder(args: CreateProjFoldArgs, config: BrowserStackConfig): Promise<CallToolResult>;
+export {};

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

@@ -1,8 +1,8 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js"; // or correct path
+import { formatAxiosError } from "../../lib/error.js";
 import { projectIdentifierToId } from "../testmanagement-utils/TCG-utils/api.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 // Schema for combined project/folder creation
 export const CreateProjFoldSchema = z.object({
     project_name: z
@@ -30,21 +30,29 @@ export const CreateProjFoldSchema = z.object({
 /**
  * Creates a project and/or folder in BrowserStack Test Management.
  */
-export async function createProjectOrFolder(args) {
+export async function createProjectOrFolder(args, config) {
     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).");
     }
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
     let projId = project_identifier;
     // Step 1: Create project if project_name provided
     if (project_name) {
         try {
-            const res = await axios.post("https://test-management.browserstack.com/api/v2/projects", { project: { name: project_name, description: project_description } }, {
-                auth: {
-                    username: config.browserstackUsername,
-                    password: config.browserstackAccessKey,
+            const authString = getBrowserStackAuth(config);
+            const [username, password] = authString.split(":");
+            const res = await apiClient.post({
+                url: "https://test-management.browserstack.com/api/v2/projects",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Basic " +
+                        Buffer.from(`${username}:${password}`).toString("base64"),
+                },
+                body: {
+                    project: { name: project_name, description: project_description },
                 },
-                headers: { "Content-Type": "application/json" },
             });
             if (!res.data.success) {
                 throw new Error(`Failed to create project: ${JSON.stringify(res.data)}`);
@@ -53,7 +61,7 @@ export async function createProjectOrFolder(args) {
             projId = res.data.project.identifier;
         }
         catch (err) {
-            return formatAxiosError(err, "Failed to create project..");
+            return formatAxiosError(err, "Failed to create project.");
         }
     }
     // Step 2: Create folder if folder_name provided
@@ -61,25 +69,27 @@ export async function createProjectOrFolder(args) {
         if (!projId)
             throw new Error("Cannot create folder without project_identifier.");
         try {
-            const res = await axios.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(projId)}/folders`, {
-                folder: {
-                    name: folder_name,
-                    description: folder_description,
-                    parent_id,
+            const res = await apiClient.post({
+                url: `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(projId)}/folders`,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Basic " +
+                        Buffer.from(`${username}:${password}`).toString("base64"),
                 },
-            }, {
-                auth: {
-                    username: config.browserstackUsername,
-                    password: config.browserstackAccessKey,
+                body: {
+                    folder: {
+                        name: folder_name,
+                        description: folder_description,
+                        parent_id,
+                    },
                 },
-                headers: { "Content-Type": "application/json" },
             });
             if (!res.data.success) {
                 throw new Error(`Failed to create folder: ${JSON.stringify(res.data)}`);
             }
             // Folder created successfully
             const folder = res.data.folder;
-            const projectId = await projectIdentifierToId(projId);
+            const projectId = await projectIdentifierToId(projId, config);
             return {
                 content: [
                     {

package/dist/tools/testmanagement-utils/create-testcase.d.ts

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+interface TestCaseStep {
+    step: string;
+    result: string;
+}
+interface IssueTracker {
+    name: string;
+    host: string;
+}
+export interface TestCaseCreateRequest {
+    project_identifier: string;
+    folder_id: string;
+    name: string;
+    description?: string;
+    owner?: string;
+    preconditions?: string;
+    test_case_steps: TestCaseStep[];
+    issues?: string[];
+    issue_tracker?: IssueTracker;
+    tags?: string[];
+    custom_fields?: Record<string, string>;
+}
+export interface TestCaseResponse {
+    data: {
+        success: boolean;
+        test_case: {
+            case_type: string;
+            priority: string;
+            status: string;
+            folder_id: number;
+            issues: Array<{
+                jira_id: string;
+                issue_type: string;
+            }>;
+            tags: string[];
+            template: string;
+            description: string;
+            preconditions: string;
+            title: string;
+            identifier: string;
+            automation_status: string;
+            owner: string;
+            steps: TestCaseStep[];
+            custom_fields: Array<{
+                name: string;
+                value: string;
+            }>;
+        };
+    };
+}
+export declare const CreateTestCaseSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    folder_id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    preconditions: z.ZodOptional<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">;
+    issues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    issue_tracker: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        host: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        host: string;
+    }, {
+        name: string;
+        host: string;
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    custom_fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    test_case_steps: {
+        step: string;
+        result: string;
+    }[];
+    project_identifier: string;
+    folder_id: string;
+    issues?: string[] | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    custom_fields?: Record<string, string> | undefined;
+    preconditions?: string | undefined;
+    owner?: string | undefined;
+    issue_tracker?: {
+        name: string;
+        host: string;
+    } | undefined;
+}, {
+    name: string;
+    test_case_steps: {
+        step: string;
+        result: string;
+    }[];
+    project_identifier: string;
+    folder_id: string;
+    issues?: string[] | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    custom_fields?: Record<string, string> | undefined;
+    preconditions?: string | undefined;
+    owner?: string | undefined;
+    issue_tracker?: {
+        name: string;
+        host: string;
+    } | undefined;
+}>;
+export declare function sanitizeArgs(args: any): any;
+export declare function createTestCase(params: TestCaseCreateRequest, config: BrowserStackConfig): Promise<CallToolResult>;
+export {};

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

@@ -1,7 +1,6 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js"; // or correct
+import { formatAxiosError } from "../../lib/error.js";
 import { projectIdentifierToId } from "./TCG-utils/api.js";
 export const CreateTestCaseSchema = z.object({
     project_identifier: z
@@ -67,15 +66,19 @@ export function sanitizeArgs(args) {
     }
     return cleaned;
 }
-export async function createTestCase(params) {
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+export async function createTestCase(params, config) {
     const body = { test_case: params };
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
     try {
-        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.browserstackUsername,
-                password: config.browserstackAccessKey,
+        const response = await apiClient.post({
+            url: `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(params.project_identifier)}/folders/${encodeURIComponent(params.folder_id)}/test-cases`,
+            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) {
@@ -91,7 +94,7 @@ export async function createTestCase(params) {
             };
         }
         const tc = data.test_case;
-        const projectId = await projectIdentifierToId(params.project_identifier);
+        const projectId = await projectIdentifierToId(params.project_identifier, config);
         return {
             content: [
                 {

package/dist/tools/testmanagement-utils/create-testrun.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for creating a test run.
+ */
+export declare const CreateTestRunSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    test_run: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        run_state: z.ZodOptional<z.ZodEnum<["new_run", "in_progress", "under_review", "rejected", "done", "closed"]>>;
+        issues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        issue_tracker: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            host: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            host: string;
+        }, {
+            name: string;
+            host: string;
+        }>>;
+        test_cases: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        folder_ids: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        issues?: string[] | undefined;
+        description?: string | undefined;
+        issue_tracker?: {
+            name: string;
+            host: string;
+        } | undefined;
+        test_cases?: string[] | undefined;
+        run_state?: "new_run" | "in_progress" | "under_review" | "rejected" | "done" | "closed" | undefined;
+        folder_ids?: number[] | undefined;
+    }, {
+        name: string;
+        issues?: string[] | undefined;
+        description?: string | undefined;
+        issue_tracker?: {
+            name: string;
+            host: string;
+        } | undefined;
+        test_cases?: string[] | undefined;
+        run_state?: "new_run" | "in_progress" | "under_review" | "rejected" | "done" | "closed" | undefined;
+        folder_ids?: number[] | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    project_identifier: string;
+    test_run: {
+        name: string;
+        issues?: string[] | undefined;
+        description?: string | undefined;
+        issue_tracker?: {
+            name: string;
+            host: string;
+        } | undefined;
+        test_cases?: string[] | undefined;
+        run_state?: "new_run" | "in_progress" | "under_review" | "rejected" | "done" | "closed" | undefined;
+        folder_ids?: number[] | undefined;
+    };
+}, {
+    project_identifier: string;
+    test_run: {
+        name: string;
+        issues?: string[] | undefined;
+        description?: string | undefined;
+        issue_tracker?: {
+            name: string;
+            host: string;
+        } | undefined;
+        test_cases?: string[] | undefined;
+        run_state?: "new_run" | "in_progress" | "under_review" | "rejected" | "done" | "closed" | undefined;
+        folder_ids?: number[] | undefined;
+    };
+}>;
+export type CreateTestRunArgs = z.infer<typeof CreateTestRunSchema>;
+/**
+ * Creates a test run via BrowserStack Test Management API.
+ */
+export declare function createTestRun(rawArgs: CreateTestRunArgs, config: BrowserStackConfig): Promise<CallToolResult>;

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

@@ -1,7 +1,7 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
 import { formatAxiosError } from "../../lib/error.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 /**
  * Schema for creating a test run.
  */
@@ -44,7 +44,7 @@ export const CreateTestRunSchema = z.object({
 /**
  * Creates a test run via BrowserStack Test Management API.
  */
-export async function createTestRun(rawArgs) {
+export async function createTestRun(rawArgs, config) {
     try {
         const inputArgs = {
             ...rawArgs,
@@ -55,12 +55,15 @@ export async function createTestRun(rawArgs) {
         };
         const args = CreateTestRunSchema.parse(inputArgs);
         const url = `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(args.project_identifier)}/test-runs`;
-        const response = await axios.post(url, { test_run: args.test_run }, {
-            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: { test_run: args.test_run },
         });
         const data = response.data;
         if (!data.success) {

package/dist/tools/testmanagement-utils/list-testcases.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for listing test cases with optional filters.
+ */
+export declare const ListTestCasesSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    folder_id: z.ZodOptional<z.ZodString>;
+    case_type: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    p: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    project_identifier: string;
+    priority?: string | undefined;
+    case_type?: string | undefined;
+    folder_id?: string | undefined;
+    p?: number | undefined;
+}, {
+    project_identifier: string;
+    priority?: string | undefined;
+    case_type?: string | undefined;
+    folder_id?: string | undefined;
+    p?: number | undefined;
+}>;
+export type ListTestCasesArgs = z.infer<typeof ListTestCasesSchema>;
+/**
+ * Calls BrowserStack Test Management to list test cases with filters.
+ */
+export declare function listTestCases(args: ListTestCasesArgs, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/testmanagement-utils/list-testcases.js

@@ -1,7 +1,7 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
 import { formatAxiosError } from "../../lib/error.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 /**
  * Schema for listing test cases with optional filters.
  */
@@ -26,7 +26,7 @@ export const ListTestCasesSchema = z.object({
 /**
  * Calls BrowserStack Test Management to list test cases with filters.
  */
-export async function listTestCases(args) {
+export async function listTestCases(args, config) {
     try {
         // Build query string
         const params = new URLSearchParams();
@@ -39,10 +39,12 @@ export async function listTestCases(args) {
         if (args.p !== undefined)
             params.append("p", args.p.toString());
         const url = `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(args.project_identifier)}/test-cases?${params.toString()}`;
-        const resp = await axios.get(url, {
-            auth: {
-                username: config.browserstackUsername,
-                password: config.browserstackAccessKey,
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const resp = await apiClient.get({
+            url,
+            headers: {
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
             },
         });
         const resp_data = resp.data;

package/dist/tools/testmanagement-utils/list-testruns.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for listing test runs with optional filters.
+ */
+export declare const ListTestRunsSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    run_state: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    project_identifier: string;
+    run_state?: string | undefined;
+}, {
+    project_identifier: string;
+    run_state?: string | undefined;
+}>;
+type ListTestRunsArgs = z.infer<typeof ListTestRunsSchema>;
+/**
+ * Fetches and formats the list of test runs for a project.
+ */
+export declare function listTestRuns(args: ListTestRunsArgs, config: BrowserStackConfig): Promise<CallToolResult>;
+export {};

package/dist/tools/testmanagement-utils/list-testruns.js

@@ -1,7 +1,7 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
 import { formatAxiosError } from "../../lib/error.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 /**
  * Schema for listing test runs with optional filters.
  */
@@ -17,17 +17,19 @@ export const ListTestRunsSchema = z.object({
 /**
  * Fetches and formats the list of test runs for a project.
  */
-export async function listTestRuns(args) {
+export async function listTestRuns(args, config) {
     try {
         const params = new URLSearchParams();
         if (args.run_state) {
             params.set("run_state", args.run_state);
         }
         const url = `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(args.project_identifier)}/test-runs?` + params.toString();
-        const resp = await axios.get(url, {
-            auth: {
-                username: config.browserstackUsername,
-                password: config.browserstackAccessKey,
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const resp = await apiClient.get({
+            url,
+            headers: {
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
             },
         });
         const data = resp.data;

package/dist/tools/testmanagement-utils/poll-lca-status.d.ts

@@ -0,0 +1,11 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Poll test case details to check LCA build status
+ */
+export declare function pollLCAStatus(projectId: string, folderId: string, testCaseId: string, context: any, maxWaitTimeMs: number | undefined, // 10 minutes default
+initialWaitMs: number | undefined, // 2 minutes initial wait
+pollIntervalMs: number | undefined, // 10 seconds interval
+config: BrowserStackConfig): Promise<{
+    resource_path: string;
+    status: string;
+} | null>;

package/dist/tools/testmanagement-utils/poll-lca-status.js

@@ -1,11 +1,12 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 /**
  * Poll test case details to check LCA build status
  */
 export async function pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitTimeMs = 10 * 60 * 1000, // 10 minutes default
 initialWaitMs = 2 * 60 * 1000, // 2 minutes initial wait
-pollIntervalMs = 10 * 1000) {
+pollIntervalMs = 10 * 1000, // 10 seconds interval
+config) {
     const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/test-cases/${testCaseId}`;
     const startTime = Date.now();
     // Send initial notification that polling is starting
@@ -49,17 +50,20 @@ pollIntervalMs = 10 * 1000) {
         // Set up polling interval
         const intervalId = setInterval(async () => {
             try {
-                const response = await axios.get(url, {
+                const authString = getBrowserStackAuth(config);
+                const response = await apiClient.get({
+                    url,
                     headers: {
-                        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                        "API-TOKEN": authString,
                         accept: "application/json, text/plain, */*",
                     },
                 });
-                if (response.data.data.success && response.data.data.test_case) {
-                    const testCase = response.data.data.test_case;
+                const responseData = response.data;
+                if (responseData.data.success && responseData.data.test_case) {
+                    const testCase = responseData.data.test_case;
                     // Check lcnc_build_map in both possible locations
                     const lcncBuildMap = testCase.lcnc_build_map ||
-                        response.data.data.metadata?.lcnc_build_map;
+                        responseData.data.metadata?.lcnc_build_map;
                     if (lcncBuildMap) {
                         if (lcncBuildMap.status === "done") {
                             // Clean up timers

package/dist/tools/testmanagement-utils/testcase-from-file.d.ts

@@ -0,0 +1,4 @@
+import { CreateTestCasesFromFileArgs } from "./TCG-utils/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function createTestCasesFromFile(args: CreateTestCasesFromFileArgs, context: any, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/testmanagement-utils/testcase-from-file.js

@@ -3,12 +3,12 @@ import { buildDefaultFieldMaps, findBooleanFieldId, } from "./TCG-utils/helpers.
 import { signedUrlMap } from "../../lib/inmemory-store.js";
 import logger from "../../logger.js";
 import { projectIdentifierToId } from "./TCG-utils/api.js";
-export async function createTestCasesFromFile(args, context) {
+export async function createTestCasesFromFile(args, context, config) {
     logger.info(`createTestCasesFromFile called with projectId: ${args.projectReferenceId}, folderId: ${args.folderId}`);
     if (args.projectReferenceId.startsWith("PR-")) {
-        args.projectReferenceId = await projectIdentifierToId(args.projectReferenceId);
+        args.projectReferenceId = await projectIdentifierToId(args.projectReferenceId, config);
     }
-    const { default_fields, custom_fields } = await fetchFormFields(args.projectReferenceId);
+    const { default_fields, custom_fields } = await fetchFormFields(args.projectReferenceId, config);
     const fieldMaps = buildDefaultFieldMaps(default_fields);
     const booleanFieldId = findBooleanFieldId(custom_fields);
     const documentObj = signedUrlMap.get(args.documentId);
@@ -27,9 +27,9 @@ export async function createTestCasesFromFile(args, context) {
     const documentId = documentObj.fileId;
     const document = documentObj.downloadUrl;
     const source = "jira-on-prem";
-    const traceId = await triggerTestCaseGeneration(document, documentId, args.folderId, args.projectReferenceId, source);
-    const scenariosMap = await pollScenariosTestDetails(args, traceId, context, documentId, source);
-    const resultString = await bulkCreateTestCases(scenariosMap, args.projectReferenceId, args.folderId, fieldMaps, booleanFieldId, traceId, context, documentId);
+    const traceId = await triggerTestCaseGeneration(document, documentId, args.folderId, args.projectReferenceId, source, config);
+    const scenariosMap = await pollScenariosTestDetails(args, traceId, context, documentId, source, config);
+    const resultString = await bulkCreateTestCases(scenariosMap, args.projectReferenceId, args.folderId, fieldMaps, booleanFieldId, traceId, context, documentId, config);
     signedUrlMap.delete(args.documentId);
     const dashboardURL = `https://test-management.browserstack.com/projects/${args.projectReferenceId}/folder/${args.folderId}/test-cases`;
     return {