@browserstack/mcp-server 1.5.0-beta.21 → 1.5.0-beta.23

package/dist/tools/capability-registry/types.d.ts

@@ -0,0 +1,282 @@
+/**
+ * The shape of the index artifact, which is the contract with the export pipeline.
+ *
+ * The artifact is generated by the capability-registry build and transformed into its
+ * released envelope by the export pipeline's merge step. It contains ONLY data that has
+ * already passed that side's outbound boundary. Nothing here is parsed from an OpenAPI spec
+ * at runtime: if this half parsed specs it would become the boundary, and every gate (route
+ * lint, vocabulary rule, intent lint, discovery denylist) would have to be reimplemented and
+ * re-tested here. Reading a pre-projected index means the internal data is not in the
+ * package at all.
+ *
+ * ONE FILE PER PRODUCT. The released artifact is `capability/<product>.capability-index.json`,
+ * with the
+ * product object at the top level under its own name. The plural `products` wrapper belonged
+ * to the pre-release shape and implied multi-product files that never existed.
+ */
+/**
+ * The envelope's format marker, for FUTURE shape changes.
+ *
+ * BOTH the released and the pre-release shapes claim 1, so this number cannot distinguish
+ * them — `readIndexFile` shape-detects on the `products` wrapper instead. The check is still
+ * worth keeping: it is what refuses a shape the generator has announced but this build does
+ * not read.
+ */
+export declare const SUPPORTED_SCHEMA_VERSION = 1;
+/** Envelope keys, i.e. everything at the top level that is NOT the product object. */
+export declare const ENVELOPE_KEYS: readonly ["schema_version", "version", "build_id", "harness_commit", "products"];
+export type Mode = "read" | "write" | "destructive";
+/** One parameter, under the name the OpenAPI spec itself gives it. */
+/**
+ * The constraints a parameter may declare beyond its type.
+ *
+ * ALL OPTIONAL, and absent means unchecked. The released artifact carries none of these
+ * yet — tm's spec holds 59 `format`, 50 `default`, 23 `minimum`, 12 `maximum`, 10
+ * `minItems`, 7 `maxItems`, 4 `minLength`, 3 `pattern` and 2 `maxLength` that the export
+ * currently drops — so this ships inert and starts working the moment the export carries
+ * them. An older index must keep binding exactly as it does today.
+ */
+export interface WireConstraints {
+    /** Numbers. `multipleOf` is checked on the coerced number, not the raw string. */
+    minimum?: number;
+    maximum?: number;
+    multipleOf?: number;
+    /** Strings. `pattern` is an unanchored regex, compiled with `u` for `\p{…}` classes. */
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    /** Arrays. */
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    /**
+     * The value the product uses when the field is omitted.
+     *
+     * PUBLISHED, NOT INJECTED. Telling a caller the default is what stops the redundant send;
+     * filling it in here would put a value on the wire that the caller never chose, and pin
+     * a server-side default that is free to change. Omission and "explicitly the default" are
+     * different requests, and only the product knows whether that difference matters.
+     */
+    default?: unknown;
+}
+/** One field inside an array item or a nested object — same constraints, one level down. */
+export interface WireField extends WireConstraints {
+    name: string;
+    type: string;
+    required?: true;
+    values?: unknown[];
+}
+export interface WireParam extends WireConstraints {
+    name: string;
+    type: string;
+    required?: true;
+    values?: unknown[];
+    example?: unknown;
+    description?: string;
+    /** Field names/types one level inside an array item or nested object. */
+    fields?: WireField[];
+    /**
+     * Where a body field sits in the JSON, when that differs from its name. Published
+     * because the nesting is not guessable and getting it wrong fails silently — tm's folder
+     * create really wants `{folder: {name}}` while the spec's flat `{name}` is what a reader
+     * would assume.
+     */
+    json_path?: string;
+}
+/**
+ * A reference into a product-level lookup table.
+ *
+ * Named components are stored ONCE, already dereferenced and allOf-flattened at build time,
+ * so resolution is a single dict lookup rather than a recursive $ref walk at runtime.
+ */
+export interface ComponentRef {
+    $response?: string;
+    $schema?: string;
+}
+/** A JSON Schema fragment, or a reference to a named one. */
+export type SchemaNode = ComponentRef & Record<string, unknown>;
+/** One declared response, or a reference to a named one. */
+export interface ResponseDoc extends ComponentRef {
+    description?: string;
+    schema?: SchemaNode;
+}
+/** A capability, keyed by the endpoint it exposes. There is deliberately no name. */
+export interface Capability {
+    /**
+     * The caller-facing handle — the snake-cased `operationId`, unique within its product.
+     *
+     * This is what `invokeCapability` takes, and what `entities[*].capabilities[]` lists. It
+     * is stable where a route is not: `/edit` becoming `/edit-v2` must not break a caller
+     * holding a handle.
+     *
+     * OPTIONAL because not every product publishes it yet — loadtesting's index carries none.
+     * For those, the endpoint remains the handle, so nothing may assume this is present.
+     */
+    name?: string;
+    method: string;
+    path: string;
+    mode: Mode;
+    entity: string;
+    path_params?: WireParam[];
+    query?: WireParam[];
+    body?: WireParam[];
+    intent?: string;
+    /**
+     * How to call the endpoint correctly.
+     *
+     * ABSENT from the released artifact — the export dropped it, and the shape-change note
+     * does not say whether that was intended. Kept optional and still scored by search so the
+     * server works either way; nothing may depend on it being present.
+     */
+    guidance?: string[];
+    /** Allowlisted row fields. Absent when `shape` is "discovered". */
+    returns?: string[];
+    /** "discovered" when the product declares no response schema for this operation. */
+    shape?: "discovered";
+    requires?: string[];
+    paginated?: boolean;
+    /** The largest page the operation declares. */
+    max_page_size?: number;
+    /**
+     * Declared responses by status code, values possibly `{$response: "Name"}` references.
+     *
+     * ADDITIVE and not yet emitted: no capability in the current export carries it. Absence
+     * means "no response schema available", never an error. Resolve with `resolveComponent`.
+     */
+    responses?: Record<string, ResponseDoc>;
+}
+export interface EntityDoc {
+    title?: string;
+    /**
+     * One line saying what this entity IS. Rides on `listProducts`, next to the aliases.
+     *
+     * Aliases route; they do not define. `version -> history, revision, version-history`
+     * tells a caller which words land here and nothing about whether that is the versioning
+     * of a test case or of a project. Without this line the only way to find out is
+     * `describeEntity`, once per entity — 19 calls at ~1.4KB for tm, against ~1.6KB to
+     * answer it for all of them at once.
+     *
+     * Capped at 140 characters by the build, and dropped rather than truncated when longer.
+     * Often absent: a product that has not authored these emits none (loadtesting has 0 of
+     * 9 today), and absence means "unwritten", never an error.
+     */
+    description?: string;
+    aliases?: string[];
+    id_convention?: string;
+    parents?: string[];
+    relations?: {
+        entity?: string;
+        via?: string;
+    }[];
+    /**
+     * What a caller gets wrong about this ENTITY, as opposed to one operation.
+     *
+     * The entity-wide half of guidance: "a run's `id` is the display string, take `uuid`"
+     * holds for every capability returning a run, so it is stated once here rather than
+     * copied onto each capability's `guidance` — which would repeat across ~20 records and,
+     * since guidance is a search haystack, dilute ranking with boilerplate.
+     *
+     * Filtered at build time and often absent: of tm's 155 authored facts, 73 are publishable
+     * as written and the rest name routes, HTTP verbs or wire-shaped parameters. Absent means
+     * "none passed", never an error.
+     */
+    key_facts?: string[];
+    [key: string]: unknown;
+}
+/**
+ * Paging controls, keyed "METHOD /path".
+ *
+ * NOT USED BY THIS SERVER: it performs one request and returns the response, so paging
+ * belongs to the caller and the page parameters are published with the endpoint's other
+ * query parameters. The field is still emitted by the build, so it stays described here
+ * rather than silently ignored — a consumer that DOES page can use it.
+ */
+export interface PagingRule {
+    page?: string;
+    size?: string;
+    /** The largest page the operation declares. Absent when the spec states no maximum. */
+    max?: number;
+}
+/**
+ * How a product wants the caller's credentials presented.
+ *
+ * The OpenAPI `securityScheme` vocabulary, verbatim — `type` / `in` / `name` / `scheme` —
+ * because the spec already describes this and inventing a parallel taxonomy would mean
+ * translating between two of them forever. ONE scheme per product, not OpenAPI's list of
+ * alternatives: this server holds a username and an access key and nothing else, so
+ * "the first alternative we can satisfy" only ever had one answer.
+ *
+ * `template` is what makes it a contract rather than a guess — a product taking
+ * `{username}_{access_key}` is expressible instead of being a special case in the server.
+ * It names placeholders, never values: the credential itself stays in config, and the
+ * harness's `{ env: … }` value sources must NOT cross the boundary into the artifact.
+ */
+export interface AuthScheme {
+    /** "apiKey" puts the rendered template in a header; "http" with scheme "basic" encodes it. */
+    type: "apiKey" | "http";
+    /** apiKey only. Header is the sole supported location — see `egress.authHeaders`. */
+    in?: "header" | "cookie" | "query";
+    /** apiKey only: the header name, e.g. "Api-Token". */
+    name?: string;
+    /** http only. */
+    scheme?: string;
+    /** Defaults to `{username}:{access_key}`. */
+    template?: string;
+}
+export interface ProductIndex {
+    summary: string;
+    /**
+     * How to authenticate to this product. Absent means the historical default: the caller's
+     * credentials as `Api-Token: {username}:{access_key}`, which is what every shipped index
+     * relies on today.
+     */
+    auth?: AuthScheme;
+    /**
+     * The single host this product is served from, when it has one.
+     *
+     * A default, not the last word: config overrides it, and for a region-sharded product
+     * (one declaring `base_urls`) account discovery outranks it and this is the fallback.
+     */
+    base_url?: string;
+    /**
+     * Candidate regional hosts, in probe order, for a product whose host depends on the
+     * ACCOUNT rather than the deployment.
+     *
+     * Declaring these makes the product region-sharded: the server asks each in turn with the
+     * caller's credentials and keeps the one that answers. A single fixed `base_url` cannot
+     * express this — it would send every account outside the default region to the wrong host,
+     * a failure invisible to anyone testing from inside that region.
+     */
+    base_urls?: string[];
+    /**
+     * The endpoint to probe the candidates with. Derived from the capabilities when absent
+     * (see `discovery.probePath`); declare it when the derived choice would be wrong.
+     */
+    probe_path?: string;
+    capabilities: Capability[];
+    entities: Record<string, EntityDoc>;
+    paging?: Record<string, PagingRule>;
+    /** Named responses, referenced as `{$response: "Name"}`. Additive; not yet emitted. */
+    responses?: Record<string, ResponseDoc>;
+    /** Named schemas, referenced as `{$schema: "Name"}`. Additive; not yet emitted. */
+    schemas?: Record<string, SchemaNode>;
+}
+/** Where one product's data came from. Logging and cache-busting only. */
+export interface Provenance {
+    /** `<commit>_<UTC timestamp>` in the released shape. */
+    build_id: string;
+    /** Dotted content-generation counter, e.g. "1.2". Absent in the pre-release shape. */
+    version?: string;
+}
+/**
+ * The merged, in-memory model: every loaded file's product under its own name.
+ *
+ * This is the server's own structure, not the file format — one file carries one product,
+ * and the registry holds all of them so a caller can search across products.
+ */
+export interface RegistryIndex {
+    schema_version: number;
+    build_id: string;
+    products: Record<string, ProductIndex>;
+}

package/dist/tools/capability-registry/types.js

@@ -0,0 +1,33 @@
+/**
+ * The shape of the index artifact, which is the contract with the export pipeline.
+ *
+ * The artifact is generated by the capability-registry build and transformed into its
+ * released envelope by the export pipeline's merge step. It contains ONLY data that has
+ * already passed that side's outbound boundary. Nothing here is parsed from an OpenAPI spec
+ * at runtime: if this half parsed specs it would become the boundary, and every gate (route
+ * lint, vocabulary rule, intent lint, discovery denylist) would have to be reimplemented and
+ * re-tested here. Reading a pre-projected index means the internal data is not in the
+ * package at all.
+ *
+ * ONE FILE PER PRODUCT. The released artifact is `capability/<product>.capability-index.json`,
+ * with the
+ * product object at the top level under its own name. The plural `products` wrapper belonged
+ * to the pre-release shape and implied multi-product files that never existed.
+ */
+/**
+ * The envelope's format marker, for FUTURE shape changes.
+ *
+ * BOTH the released and the pre-release shapes claim 1, so this number cannot distinguish
+ * them — `readIndexFile` shape-detects on the `products` wrapper instead. The check is still
+ * worth keeping: it is what refuses a shape the generator has announced but this build does
+ * not read.
+ */
+export const SUPPORTED_SCHEMA_VERSION = 1;
+/** Envelope keys, i.e. everything at the top level that is NOT the product object. */
+export const ENVELOPE_KEYS = [
+    "schema_version",
+    "version",
+    "build_id",
+    "harness_commit",
+    "products",
+];

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

@@ -1,7 +1,6 @@
 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`;
@@ -23,7 +22,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${wrapUntrusted("device logs", JSON.stringify(logs, null, 2))}`
+        ? `Device Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No device failures found";
 }
 // APPIUM LOGS
@@ -47,7 +46,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${wrapUntrusted("Appium logs", JSON.stringify(logs, null, 2))}`
+        ? `Appium Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No Appium failures found";
 }
 // CRASH LOGS
@@ -71,7 +70,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${wrapUntrusted("crash logs", JSON.stringify(logs, null, 2))}`
+        ? `Crash Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No crash failures found";
 }
 // FILTER HELPERS

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

@@ -1,5 +1,4 @@
 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
@@ -23,7 +22,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${wrapUntrusted("network logs", JSON.stringify(failureEntries.map((entry) => ({
+        ? `Network Failures (${failureEntries.length} found):\n${JSON.stringify(failureEntries.map((entry) => ({
             startedDateTime: entry.startedDateTime,
             request: {
                 method: entry.request?.method,
@@ -37,7 +36,7 @@ export async function retrieveNetworkFailures(sessionId, config) {
             },
             serverIPAddress: entry.serverIPAddress,
             time: entry.time,
-        })), null, 2))}`
+        })), null, 2)}`
         : "No network failures found";
 }
 // SESSION LOGS
@@ -61,7 +60,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${wrapUntrusted("session logs", JSON.stringify(logs, null, 2))}`
+        ? `Session Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No session failures found";
 }
 // CONSOLE LOGS
@@ -85,7 +84,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${wrapUntrusted("console logs", JSON.stringify(logs, null, 2))}`
+        ? `Console Failures (${logs.length} found):\n${JSON.stringify(logs, null, 2)}`
         : "No console failures found";
 }
 // FILTER: session logs

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

@@ -1,11 +1,8 @@
 import { z } from "zod";
 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 { 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";
+import { AppAutomateLogType, AutomateLogType, SessionType, } from "../lib/constants.js";
 // Main log fetcher function
 export async function getFailureLogs(args, config) {
     const results = [];
@@ -14,16 +11,17 @@ 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: ${[
-                ...new Set([
-                    ...Object.values(AutomateLogType),
-                    ...Object.values(AppAutomateLogType),
-                ]),
+                ...Object.values(AutomateLogType),
+                ...Object.values(AppAutomateLogType),
             ].join(", ")}`);
             return false;
         }
@@ -48,26 +46,11 @@ 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 });
@@ -84,17 +67,17 @@ export async function getFailureLogs(args, config) {
                     break;
                 }
                 case AppAutomateLogType.DeviceLogs: {
-                    response = await retrieveDeviceLogs(args.sessionId, buildId, config);
+                    response = await retrieveDeviceLogs(args.sessionId, args.buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.AppiumLogs: {
-                    response = await retrieveAppiumLogs(args.sessionId, buildId, config);
+                    response = await retrieveAppiumLogs(args.sessionId, args.buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
                 case AppAutomateLogType.CrashLogs: {
-                    response = await retrieveCrashLogs(args.sessionId, buildId, config);
+                    response = await retrieveCrashLogs(args.sessionId, args.buildId, config);
                     results.push({ type: "text", text: response });
                     break;
                 }
@@ -115,8 +98,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 logs, or the session video URL, for an Automate/App Automate session." +
-        NEEDS_SESSION_ID, {
+    tools.getFailureLogs = server.tool("getFailureLogs", "Fetch various types of logs from a BrowserStack session. Supports both automate and app-automate sessions.", {
         sessionType: z
             .enum([SessionType.Automate, SessionType.AppAutomate])
             .describe("Type of BrowserStack session. Must be explicitly provided by the user."),
@@ -126,7 +108,7 @@ export default function registerGetFailureLogs(server, config) {
         buildId: z
             .string()
             .optional()
-            .describe("App Automate build ID. Optional — resolved from the session if omitted."),
+            .describe("Required only when sessionType is 'app-automate'. If sessionType is 'app-automate', always ask the user to provide the build ID before proceeding."),
         logTypes: z
             .array(z.enum([
             AutomateLogType.NetworkLogs,
@@ -135,7 +117,6 @@ 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,4 +1,3 @@
-import { wrapUntrusted } from "../lib/untrusted-content.js";
 import { z } from "zod";
 import { getLatestO11YBuildInfo } from "../lib/api.js";
 import { trackMCP } from "../lib/instrumentation.js";
@@ -27,8 +26,7 @@ export async function getFailuresInLastRun(buildName, projectName, config) {
         content: [
             {
                 type: "text",
-                text: `Observability URL: ${observabilityUrl}\n` +
-                    wrapUntrusted("observability failure report", `Overview: ${overview}\nError Details: ${details}`),
+                text: `Observability URL: ${observabilityUrl}\nOverview: ${overview}\nError Details: ${details}`,
             },
         ],
     };

package/dist/tools/percy-sdk.js

@@ -38,11 +38,11 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async (args) => {
         try {
-            trackMCP("percyVisualTestIntegrationAgent", server.server.getClientVersion(), undefined, config);
+            trackMCP("VisualTestIntegrationAgent", server.server.getClientVersion(), config);
             return simulatePercyChangeHandler(args, config);
         }
         catch (error) {
-            return handleMCPError("percyVisualTestIntegrationAgent", server, config, error);
+            return handleMCPError("VisualTestIntegrationAgent", server, config, error);
         }
     });
     tools.setupPercyVisualTesting = server.tool("expandPercyVisualTesting", SETUP_PERCY_DESCRIPTION, SetUpPercyParamsShape, {
@@ -53,11 +53,11 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async (args) => {
         try {
-            trackMCP("expandPercyVisualTesting", server.server.getClientVersion(), undefined, config);
+            trackMCP("setupPercyVisualTesting", server.server.getClientVersion(), config);
             return setUpPercyHandler(args, config);
         }
         catch (error) {
-            return handleMCPError("expandPercyVisualTesting", server, config, error);
+            return handleMCPError("setupPercyVisualTesting", server, config, error);
         }
     });
     tools.addPercySnapshotCommands = server.tool("addPercySnapshotCommands", PERCY_SNAPSHOT_COMMANDS_DESCRIPTION, UpdateTestFileWithInstructionsParams, {
@@ -68,7 +68,7 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async (args) => {
         try {
-            trackMCP("addPercySnapshotCommands", server.server.getClientVersion(), undefined, config);
+            trackMCP("addPercySnapshotCommands", server.server.getClientVersion(), config);
             return await updateTestsWithPercyCommands(args);
         }
         catch (error) {
@@ -83,7 +83,7 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async () => {
         try {
-            trackMCP("listTestFiles", server.server.getClientVersion(), undefined, config);
+            trackMCP("listTestFiles", server.server.getClientVersion(), config);
             return addListTestFiles();
         }
         catch (error) {
@@ -98,7 +98,7 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async (args) => {
         try {
-            trackMCP("runPercyScan", server.server.getClientVersion(), undefined, config);
+            trackMCP("runPercyScan", server.server.getClientVersion(), config);
             return runPercyScan(args);
         }
         catch (error) {
@@ -113,7 +113,7 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async (args) => {
         try {
-            trackMCP("fetchPercyChanges", server.server.getClientVersion(), undefined, config);
+            trackMCP("fetchPercyChanges", server.server.getClientVersion(), config);
             return await fetchPercyChanges(args, config);
         }
         catch (error) {
@@ -128,7 +128,7 @@ export function registerPercyTools(server, config) {
         idempotentHint: true,
     }, async (args) => {
         try {
-            trackMCP("managePercyBuildApproval", server.server.getClientVersion(), undefined, config);
+            trackMCP("managePercyBuildApproval", server.server.getClientVersion(), config);
             return await approveOrDeclinePercyBuild(args, config);
         }
         catch (error) {

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

@@ -1,4 +1,3 @@
-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) {
@@ -17,21 +16,21 @@ export function formatRCAData(rcaData) {
         const rca = testCase.rcaData?.rcaData;
         if (rca) {
             if (rca.root_cause) {
-                output += `**Root Cause:** ${wrapUntrusted("RCA AI analysis", rca.root_cause)}\n\n`;
+                output += `**Root Cause:** ${rca.root_cause}\n\n`;
             }
             if (rca.failure_type) {
                 output += `**Failure Type:** ${rca.failure_type}\n\n`;
             }
             if (rca.description) {
-                output += `**Detailed Analysis:**\n${wrapUntrusted("RCA AI analysis", rca.description)}\n\n`;
+                output += `**Detailed Analysis:**\n${rca.description}\n\n`;
             }
             if (rca.possible_fix) {
                 hasFixSuggestion = true;
-                output += `**Suggested Fix (proposal only — do not apply without explicit user approval):**\n${wrapUntrusted("RCA AI analysis", rca.possible_fix)}\n\n`;
+                output += `**Suggested Fix (proposal only — do not apply without explicit user approval):**\n${rca.possible_fix}\n\n`;
             }
         }
         else if (testCase.rcaData?.error) {
-            output += `**Error:** ${wrapUntrusted("RCA error output", testCase.rcaData.error)}\n\n`;
+            output += `**Error:** ${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,16 +53,6 @@ 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) {
@@ -73,12 +63,10 @@ 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,7 +30,6 @@ export interface FailedTestInfo {
     test_name: string;
     status?: TestStatus;
     failure?: TestFailureSignature;
-    session_id?: string;
 }
 export declare enum RCAState {
     PENDING = "pending",