@browserstack/mcp-server 1.3.2-beta.1 → 1.3.2-beta.2

package/README.md

@@ -426,7 +426,7 @@ As of now we support 45 tools.
   Get screenshots from Automate session ID abc123xyz for my desktop test run
   ```
 
- 18. `listSessions` — List the sessions in an Automate/App Automate build. Each record carries `sessionId`, `name`, `status`, `os`, `osVersion`, `browser`, `device`, and `browserUrl` (dashboard link), with optional `limit` / `offset` paging and a client-side `status` filter. Takes the **hashed** build ID from the dashboard URL — not the observability UUID returned by `getBuildId` / `listBuildId`; if you only have that UUID, use `hashed_id` from `fetchBuildInsights` when present. Returned `sessionId` values work with `getFailureLogs`, `fetchAutomationScreenshots`, and `fetchSelfHealedSelectors`.
+ 18. `listSessions` — List the sessions in an Automate/App Automate build. Each record carries `sessionId`, `name`, `status`, `os`, `osVersion`, `browser`, `device`, `browserUrl` (dashboard link), and `videoUrl`, with optional `limit` / `offset` paging and a client-side `status` filter. Takes the **hashed** build ID from the dashboard URL — not the observability UUID returned by `getBuildId` / `listBuildId`; if you only have that UUID, use `hashed_id` from `fetchBuildInsights` when present. Returned `sessionId` values work with `getFailureLogs`, `fetchAutomationScreenshots`, and `fetchSelfHealedSelectors`.
   **Prompt example**
 
   ```text
@@ -444,7 +444,7 @@ As of now we support 45 tools.
   Get the Appium logs for App Automate session ID <session id>
   ```
 
- 20. `fetchBuildInsights` — Fetch insights about a BrowserStack build by combining build details and quality-gate results. Includes `hashed_id` (the hashed build id `listSessions` takes) when the build payload reports one.
+ 20. `fetchBuildInsights` — Fetch insights about a BrowserStack build by combining build details and quality-gate results. Includes `hashed_id` (the hashed build id `listSessions` takes) and `session_type`, resolved through the build's sessions when the build ran on Automate / App Automate.
   **Prompt example**
 
   ```text
@@ -643,7 +643,7 @@ As of now we support 45 tools.
   Get the latest build ID for build 'nightly-regression' in project 'Checkout Flow'
   ```
 
- 45. `listTestIds` — List test IDs from a BrowserStack Automate build, filtered by status (passed/failed/pending/skipped).
+ 45. `listTestIds` — List the tests in a BrowserStack build (Automate or App Automate) with each test's `status` and `session_id`, optionally filtered by status (passed/failed/pending/skipped). The `session_id` feeds `getFailureLogs` and `fetchAutomationScreenshots` directly.
   **Prompt example**
 
   ```text

package/dist/lib/constants.d.ts

@@ -2,15 +2,18 @@ export declare const SessionType: {
     readonly Automate: "automate";
     readonly AppAutomate: "app-automate";
 };
+export declare const SessionVideoLogType: "video";
 export declare const AutomateLogType: {
     readonly NetworkLogs: "networkLogs";
     readonly SessionLogs: "sessionLogs";
     readonly ConsoleLogs: "consoleLogs";
+    readonly Video: "video";
 };
 export declare const AppAutomateLogType: {
     readonly DeviceLogs: "deviceLogs";
     readonly AppiumLogs: "appiumLogs";
     readonly CrashLogs: "crashLogs";
+    readonly Video: "video";
 };
 export type SessionType = (typeof SessionType)[keyof typeof SessionType];
 export type AutomateLogType = (typeof AutomateLogType)[keyof typeof AutomateLogType];

package/dist/lib/constants.js

@@ -2,13 +2,16 @@ export const SessionType = {
     Automate: "automate",
     AppAutomate: "app-automate",
 };
+export const SessionVideoLogType = "video";
 export const AutomateLogType = {
     NetworkLogs: "networkLogs",
     SessionLogs: "sessionLogs",
     ConsoleLogs: "consoleLogs",
+    Video: SessionVideoLogType,
 };
 export const AppAutomateLogType = {
     DeviceLogs: "deviceLogs",
     AppiumLogs: "appiumLogs",
     CrashLogs: "crashLogs",
+    Video: SessionVideoLogType,
 };

package/dist/tools/automate-utils/list-session-ids.d.ts

@@ -1,6 +1,10 @@
 import { SessionType } from "../../lib/constants.js";
 import { BrowserStackConfig } from "../../lib/types.js";
 export declare const DEFAULT_SESSION_LIST_LIMIT = 10;
+/** The REST session list returned 404: no Automate/App Automate build has this hashed id. */
+export declare class UnknownBuildError extends Error {
+    constructor(message: string);
+}
 export interface ListSessionIdsArgs {
     sessionType: SessionType;
     buildId: string;
@@ -17,6 +21,7 @@ export interface SessionIdRecord {
     browser?: string;
     device?: string | null;
     browserUrl?: string;
+    videoUrl?: string;
 }
 export declare function sessionsListUrl(sessionType: SessionType, buildId: string): string;
 export declare function mapSessionRecords(payload: unknown, statusFilter?: string): SessionIdRecord[];

package/dist/tools/automate-utils/list-session-ids.js

@@ -2,6 +2,13 @@ import { SessionType } from "../../lib/constants.js";
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { apiClient } from "../../lib/apiClient.js";
 export const DEFAULT_SESSION_LIST_LIMIT = 10;
+/** The REST session list returned 404: no Automate/App Automate build has this hashed id. */
+export class UnknownBuildError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UnknownBuildError";
+    }
+}
 export function sessionsListUrl(sessionType, buildId) {
     const encodedBuildId = encodeURIComponent(buildId);
     switch (sessionType) {
@@ -41,6 +48,7 @@ export function mapSessionRecords(payload, statusFilter) {
             browser: session.browser,
             device: session.device,
             browserUrl: session.browser_url,
+            videoUrl: session.video_url,
         });
     }
     return records;
@@ -68,11 +76,10 @@ export async function listSessionIds(args, config) {
     });
     if (!response.ok) {
         if (response.status === 404) {
-            throw new Error(`Invalid hashed build ID "${buildId}" for ${args.sessionType}. ` +
-                "Use the Automate/App Automate dashboard hashed build id " +
-                "(same family as App Automate getFailureLogs buildId), not the " +
-                "observability UUID from getBuildId or listBuildId. " +
-                "If you only have an observability UUID, call fetchBuildInsights and use hashed_id when present.");
+            throw new UnknownBuildError(`No ${args.sessionType} build found for id "${buildId}". ` +
+                "Pass the Automate/App Automate dashboard hashed build id or the " +
+                "observability build id from getBuildId / listBuildId, and check that " +
+                "sessionType matches the product the build ran on.");
         }
         throw new Error(`Failed to list sessions: ${response.status} ${response.statusText}`);
     }

package/dist/tools/automate-utils/resolve-hashed-build-id.d.ts

@@ -0,0 +1,30 @@
+import { SessionType } from "../../lib/constants.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function isObservabilityBuildUuid(id: string): boolean;
+export declare function isHashedBuildId(id: string): boolean;
+export declare function sessionDetailsUrl(sessionType: SessionType, sessionId: string): string;
+/**
+ * Resolve the hashed build id that a session belongs to via the Automate /
+ * App Automate session detail endpoint. Returns undefined when the session
+ * cannot be fetched or does not report a build.
+ */
+export declare function resolveBuildIdFromSession(sessionId: string, sessionType: SessionType, config: BrowserStackConfig): Promise<string | undefined>;
+/**
+ * Find any BrowserStack session id attached to an observability build by
+ * walking its test runs. Returns undefined when no test reports a session
+ * (e.g. JUnit-uploaded builds that never ran on BrowserStack).
+ */
+export declare function findSessionIdForObservabilityBuild(observabilityBuildId: string, config: BrowserStackConfig): Promise<string | undefined>;
+export interface ResolvedHashedBuildId {
+    hashedBuildId: string;
+    sessionId: string;
+    sessionType: SessionType;
+}
+/**
+ * Convert an observability build UUID into the Automate / App Automate hashed
+ * build id in two deterministic API calls: pick any session of the build from
+ * its test runs, then read `build_hashed_id` from that session's details.
+ *
+ * When `sessionType` is omitted, Automate is tried first, then App Automate.
+ */
+export declare function resolveHashedBuildId(observabilityBuildId: string, config: BrowserStackConfig, sessionType?: SessionType): Promise<ResolvedHashedBuildId>;

package/dist/tools/automate-utils/resolve-hashed-build-id.js

@@ -0,0 +1,124 @@
+import { SessionType } from "../../lib/constants.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { apiClient } from "../../lib/apiClient.js";
+import logger from "../../logger.js";
+import { getAutomationBaseUrl } from "../rca-agent-utils/constants.js";
+import { extractTestIds } from "../rca-agent-utils/get-failed-test-id.js";
+// Observability (Test Reporting & Analytics) build ids are usually UUIDs but
+// some are 40-char hex, the same shape as Automate / App Automate "hashed ids".
+// The two are never interchangeable, and the observability build API does not
+// expose the hashed id. The deterministic bridge is any BrowserStack session that belongs to the
+// build: the session detail endpoint reports its parent `build_hashed_id`.
+const OBSERVABILITY_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const HASHED_BUILD_ID_RE = /^[a-f0-9]{40}$/i;
+// Only the first session id is needed; most builds surface one on page one.
+const MAX_TEST_RUN_PAGES = 5;
+export function isObservabilityBuildUuid(id) {
+    return OBSERVABILITY_UUID_RE.test(id.trim());
+}
+export function isHashedBuildId(id) {
+    return HASHED_BUILD_ID_RE.test(id.trim());
+}
+export function sessionDetailsUrl(sessionType, sessionId) {
+    const encoded = encodeURIComponent(sessionId);
+    switch (sessionType) {
+        case SessionType.Automate:
+            return `https://api.browserstack.com/automate/sessions/${encoded}.json`;
+        case SessionType.AppAutomate:
+            return `https://api.browserstack.com/app-automate/sessions/${encoded}.json`;
+        default: {
+            const _exhaustive = sessionType;
+            throw new Error(`Unsupported session type: ${_exhaustive}`);
+        }
+    }
+}
+/**
+ * Resolve the hashed build id that a session belongs to via the Automate /
+ * App Automate session detail endpoint. Returns undefined when the session
+ * cannot be fetched or does not report a build.
+ */
+export async function resolveBuildIdFromSession(sessionId, sessionType, config) {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const response = await apiClient.get({
+        url: sessionDetailsUrl(sessionType, sessionId),
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+        raise_error: false,
+    });
+    if (!response.ok) {
+        logger.warn(`Could not resolve build id for ${sessionType} session ${sessionId}: ${response.status}`);
+        return undefined;
+    }
+    const session = response.data?.automation_session;
+    const buildId = session?.build_hashed_id;
+    return typeof buildId === "string" && buildId.trim()
+        ? buildId.trim()
+        : undefined;
+}
+/**
+ * Find any BrowserStack session id attached to an observability build by
+ * walking its test runs. Returns undefined when no test reports a session
+ * (e.g. JUnit-uploaded builds that never ran on BrowserStack).
+ */
+export async function findSessionIdForObservabilityBuild(observabilityBuildId, config) {
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const baseUrl = `${getAutomationBaseUrl()}/ext/v1/builds/${encodeURIComponent(observabilityBuildId)}/testRuns`;
+    let nextPage;
+    for (let page = 0; page < MAX_TEST_RUN_PAGES; page++) {
+        const response = await apiClient.get({
+            url: baseUrl,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Basic ${auth}`,
+            },
+            ...(nextPage ? { params: { next_page: nextPage } } : {}),
+            raise_error: false,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch test runs for observability build "${observabilityBuildId}": ` +
+                `${response.status} ${response.statusText}`);
+        }
+        const data = response.data;
+        const withSession = extractTestIds(data?.hierarchy ?? []).find((test) => test.session_id);
+        if (withSession?.session_id) {
+            return withSession.session_id;
+        }
+        if (!data?.pagination?.has_next || !data.pagination.next_page) {
+            return undefined;
+        }
+        nextPage = data.pagination.next_page;
+    }
+    logger.warn(`resolveHashedBuildId: no session id in first ${MAX_TEST_RUN_PAGES} pages of build ${observabilityBuildId}`);
+    return undefined;
+}
+/**
+ * Convert an observability build UUID into the Automate / App Automate hashed
+ * build id in two deterministic API calls: pick any session of the build from
+ * its test runs, then read `build_hashed_id` from that session's details.
+ *
+ * When `sessionType` is omitted, Automate is tried first, then App Automate.
+ */
+export async function resolveHashedBuildId(observabilityBuildId, config, sessionType) {
+    const buildId = observabilityBuildId.trim();
+    const sessionId = await findSessionIdForObservabilityBuild(buildId, config);
+    if (!sessionId) {
+        throw new Error(`No BrowserStack sessions found for observability build "${buildId}". ` +
+            "Only builds that ran on Automate or App Automate have sessions to list; " +
+            "uploaded-report builds (e.g. JUnit) do not.");
+    }
+    const candidates = sessionType
+        ? [sessionType]
+        : [SessionType.Automate, SessionType.AppAutomate];
+    for (const candidate of candidates) {
+        const hashedBuildId = await resolveBuildIdFromSession(sessionId, candidate, config);
+        if (hashedBuildId) {
+            return { hashedBuildId, sessionId, sessionType: candidate };
+        }
+    }
+    throw new Error(`Could not resolve the hashed build id for observability build "${buildId}" ` +
+        `from session "${sessionId}" (tried: ${candidates.join(", ")}).`);
+}

package/dist/tools/automate.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { fetchAutomationScreenshots } from "./automate-utils/fetch-screenshots.js";
-import { DEFAULT_SESSION_LIST_LIMIT, listSessionIds, } from "./automate-utils/list-session-ids.js";
+import { DEFAULT_SESSION_LIST_LIMIT, listSessionIds, UnknownBuildError, } from "./automate-utils/list-session-ids.js";
+import { isObservabilityBuildUuid, resolveHashedBuildId, } from "./automate-utils/resolve-hashed-build-id.js";
 import { SessionType } from "../lib/constants.js";
 import { trackMCP } from "../lib/instrumentation.js";
 import logger from "../logger.js";
@@ -51,25 +52,51 @@ export async function fetchAutomationScreenshotsTool(args, config) {
 }
 export async function listSessionIdsTool(args, config) {
     try {
-        const sessions = await listSessionIds(args, config);
-        if (sessions.length === 0) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "No sessions found for this hashed build ID.",
-                    },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify(sessions, null, 2),
-                },
-            ],
+        // Accept the observability build id too. Observability ids are usually
+        // UUIDs but can also be 40-char hex like Automate hashed ids, so shape
+        // alone is not enough: try the REST list first and resolve on a miss.
+        const inputId = args.buildId.trim();
+        let buildId = inputId;
+        let resolvedNote;
+        const resolve = async () => {
+            const resolved = await resolveHashedBuildId(inputId, config, args.sessionType);
+            buildId = resolved.hashedBuildId;
+            resolvedNote = `Resolved observability build ${inputId} to hashed build id ${buildId}.`;
         };
+        let sessions;
+        if (isObservabilityBuildUuid(inputId)) {
+            await resolve();
+            sessions = await listSessionIds({ ...args, buildId }, config);
+        }
+        else {
+            try {
+                sessions = await listSessionIds({ ...args, buildId }, config);
+            }
+            catch (error) {
+                if (!(error instanceof UnknownBuildError))
+                    throw error;
+                try {
+                    await resolve();
+                }
+                catch (resolveError) {
+                    logger.debug("listSessions: id is neither a known hashed build nor a resolvable observability build", resolveError);
+                    throw error;
+                }
+                sessions = await listSessionIds({ ...args, buildId }, config);
+            }
+        }
+        const content = [
+            {
+                type: "text",
+                text: sessions.length === 0
+                    ? "No sessions found for this hashed build ID."
+                    : JSON.stringify(sessions, null, 2),
+            },
+        ];
+        if (resolvedNote) {
+            content.push({ type: "text", text: resolvedNote });
+        }
+        return { content };
     }
     catch (error) {
         logger.error("Error listing session IDs", error);
@@ -79,7 +106,7 @@ export async function listSessionIdsTool(args, config) {
 //Registers the fetchAutomationScreenshots tool with the MCP server
 export default function addAutomationTools(server, config) {
     const tools = {};
-    tools.fetchAutomationScreenshots = server.tool("fetchAutomationScreenshots", "Fetch and process screenshots from a BrowserStack Automate session", {
+    tools.fetchAutomationScreenshots = server.tool("fetchAutomationScreenshots", "Fetch screenshots captured during an Automate/App Automate session.", {
         sessionId: z
             .string()
             .describe("The BrowserStack session ID to fetch screenshots from"),
@@ -117,7 +144,7 @@ export default function addAutomationTools(server, config) {
             .describe("Type of BrowserStack session"),
         buildId: z
             .string()
-            .describe("Dashboard hashed build id or fetchBuildInsights hashed_id — not the getBuildId UUID."),
+            .describe("Hashed build id from the dashboard, or the observability build id from getBuildId."),
         limit: z
             .number()
             .int()

package/dist/tools/build-insights.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import logger from "../logger.js";
 import { fetchFromBrowserStackAPI, handleMCPError } from "../lib/utils.js";
 import { trackMCP } from "../lib/instrumentation.js";
+import { resolveHashedBuildId } from "./automate-utils/resolve-hashed-build-id.js";
 // Tool function that fetches build insights from two APIs
 export async function fetchBuildInsightsTool(args, config) {
     try {
@@ -15,7 +16,7 @@ export async function fetchBuildInsightsTool(args, config) {
                 return null;
             }),
         ]);
-        const hashed_id = extractHashedBuildId(buildData);
+        const { hashed_id, session_type } = await resolveInsightsHashedId(args.buildId, buildData, config);
         // Select useful fields for users
         const insights = {
             name: buildData.name,
@@ -35,6 +36,7 @@ export async function fetchBuildInsightsTool(args, config) {
             vcs_name: buildData.vcs_info?.name,
             quality_gate_result: qualityData?.quality_gate_result,
             ...(hashed_id ? { hashed_id } : {}),
+            ...(session_type ? { session_type } : {}),
         };
         const qualityProfiles = qualityData?.quality_profiles?.map((profile) => ({
             name: profile.name,
@@ -58,6 +60,28 @@ export async function fetchBuildInsightsTool(args, config) {
         throw error;
     }
 }
+/**
+ * The observability build payload does not carry the Automate hashed build id
+ * today. Prefer it if the API ever adds one; otherwise resolve it through any
+ * session of the build (two deterministic REST calls). Never blocks insights.
+ */
+async function resolveInsightsHashedId(observabilityBuildId, buildData, config) {
+    const direct = extractHashedBuildId(buildData);
+    if (direct) {
+        return { hashed_id: direct };
+    }
+    try {
+        const resolved = await resolveHashedBuildId(observabilityBuildId, config);
+        return {
+            hashed_id: resolved.hashedBuildId,
+            session_type: resolved.sessionType,
+        };
+    }
+    catch (error) {
+        logger.warn("Could not resolve hashed build id for build insights", error);
+        return {};
+    }
+}
 function extractHashedBuildId(buildData) {
     const candidates = [
         buildData?.hashed_id,
@@ -74,7 +98,7 @@ function extractHashedBuildId(buildData) {
 // Registers the fetchBuildInsights tool with the MCP server
 export default function addBuildInsightsTools(server, config) {
     const tools = {};
-    tools.fetchBuildInsights = server.tool("fetchBuildInsights", "Fetch build details and quality gate results. Includes hashed_id, the build id listSessions takes.", {
+    tools.fetchBuildInsights = server.tool("fetchBuildInsights", "Fetch build details and quality gate results. Includes hashed_id and session_type for listSessions.", {
         buildId: z.string().describe("The build UUID of the BrowserStack build"),
     }, {
         title: "Fetch Build Insights",

package/dist/tools/failurelogs-utils/resolve-app-build-id.js

@@ -1,25 +1,5 @@
-import { getBrowserStackAuth } from "../../lib/get-auth.js";
-import { apiClient } from "../../lib/apiClient.js";
-import logger from "../../logger.js";
+import { SessionType } from "../../lib/constants.js";
+import { resolveBuildIdFromSession } from "../automate-utils/resolve-hashed-build-id.js";
 export async function resolveAppAutomateBuildId(sessionId, config) {
-    const url = `https://api.browserstack.com/app-automate/sessions/${encodeURIComponent(sessionId)}.json`;
-    const authString = getBrowserStackAuth(config);
-    const auth = Buffer.from(authString).toString("base64");
-    const response = await apiClient.get({
-        url,
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Basic ${auth}`,
-        },
-        raise_error: false,
-    });
-    if (!response.ok) {
-        logger.warn(`Could not resolve build id for app-automate session ${sessionId}: ${response.status}`);
-        return undefined;
-    }
-    const session = response.data?.automation_session;
-    const buildId = session?.build_hashed_id;
-    return typeof buildId === "string" && buildId.trim()
-        ? buildId.trim()
-        : undefined;
+    return resolveBuildIdFromSession(sessionId, SessionType.AppAutomate, config);
 }

package/dist/tools/failurelogs-utils/video.d.ts

@@ -0,0 +1,3 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+import { SessionType } from "../../lib/constants.js";
+export declare function retrieveSessionVideo(sessionId: string, sessionType: SessionType, config: BrowserStackConfig): Promise<string>;

package/dist/tools/failurelogs-utils/video.js

@@ -0,0 +1,25 @@
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { apiClient } from "../../lib/apiClient.js";
+import { SessionType } from "../../lib/constants.js";
+import { validateLogResponse } from "./utils.js";
+export async function retrieveSessionVideo(sessionId, sessionType, config) {
+    const product = sessionType === SessionType.AppAutomate ? "app-automate" : "automate";
+    const url = `https://api.browserstack.com/${product}/sessions/${encodeURIComponent(sessionId)}.json`;
+    const authString = getBrowserStackAuth(config);
+    const auth = Buffer.from(authString).toString("base64");
+    const response = await apiClient.get({
+        url,
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Basic ${auth}`,
+        },
+        raise_error: false,
+    });
+    const validationError = validateLogResponse(response, "session video");
+    if (validationError)
+        return validationError.message;
+    const videoUrl = response.data?.automation_session?.video_url;
+    return typeof videoUrl === "string" && videoUrl.trim()
+        ? `Session video: ${videoUrl.trim()}`
+        : "No session video available for this session";
+}

package/dist/tools/get-failure-logs.js

@@ -3,7 +3,8 @@ import { trackMCP } from "../lib/instrumentation.js";
 import { retrieveNetworkFailures, retrieveSessionFailures, retrieveConsoleFailures, } from "./failurelogs-utils/automate.js";
 import { retrieveDeviceLogs, retrieveAppiumLogs, retrieveCrashLogs, } from "./failurelogs-utils/app-automate.js";
 import { resolveAppAutomateBuildId } from "./failurelogs-utils/resolve-app-build-id.js";
-import { AppAutomateLogType, AutomateLogType, SessionType, } from "../lib/constants.js";
+import { retrieveSessionVideo } from "./failurelogs-utils/video.js";
+import { AppAutomateLogType, AutomateLogType, SessionType, SessionVideoLogType, } from "../lib/constants.js";
 // Main log fetcher function
 export async function getFailureLogs(args, config) {
     const results = [];
@@ -12,21 +13,16 @@ export async function getFailureLogs(args, config) {
     if (!args.sessionId) {
         throw new Error("Session ID is required");
     }
-    let buildId = args.buildId;
-    if (args.sessionType === SessionType.AppAutomate && !buildId) {
-        buildId = await resolveAppAutomateBuildId(args.sessionId, config);
-        if (!buildId) {
-            throw new Error("Build ID is required for app-automate sessions");
-        }
-    }
     // Validate log types and collect errors
     validLogTypes = args.logTypes.filter((logType) => {
         const isAutomate = Object.values(AutomateLogType).includes(logType);
         const isAppAutomate = Object.values(AppAutomateLogType).includes(logType);
         if (!isAutomate && !isAppAutomate) {
             errors.push(`Invalid log type '${logType}'. Valid log types are: ${[
-                ...Object.values(AutomateLogType),
-                ...Object.values(AppAutomateLogType),
+                ...new Set([
+                    ...Object.values(AutomateLogType),
+                    ...Object.values(AppAutomateLogType),
+                ]),
             ].join(", ")}`);
             return false;
         }
@@ -51,11 +47,26 @@ export async function getFailureLogs(args, config) {
             isError: true,
         };
     }
+    let buildId = args.buildId;
+    const needsBuildId = validLogTypes.some((logType) => logType !== SessionVideoLogType);
+    if (args.sessionType === SessionType.AppAutomate &&
+        needsBuildId &&
+        !buildId) {
+        buildId = await resolveAppAutomateBuildId(args.sessionId, config);
+        if (!buildId) {
+            throw new Error("Build ID is required for app-automate sessions");
+        }
+    }
     let response;
     // eslint-disable-next-line no-useless-catch
     try {
         for (const logType of validLogTypes) {
             switch (logType) {
+                case SessionVideoLogType: {
+                    response = await retrieveSessionVideo(args.sessionId, args.sessionType, config);
+                    results.push({ type: "text", text: response });
+                    break;
+                }
                 case AutomateLogType.NetworkLogs: {
                     response = await retrieveNetworkFailures(args.sessionId, config);
                     results.push({ type: "text", text: response });
@@ -103,7 +114,7 @@ export async function getFailureLogs(args, config) {
 // Register tool with the MCP server
 export default function registerGetFailureLogs(server, config) {
     const tools = {};
-    tools.getFailureLogs = server.tool("getFailureLogs", "Fetch various types of logs from a BrowserStack session. Supports both automate and app-automate sessions.", {
+    tools.getFailureLogs = server.tool("getFailureLogs", "Fetch logs, or the session video URL, for an Automate/App Automate session.", {
         sessionType: z
             .enum([SessionType.Automate, SessionType.AppAutomate])
             .describe("Type of BrowserStack session. Must be explicitly provided by the user."),
@@ -122,6 +133,7 @@ export default function registerGetFailureLogs(server, config) {
             AppAutomateLogType.DeviceLogs,
             AppAutomateLogType.AppiumLogs,
             AppAutomateLogType.CrashLogs,
+            SessionVideoLogType,
         ]))
             .describe("The types of logs to fetch."),
     }, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserstack/mcp-server",
-  "version": "1.3.2-beta.1",
+  "version": "1.3.2-beta.2",
   "description": "BrowserStack's Official MCP Server",
   "mcpName": "io.github.browserstack/mcp-server",
   "main": "dist/index.js",