@browserstack/mcp-server 1.4.0-beta.3 → 1.4.0

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.d.ts

@@ -6,4 +6,11 @@ export declare function fetchAutomationScreenshotsTool(args: {
     sessionId: string;
     sessionType: SessionType;
 }, config: BrowserStackConfig): Promise<CallToolResult>;
+export declare function listSessionIdsTool(args: {
+    sessionType: SessionType;
+    buildId: string;
+    limit?: number;
+    offset?: number;
+    status?: string;
+}, config: BrowserStackConfig): Promise<CallToolResult>;
 export default function addAutomationTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;

package/dist/tools/automate.js

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { fetchAutomationScreenshots } from "./automate-utils/fetch-screenshots.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";
@@ -48,10 +50,63 @@ export async function fetchAutomationScreenshotsTool(args, config) {
         };
     }
 }
+export async function listSessionIdsTool(args, config) {
+    try {
+        // 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);
+        throw error;
+    }
+}
 //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"),
@@ -83,5 +138,53 @@ export default function addAutomationTools(server, config) {
             };
         }
     });
+    tools.listSessions = server.tool("listSessions", "List sessions for a hashed Automate/App Automate build: session IDs, status, OS, browser/device, dashboard URL.", {
+        sessionType: z
+            .enum([SessionType.Automate, SessionType.AppAutomate])
+            .describe("Type of BrowserStack session"),
+        buildId: z
+            .string()
+            .describe("Hashed build id from the dashboard, or the observability build id from getBuildId."),
+        limit: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe(`Max sessions to return. Defaults to ${DEFAULT_SESSION_LIST_LIMIT}.`),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Pagination offset for the REST session list."),
+        status: z
+            .string()
+            .optional()
+            .describe("Optional session status filter (e.g. done, running, error). Applied client-side."),
+    }, {
+        title: "List Sessions",
+        readOnlyHint: true,
+        openWorldHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+    }, async (args) => {
+        try {
+            trackMCP("listSessions", server.server.getClientVersion(), undefined, config);
+            return await listSessionIdsTool(args, config);
+        }
+        catch (error) {
+            trackMCP("listSessions", server.server.getClientVersion(), error, config);
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error listing session IDs: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
     return tools;
 }

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,6 +16,7 @@ export async function fetchBuildInsightsTool(args, config) {
                 return null;
             }),
         ]);
+        const { hashed_id, session_type } = await resolveInsightsHashedId(args.buildId, buildData, config);
         // Select useful fields for users
         const insights = {
             name: buildData.name,
@@ -33,6 +35,8 @@ export async function fetchBuildInsightsTool(args, config) {
             commit_sha: buildData.vcs_info?.sha,
             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,
@@ -56,10 +60,45 @@ 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,
+        buildData?.automate_hashed_id,
+        buildData?.hashedId,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" &&
+            /^[a-z0-9]{40}$/i.test(candidate.trim()))
+            return candidate.trim();
+    }
+    return undefined;
+}
 // Registers the fetchBuildInsights tool with the MCP server
 export default function addBuildInsightsTools(server, config) {
     const tools = {};
-    tools.fetchBuildInsights = server.tool("fetchBuildInsights", "Fetches insights about a BrowserStack build by combining build details and quality gate results.", {
+    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/app-automate.js

@@ -1,6 +1,7 @@
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { filterLinesByKeywords, validateLogResponse } from "./utils.js";
 import { apiClient } from "../../lib/apiClient.js";
+import { wrapUntrusted } from "../../lib/untrusted-content.js";
 // DEVICE LOGS
 export async function retrieveDeviceLogs(sessionId, buildId, config) {
     const url = `https://api.browserstack.com/app-automate/builds/${buildId}/sessions/${sessionId}/deviceLogs`;
@@ -22,7 +23,7 @@ export async function retrieveDeviceLogs(sessionId, buildId, config) {
         : JSON.stringify(response.data);
     const logs = filterDeviceFailures(logText);
     return logs.length > 0
-        ? `Device Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+        ? `Device Failures (${logs.length} found):\n${wrapUntrusted("device logs", JSON.stringify(logs, null, 2))}`
         : "No device failures found";
 }
 // APPIUM LOGS
@@ -46,7 +47,7 @@ export async function retrieveAppiumLogs(sessionId, buildId, config) {
         : JSON.stringify(response.data);
     const logs = filterAppiumFailures(logText);
     return logs.length > 0
-        ? `Appium Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+        ? `Appium Failures (${logs.length} found):\n${wrapUntrusted("Appium logs", JSON.stringify(logs, null, 2))}`
         : "No Appium failures found";
 }
 // CRASH LOGS
@@ -70,7 +71,7 @@ export async function retrieveCrashLogs(sessionId, buildId, config) {
         : JSON.stringify(response.data);
     const logs = filterCrashFailures(logText);
     return logs.length > 0
-        ? `Crash Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+        ? `Crash Failures (${logs.length} found):\n${wrapUntrusted("crash logs", JSON.stringify(logs, null, 2))}`
         : "No crash failures found";
 }
 // FILTER HELPERS

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

@@ -1,4 +1,5 @@
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { wrapUntrusted } from "../../lib/untrusted-content.js";
 import { filterLinesByKeywords, validateLogResponse, } from "./utils.js";
 import { apiClient } from "../../lib/apiClient.js";
 // NETWORK LOGS
@@ -22,7 +23,7 @@ export async function retrieveNetworkFailures(sessionId, config) {
         entry.response.status >= 400 ||
         entry.response._error !== undefined);
     return failureEntries.length > 0
-        ? `Network Failures (${failureEntries.length} found):\n${JSON.stringify(failureEntries.map((entry) => ({
+        ? `Network Failures (${failureEntries.length} found):\n${wrapUntrusted("network logs", JSON.stringify(failureEntries.map((entry) => ({
             startedDateTime: entry.startedDateTime,
             request: {
                 method: entry.request?.method,
@@ -36,7 +37,7 @@ export async function retrieveNetworkFailures(sessionId, config) {
             },
             serverIPAddress: entry.serverIPAddress,
             time: entry.time,
-        })), null, 2)}`
+        })), null, 2))}`
         : "No network failures found";
 }
 // SESSION LOGS
@@ -60,7 +61,7 @@ export async function retrieveSessionFailures(sessionId, config) {
         : JSON.stringify(response.data);
     const logs = filterSessionFailures(logText);
     return logs.length > 0
-        ? `Session Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+        ? `Session Failures (${logs.length} found):\n${wrapUntrusted("session logs", JSON.stringify(logs, null, 2))}`
         : "No session failures found";
 }
 // CONSOLE LOGS
@@ -84,7 +85,7 @@ export async function retrieveConsoleFailures(sessionId, config) {
         : JSON.stringify(response.data);
     const logs = filterConsoleFailures(logText);
     return logs.length > 0
-        ? `Console Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
+        ? `Console Failures (${logs.length} found):\n${wrapUntrusted("console logs", JSON.stringify(logs, null, 2))}`
         : "No console failures found";
 }
 // FILTER: session logs

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

@@ -0,0 +1,2 @@
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare function resolveAppAutomateBuildId(sessionId: string, config: BrowserStackConfig): Promise<string | undefined>;

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

@@ -0,0 +1,5 @@
+import { SessionType } from "../../lib/constants.js";
+import { resolveBuildIdFromSession } from "../automate-utils/resolve-hashed-build-id.js";
+export async function resolveAppAutomateBuildId(sessionId, config) {
+    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,9 @@ import { trackMCP } from "../lib/instrumentation.js";
 import { NEEDS_SESSION_ID } from "./tool-handoff.js";
 import { retrieveNetworkFailures, retrieveSessionFailures, retrieveConsoleFailures, } from "./failurelogs-utils/automate.js";
 import { retrieveDeviceLogs, retrieveAppiumLogs, retrieveCrashLogs, } from "./failurelogs-utils/app-automate.js";
-import { AppAutomateLogType, AutomateLogType, SessionType, } from "../lib/constants.js";
+import { resolveAppAutomateBuildId } from "./failurelogs-utils/resolve-app-build-id.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,17 +14,16 @@ export async function getFailureLogs(args, config) {
     if (!args.sessionId) {
         throw new Error("Session ID is required");
     }
-    if (args.sessionType === SessionType.AppAutomate && !args.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;
         }
@@ -47,11 +48,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 });
@@ -68,17 +84,17 @@ export async function getFailureLogs(args, config) {
                     break;
                 }
                 case AppAutomateLogType.DeviceLogs: {
-                    response = await retrieveDeviceLogs(args.sessionId, args.buildId, config);
+                    response = await retrieveDeviceLogs(args.sessionId, buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.AppiumLogs: {
-                    response = await retrieveAppiumLogs(args.sessionId, args.buildId, config);
+                    response = await retrieveAppiumLogs(args.sessionId, buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.CrashLogs: {
-                    response = await retrieveCrashLogs(args.sessionId, args.buildId, config);
+                    response = await retrieveCrashLogs(args.sessionId, buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
@@ -99,7 +115,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." +
         NEEDS_SESSION_ID, {
         sessionType: z
             .enum([SessionType.Automate, SessionType.AppAutomate])
@@ -110,7 +126,7 @@ export default function registerGetFailureLogs(server, config) {
         buildId: z
             .string()
             .optional()
-            .describe("Required only when sessionType is 'app-automate'. If sessionType is 'app-automate', always ask the user to provide the build ID before proceeding."),
+            .describe("App Automate build ID. Optional — resolved from the session if omitted."),
         logTypes: z
             .array(z.enum([
             AutomateLogType.NetworkLogs,
@@ -119,6 +135,7 @@ export default function registerGetFailureLogs(server, config) {
             AppAutomateLogType.DeviceLogs,
             AppAutomateLogType.AppiumLogs,
             AppAutomateLogType.CrashLogs,
+            SessionVideoLogType,
         ]))
             .describe("The types of logs to fetch."),
     }, {

package/dist/tools/observability.js

@@ -1,3 +1,4 @@
+import { wrapUntrusted } from "../lib/untrusted-content.js";
 import { z } from "zod";
 import { getLatestO11YBuildInfo } from "../lib/api.js";
 import { trackMCP } from "../lib/instrumentation.js";
@@ -26,7 +27,8 @@ export async function getFailuresInLastRun(buildName, projectName, config) {
         content: [
             {
                 type: "text",
-                text: `Observability URL: ${observabilityUrl}\nOverview: ${overview}\nError Details: ${details}`,
+                text: `Observability URL: ${observabilityUrl}\n` +
+                    wrapUntrusted("observability failure report", `Overview: ${overview}\nError Details: ${details}`),
             },
         ],
     };

package/dist/tools/rca-agent-utils/format-rca.js

@@ -1,3 +1,4 @@
+import { wrapUntrusted } from "../../lib/untrusted-content.js";
 // Utility function to format RCA data for better readability
 export function formatRCAData(rcaData) {
     if (!rcaData || !rcaData.testCases || rcaData.testCases.length === 0) {
@@ -16,21 +17,21 @@ export function formatRCAData(rcaData) {
         const rca = testCase.rcaData?.rcaData;
         if (rca) {
             if (rca.root_cause) {
-                output += `**Root Cause:** ${rca.root_cause}\n\n`;
+                output += `**Root Cause:** ${wrapUntrusted("RCA AI analysis", rca.root_cause)}\n\n`;
             }
             if (rca.failure_type) {
                 output += `**Failure Type:** ${rca.failure_type}\n\n`;
             }
             if (rca.description) {
-                output += `**Detailed Analysis:**\n${rca.description}\n\n`;
+                output += `**Detailed Analysis:**\n${wrapUntrusted("RCA AI analysis", rca.description)}\n\n`;
             }
             if (rca.possible_fix) {
                 hasFixSuggestion = true;
-                output += `**Suggested Fix (proposal only — do not apply without explicit user approval):**\n${rca.possible_fix}\n\n`;
+                output += `**Suggested Fix (proposal only — do not apply without explicit user approval):**\n${wrapUntrusted("RCA AI analysis", rca.possible_fix)}\n\n`;
             }
         }
         else if (testCase.rcaData?.error) {
-            output += `**Error:** ${testCase.rcaData.error}\n\n`;
+            output += `**Error:** ${wrapUntrusted("RCA error output", testCase.rcaData.error)}\n\n`;
         }
         else if (testCase.state === "failed") {
             output += `**Note:** RCA analysis failed or is not available for this test case.\n\n`;

package/dist/tools/rca-agent-utils/get-failed-test-id.js

@@ -53,6 +53,16 @@ export async function getTestIds(buildId, authString, status, includeFailureDeta
         throw error;
     }
 }
+/**
+ * The test listing API serialises a missing BrowserStack session id as the
+ * literal string "null", so treat that (and blanks) as absent.
+ */
+function extractSessionId(rawSessionId) {
+    if (typeof rawSessionId !== "string")
+        return undefined;
+    const sessionId = rawSessionId.trim();
+    return sessionId && sessionId !== "null" ? sessionId : undefined;
+}
 export function extractTestIds(hierarchy, status, includeFailureDetail = false) {
     let tests = [];
     for (const node of hierarchy) {
@@ -63,10 +73,12 @@ export function extractTestIds(hierarchy, status, includeFailureDetail = false)
         if (statusMatches && node.details?.observability_url) {
             const idMatch = node.details.observability_url.match(/details=(\d+)/);
             if (idMatch) {
+                const sessionId = extractSessionId(node.details.session_id);
                 const entry = {
                     test_id: idMatch[1],
                     test_name: node.display_name || `Test ${idMatch[1]}`,
                     status: nodeStatus,
+                    ...(sessionId && { session_id: sessionId }),
                 };
                 // Failure signatures only exist for failed tests; include when asked.
                 if (includeFailureDetail && nodeStatus === TestStatus.FAILED) {

package/dist/tools/rca-agent-utils/types.d.ts

@@ -30,6 +30,7 @@ export interface FailedTestInfo {
     test_name: string;
     status?: TestStatus;
     failure?: TestFailureSignature;
+    session_id?: string;
 }
 export declare enum RCAState {
     PENDING = "pending",

package/dist/tools/rca-agent.js

@@ -177,7 +177,7 @@ export default function addRCATools(server, config) {
             return handleMCPError("listBuildId", server, config, error);
         }
     });
-    tools.listTestIds = server.tool("listTestIds", "List all tests of a BrowserStack build (each with its status); optional status filter." +
+    tools.listTestIds = server.tool("listTestIds", "List all tests of a BrowserStack build (each with its status and session id); optional status filter." +
         NEEDS_BUILD_ID, LIST_TEST_IDS_PARAMS, {
         title: "List Test IDs",
         readOnlyHint: true,