rea-agents 2.5.0 → 3.1.0

package/dist/hopper/HopperClient.js

@@ -15,7 +15,7 @@ import { connectHopperSocketOnce } from "./HopperSocketConnection.js";
 import { hopperLauncherFailureDiagnostic } from "./HopperProcessDiagnostic.js";
 import { HopperRequestQueue, } from "./HopperRequestQueue.js";
 import { HopperResponseStream } from "./HopperResponseStream.js";
-import { responseResult } from "./protocol.js";
+import { responseResult, } from "./protocol.js";
 const SHUTDOWN_TIMEOUT_MS = 30_000;
 const MAX_QUEUED_REQUESTS = 64;
 const SESSION_ROOT = process.platform === "darwin" ? "/tmp" : tmpdir();
@@ -76,7 +76,7 @@ export class HopperClient {
             });
         });
         this.#responses = new HopperResponseStream({
-            accept: (response) => this.#requests.accept(response.id, responseResult(response)),
+            accept: (message) => this.#acceptBridgeMessage(message),
             hasQueued: (id) => this.#requests.hasQueued(id),
             nextRequestId: () => this.#nextId,
             abort: (message, cause) => this.#abortProtocol(message, cause),
@@ -333,6 +333,30 @@ export class HopperClient {
         socket.on("error", this.#onSocketError);
         socket.on("close", this.#onSocketClose);
     }
+    #acceptBridgeMessage(message) {
+        if (!("event" in message))
+            return this.#requests.accept(message.id, responseResult(message));
+        if (!this.#requests.acceptEvent(message))
+            return false;
+        this.#emitBridgeDiagnostic(message);
+        return true;
+    }
+    #emitBridgeDiagnostic(message) {
+        if (message.event.type !== "diagnostic")
+            return;
+        try {
+            this.#options.onDiagnostic?.({
+                type: "bridge-diagnostic",
+                request_id: message.id,
+                code: message.event.error.code,
+                category: message.event.error.type,
+                message: message.event.error.message,
+            });
+        }
+        catch {
+            this.#logger.warn({ requestId: message.id }, "Hopper bridge diagnostic consumer rejected an event");
+        }
+    }
     #detachSocket(socket) {
         socket.off("data", this.#onSocketData);
         socket.off("error", this.#onSocketError);
@@ -375,6 +399,6 @@ export class HopperClient {
     }
 }
 const isAborted = (signal) => signal?.aborted === true;
-const startupInterruption = (deadline) => deadline.cancelled
+const startupInterruption = (deadline) => deadline.interruption === "cancelled"
     ? new HopperCancelledError()
     : new HopperTimeoutError(deadline.timeoutMs);

package/dist/hopper/HopperProvider.js

@@ -3,7 +3,7 @@ import { accessSync, constants } from "node:fs";
 import { createAnalysisExecution } from "../application/AnalysisProvider.js";
 import { AnalysisCapabilityUnavailableError } from "../domain/errors.js";
 import { err } from "../domain/result.js";
-import { ENHANCED_TOOL_CONTRACTS, OFFICIAL_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { HopperApplicationLauncher } from "./BridgeLauncher.js";
 import { hopperLoaderArgsForTarget, resolveHopperAnalysisProfile, } from "./HopperAnalysisProfile.js";
 import { HopperClient } from "./HopperClient.js";
@@ -24,36 +24,47 @@ const MUTATING_OPERATIONS = new Set([
 ]);
 /** Tool contracts implemented directly by the Hopper adapter. */
 export const HOPPER_PROVIDER_TOOL_CONTRACTS = Object.freeze([
-    ...OFFICIAL_TOOL_CONTRACTS,
-    ...ENHANCED_TOOL_CONTRACTS.filter((contract) => contract.name === "analyze_function"),
+    ...GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy"),
+    ...GENERATED_MCP_TOOL_CATALOG.filter(({ name }) => name === "analyze_function"),
 ]);
-const CAPABILITIES = Object.freeze(HOPPER_PROVIDER_TOOL_CONTRACTS.map((contract) => Object.freeze({
-    provider: IDENTITY,
-    operation: contract.name,
-    inputContractVersion: 1,
-    outputContractVersion: 1,
-    available: true,
-    reason: null,
-    pagination: "offset" in contract.inputSchema.shape ? "offset" : "none",
-    exhaustive: false,
-    effects: Object.freeze({
-        mutatesArtifact: MUTATING_OPERATIONS.has(contract.name),
-        launchesProcess: true,
-        mayShowUi: true,
-        mayAccessNetwork: false,
-        mayWriteFilesystem: MUTATING_OPERATIONS.has(contract.name),
-        changesPermissions: false,
-        requiresRoot: false,
-    }),
-    limits: Object.freeze({
-        maxResults: null,
-        maxPayloadBytes: contract.name === "read_bytes" ? 4_096 : null,
-        timeoutMs: null,
-    }),
-    limitations: Object.freeze([
-        "Results depend on Hopper's completed static analysis.",
-    ]),
-})));
+const CAPABILITIES = Object.freeze(HOPPER_PROVIDER_TOOL_CONTRACTS.map((contract) => {
+    const operation = contract.analysisOperation;
+    if (operation === null)
+        throw new TypeError(`Missing analysis operation for ${contract.name}`);
+    return Object.freeze({
+        provider: IDENTITY,
+        operation,
+        inputContractVersion: 1,
+        outputContractVersion: 1,
+        available: true,
+        reason: null,
+        pagination: isRecord(contract.inputSchema.properties) &&
+            "offset" in contract.inputSchema.properties
+            ? "offset"
+            : "none",
+        exhaustive: false,
+        effects: Object.freeze({
+            mutatesArtifact: MUTATING_OPERATIONS.has(contract.name),
+            launchesProcess: true,
+            mayShowUi: true,
+            mayAccessNetwork: false,
+            mayWriteFilesystem: MUTATING_OPERATIONS.has(contract.name),
+            changesPermissions: false,
+            requiresRoot: false,
+        }),
+        limits: Object.freeze({
+            maxResults: null,
+            maxPayloadBytes: contract.name === "read_bytes" ? 4_096 : null,
+            timeoutMs: null,
+        }),
+        limitations: Object.freeze([
+            "Results depend on Hopper's completed static analysis.",
+        ]),
+    });
+}));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /** Concrete analysis provider backed by REA's private Hopper bridge. */
 export class HopperProvider {
     config;
@@ -118,20 +129,6 @@ export class HopperProvider {
                 reason: null,
                 diagnostics,
             };
-        if (!["mach-o", "elf", "pe"].includes(target.format))
-            return {
-                status: "unsupported",
-                code: "target_format_unsupported",
-                reason: `Hopper cannot open ${target.format} through this adapter.`,
-                diagnostics,
-            };
-        if (target.architecture === undefined)
-            return {
-                status: "unsupported",
-                code: "architecture_unsupported",
-                reason: "Hopper requires a supported concrete target architecture.",
-                diagnostics,
-            };
         return {
             status: "supported",
             code: null,
@@ -178,6 +175,7 @@ export class HopperProvider {
             }),
             ...(context === undefined ? {} : { runId: context.runId }),
             logger: this.logger.child({ layer: "bridge" }),
+            onDiagnostic: (diagnostic) => this.logger.info(diagnostic, "Hopper bridge reported a diagnostic"),
         });
         return {
             execute: async (operation, parameters, options) => {

package/dist/hopper/HopperRequestQueue.js

@@ -59,6 +59,28 @@ export class HopperRequestQueue {
         this.#drain();
         return true;
     }
+    /** Forward one correlated bridge event without releasing the wire request. */
+    acceptEvent(event) {
+        const entry = this.#active;
+        if (entry === undefined || entry.id !== event.id)
+            return false;
+        if (event.event.type === "progress" && !entry.callerSettled) {
+            if (event.event.terminal === true && entry.heartbeat !== undefined) {
+                clearInterval(entry.heartbeat);
+                entry.heartbeat = undefined;
+            }
+            this.#reportUpdate(entry, {
+                phase: event.event.phase,
+                completed: event.event.completed,
+                total: event.event.total,
+                message: event.event.message,
+                ...(event.event.terminal === undefined
+                    ? {}
+                    : { terminal: event.event.terminal }),
+            });
+        }
+        return true;
+    }
     /** Fail the active wire request and every request still waiting in the FIFO. */
     failAll(error) {
         const active = this.#active;
@@ -175,13 +197,19 @@ export class HopperRequestQueue {
             entry.signal.removeEventListener("abort", entry.onAbort);
     }
     #report(entry, message) {
-        void entry.progress
-            ?.report({
+        this.#reportUpdate(entry, {
             phase: "hopper_request",
             completed: 0,
             total: 1,
             message,
-        })
-            .catch(() => undefined);
+        });
+    }
+    #reportUpdate(entry, update) {
+        try {
+            void Promise.resolve(entry.progress?.report(update)).catch(() => undefined);
+        }
+        catch {
+            // Progress observation cannot change the request outcome.
+        }
     }
 }

package/dist/hopper/HopperResponseStream.js

@@ -1,4 +1,4 @@
-import { parseResponseLine } from "./protocol.js";
+import { parseBridgeMessageLine, } from "./protocol.js";
 const MAX_LINE_BYTES = 10 * 1024 * 1024;
 /** Incrementally validates bounded Hopper NDJSON response frames. */
 export class HopperResponseStream {
@@ -29,7 +29,7 @@ export class HopperResponseStream {
         this.#buffer = "";
     }
     #acceptLine(line) {
-        const parsed = parseResponseLine(line);
+        const parsed = parseBridgeMessageLine(line);
         if (!parsed.ok) {
             this.options.abort(parsed.error.message, parsed.error);
             return false;

package/dist/hopper/LinuxPrivateDisplayProbe.js

@@ -42,7 +42,7 @@ export const selectLinuxPrivateDisplayStrategy = async (options) => {
 /** Run one helper probe in an owned process group with a hard output bound. */
 export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
     if (options.signal?.aborted === true)
-        return emptyProcessResult({ cancelled: true });
+        return emptyProcessResult("cancelled");
     const command = privateDisplayProbeCommand(options.helperPath, strategy);
     let started;
     try {
@@ -54,7 +54,7 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         });
     }
     catch {
-        return emptyProcessResult();
+        return emptyProcessResult("launch-failed");
     }
     const launch = {
         process: started.process,
@@ -74,12 +74,15 @@ export const runLinuxPrivateDisplayProbe = async (strategy, options) => {
         supervisor.dispose();
     const snapshot = supervisor.snapshot();
     return {
+        outcome: outcome === "exit"
+            ? "exited"
+            : outcome === "timeout"
+                ? "timed-out"
+                : "cancelled",
         exitCode: snapshot.exitCode,
         stderr: snapshot.stderr.text,
         stderrBytes: snapshot.stderr.bytes,
         stderrTruncated: snapshot.stderr.truncated,
-        timedOut: outcome === "timeout",
-        cancelled: outcome === "cancelled",
         cleanupIncomplete,
     };
 };
@@ -119,16 +122,21 @@ const evaluatedProbe = async (strategy, options, timeoutMs, runner) => {
             diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
         };
     }
-    if (processResult.cancelled)
+    if (processResult.outcome === "cancelled")
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "cancelled"),
         };
-    if (processResult.timedOut)
+    if (processResult.outcome === "timed-out")
         return {
             ok: false,
             diagnostic: syntheticDiagnostic(strategy, "probe_timeout"),
         };
+    if (processResult.outcome === "launch-failed")
+        return {
+            ok: false,
+            diagnostic: syntheticDiagnostic(strategy, "probe_failed"),
+        };
     if (processResult.cleanupIncomplete)
         return {
             ok: false,
@@ -182,15 +190,13 @@ const unavailable = (diagnostic) => ({
         : (hopperStartupExitCode(diagnostic.failure_code) ?? 70),
     diagnostic: { ...diagnostic, strategy: "unavailable" },
 });
-const emptyProcessResult = (overrides = {}) => ({
+const emptyProcessResult = (outcome) => ({
+    outcome,
     exitCode: undefined,
     stderr: "",
     stderrBytes: 0,
     stderrTruncated: false,
-    timedOut: false,
-    cancelled: false,
     cleanupIncomplete: false,
-    ...overrides,
 });
 const waitForProbeExit = async (supervisor, timeoutMs, signal) => {
     if (signal?.aborted === true)

package/dist/hopper/protocol.js

@@ -2,30 +2,72 @@ import { z } from "zod";
 import { HopperProtocolError, HopperRemoteError } from "../domain/errors.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
+const remoteErrorSchema = z
+    .object({
+    code: z.number().int(),
+    message: z.string().max(512),
+    type: z
+        .enum([
+        "remote",
+        "authorization",
+        "invalid_request",
+        "capability_unavailable",
+        "bridge_exception",
+    ])
+        .default("remote"),
+})
+    .strict();
 const responseSchema = z.union([
-    z.object({
+    z
+        .object({
         id: z.number().int().nonnegative(),
         result: jsonValueSchema,
-    }),
-    z.object({
+    })
+        .strict(),
+    z
+        .object({
         id: z.number().int().nonnegative(),
-        error: z.object({
-            code: z.number().int(),
-            message: z.string(),
-            type: z
-                .enum([
-                "remote",
-                "authorization",
-                "invalid_request",
-                "capability_unavailable",
-                "bridge_exception",
-            ])
-                .default("remote"),
-        }),
-    }),
+        error: remoteErrorSchema,
+    })
+        .strict(),
 ]);
-/** Parse one complete Hopper NDJSON response line. */
-export const parseResponseLine = (line) => {
+const eventSchema = z
+    .object({
+    id: z.number().int().nonnegative(),
+    event: z.discriminatedUnion("type", [
+        z
+            .object({
+            type: z.literal("progress"),
+            phase: z.string().min(1).max(64),
+            completed: z.number().nonnegative().finite(),
+            total: z.number().nonnegative().finite().nullable(),
+            message: z.string().min(1).max(512),
+            terminal: z.boolean().optional(),
+        })
+            .strict(),
+        z
+            .object({
+            type: z.literal("diagnostic"),
+            error: remoteErrorSchema,
+        })
+            .strict(),
+    ]),
+})
+    .strict()
+    .superRefine((message, context) => {
+    if (message.event.type === "progress" &&
+        message.event.total !== null &&
+        message.event.completed > message.event.total) {
+        context.addIssue({
+            code: "custom",
+            message: "Progress total cannot be less than completed",
+            path: ["event", "total"],
+        });
+    }
+});
+const messageSchema = z.union([responseSchema, eventSchema]);
+/** Parse one complete Hopper NDJSON response or event line. */
+export const parseBridgeMessageLine = (line) => {
     let decoded;
     try {
         decoded = JSON.parse(line);
@@ -33,10 +75,10 @@ export const parseResponseLine = (line) => {
     catch (cause) {
         return err(new HopperProtocolError("Hopper returned malformed JSON", { cause }));
     }
-    const parsed = responseSchema.safeParse(decoded);
+    const parsed = messageSchema.safeParse(decoded);
     return parsed.success
         ? ok(parsed.data)
-        : err(new HopperProtocolError("Hopper returned a response outside the bridge contract", { cause: parsed.error }));
+        : err(new HopperProtocolError("Hopper returned a message outside the bridge contract", { cause: parsed.error }));
 };
 /** Project a parsed response into its result or expected remote failure. */
 export const responseResult = (response) => "error" in response

package/dist/main/reload.js

@@ -2,7 +2,7 @@ import { parseConfig } from "../config.js";
 import { readProjectPermissionStore } from "../application/ProjectPermissionStore.js";
 import { MCP_PERMISSION_RELOAD_FAILED } from "./messages.js";
 export const registerConfigReload = (input) => {
-    const { dependencies, permissionAuthority, runtimeState, liveServers, serverLogger, } = input;
+    const { dependencies, permissionAuthority, runtimeState, serverLogger } = input;
     let reloadQueue = Promise.resolve();
     return (dependencies.registerReload?.(() => {
         const refreshed = parseConfig(dependencies.env);
@@ -33,14 +33,9 @@ export const registerConfigReload = (input) => {
                 return;
             }
             runtimeState.currentConfig = refreshed.value;
-            Object.assign(runtimeState.processPolicy, refreshed.value.processExecutionPolicy);
             Object.assign(runtimeState.evidencePolicy, refreshed.value.evidenceFilePolicy);
             Object.assign(runtimeState.snapshotPolicy, refreshed.value.analysisSnapshotFilePolicy);
             runtimeState.investigationRoots.splice(0, runtimeState.investigationRoots.length, ...refreshed.value.investigationInputRoots);
-            Object.assign(runtimeState.javascriptReplayPolicy, refreshed.value.javascriptReplayPolicy);
-            Object.assign(runtimeState.managedRuntimePolicy, refreshed.value.managedRuntimePolicy);
-            for (const server of liveServers)
-                server.sendToolListChanged();
         })
             .catch(() => {
             serverLogger.error(MCP_PERMISSION_RELOAD_FAILED);

package/dist/main/state.js

@@ -1,11 +1,5 @@
 export const createRuntimeState = (config) => ({
     currentConfig: config,
-    processPolicy: {
-        ...config.processExecutionPolicy,
-        executableRoots: [...config.processExecutionPolicy.executableRoots],
-        workingRoots: [...config.processExecutionPolicy.workingRoots],
-        allowedEnvironment: [...config.processExecutionPolicy.allowedEnvironment],
-    },
     evidencePolicy: {
         ...config.evidenceFilePolicy,
         roots: [...config.evidenceFilePolicy.roots],
@@ -15,12 +9,4 @@ export const createRuntimeState = (config) => ({
         roots: [...config.analysisSnapshotFilePolicy.roots],
     },
     investigationRoots: [...config.investigationInputRoots],
-    javascriptReplayPolicy: {
-        ...config.javascriptReplayPolicy,
-        roots: [...config.javascriptReplayPolicy.roots],
-    },
-    managedRuntimePolicy: {
-        ...config.managedRuntimePolicy,
-        roots: [...config.managedRuntimePolicy.roots],
-    },
 });

package/dist/main/transport.js

@@ -1,31 +1,30 @@
-import { createServer } from "../server/createServer.js";
+import { createServer, } from "../server/createServer.js";
 import { MCP_CONNECTION_LOST, MCP_CONNECTION_START_FAILED, } from "./messages.js";
 export const startMcpTransport = async (dependencies, session, serverContext) => {
-    const liveServers = new Set();
     const { serverLogger } = serverContext;
+    let optionalProviders = {};
+    try {
+        optionalProviders = await serverContext.loadOptionalProviders();
+    }
+    catch {
+        serverLogger.warn("Optional MCP providers could not load; affected tools remain unavailable");
+    }
     let handle;
     try {
-        handle = dependencies.serve(() => {
-            const server = (dependencies.createServer ?? createServer)(session, session, {
-                logger: serverContext.logger,
-                processPolicy: serverContext.runtimeState.processPolicy,
-                evidenceFilePolicy: serverContext.runtimeState.evidencePolicy,
-                investigationInputRoots: serverContext.runtimeState.investigationRoots,
-                analysisSnapshotFilePolicy: serverContext.runtimeState.snapshotPolicy,
-                permissionAuthority: serverContext.permissionAuthority,
-                browserObservation: serverContext.browserObservation,
-                browserScenarioCapture: serverContext.browserScenarioCapture,
-                electronObservation: serverContext.electronObservation,
-                javascriptRuntimeObservation: serverContext.javascriptRuntimeObservation,
-                artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
-                    .artifactIntegrityContinueEnabled,
-                javascriptReplayPolicy: serverContext.runtimeState.javascriptReplayPolicy,
-                managedRuntimePolicy: serverContext.runtimeState.managedRuntimePolicy,
-                availabilityPolicy: () => runtimeAvailability(serverContext.runtimeState),
-            });
-            liveServers.add(server);
-            return server;
-        }, {
+        handle = dependencies.serve(() => (dependencies.createServer ?? createServer)(session, session, {
+            logger: serverContext.logger,
+            processPolicy: () => serverContext.runtimeState.currentConfig.processExecutionPolicy,
+            evidenceFilePolicy: serverContext.runtimeState.evidencePolicy,
+            investigationInputRoots: serverContext.runtimeState.investigationRoots,
+            analysisSnapshotFilePolicy: serverContext.runtimeState.snapshotPolicy,
+            permissionAuthority: serverContext.permissionAuthority,
+            ...optionalProviders,
+            artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
+                .artifactIntegrityContinueEnabled,
+            javascriptReplayPolicy: () => serverContext.runtimeState.currentConfig.javascriptReplayPolicy,
+            managedRuntimePolicy: () => serverContext.runtimeState.currentConfig.managedRuntimePolicy,
+            availabilityPolicy: () => runtimeAvailability(serverContext.runtimeState),
+        }), {
             onerror: () => {
                 serverLogger.error(MCP_CONNECTION_LOST);
                 dependencies.writeStderr(`${MCP_CONNECTION_LOST}\n`);
@@ -38,26 +37,17 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
         dependencies.writeStderr(`${MCP_CONNECTION_START_FAILED}\n`);
         return { ok: false };
     }
-    return { ok: true, handle, liveServers };
+    return { ok: true, handle };
 };
 const runtimeAvailability = (state) => ({
-    processCaptureEnabled: state.currentConfig.processExecutionPolicy.enabled,
+    processCaptureEnabled: state.currentConfig.processExecutionPolicy.status === "enabled",
     evidenceFileRoots: state.currentConfig.evidenceFilePolicy.roots.length,
     investigationInputRoots: state.currentConfig.investigationInputRoots.length,
-    browserObservationEnabled: state.currentConfig.browserObservationEnabled &&
-        state.currentConfig.browserCdpEndpoints.length > 0 &&
-        state.currentConfig.browserAllowedOrigins.length > 0,
-    browserScenarioEnabled: state.currentConfig.browserScenarioPolicy.enabled &&
-        state.currentConfig.browserScenarioPolicy.allowedOrigins.length > 0 &&
-        (state.currentConfig.browserScenarioPolicy.executableRoots.length > 0 ||
-            state.currentConfig.browserScenarioPolicy.cdpEndpoints.length > 0),
-    electronObservationEnabled: state.currentConfig.electronObservationEnabled &&
-        state.currentConfig.electronCdpEndpoints.length > 0 &&
-        state.currentConfig.electronFileRoots.length > 0,
-    v8InspectorObservationEnabled: state.currentConfig.v8InspectorObservationEnabled &&
-        state.currentConfig.v8InspectorEndpoints.length > 0 &&
-        (state.currentConfig.v8InspectorFileRoots.length > 0 ||
-            state.currentConfig.v8InspectorAllowedOrigins.length > 0),
-    javascriptReplayEnabled: state.currentConfig.javascriptReplayPolicy.enabled,
-    managedRuntimeEnabled: state.currentConfig.managedRuntimePolicy.enabled,
+    browserObservationEnabled: state.currentConfig.browserObservationPolicy.status === "enabled",
+    browserScenarioEnabled: state.currentConfig.browserScenarioPolicy.status === "enabled",
+    electronObservationEnabled: state.currentConfig.electronObservationPolicy.status === "enabled",
+    electronAutomationEnabled: state.currentConfig.electronAutomationPolicy.status === "enabled",
+    v8InspectorObservationEnabled: state.currentConfig.v8InspectorObservationPolicy.status === "enabled",
+    javascriptReplayEnabled: state.currentConfig.javascriptReplayPolicy.status === "enabled",
+    managedRuntimeEnabled: state.currentConfig.managedRuntimePolicy.status === "enabled",
 });

package/dist/main.js

@@ -7,10 +7,6 @@ import { createBinarySession } from "./application/runtime.js";
 import { createLogger } from "./logger.js";
 import { projectAnalysisError } from "./domain/errors.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
-import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
-import { CdpElectronProvider } from "./browser/CdpElectronProvider.js";
-import { V8InspectorProvider } from "./browser/V8InspectorProvider.js";
-import { PlaywrightBrowserScenarioProvider } from "./browser/PlaywrightBrowserScenarioProvider.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
 import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
@@ -60,10 +56,6 @@ export const run = async (dependencies = runtimeDependencies()) => {
         return 1;
     }
     const session = createBinarySession(config.value, logger);
-    const browserObservation = new CdpBrowserProvider();
-    const browserScenarioCapture = new PlaywrightBrowserScenarioProvider();
-    const electronObservation = new CdpElectronProvider();
-    const javascriptRuntimeObservation = new V8InspectorProvider();
     const opened = await openInitialTarget(session, config.value, serverLogger, dependencies.writeStderr);
     if (!opened.ok)
         return opened.exitCode;
@@ -71,10 +63,23 @@ export const run = async (dependencies = runtimeDependencies()) => {
     const transport = await startMcpTransport(dependencies, session, {
         logger,
         serverLogger,
-        browserObservation,
-        browserScenarioCapture,
-        electronObservation,
-        javascriptRuntimeObservation,
+        loadOptionalProviders: dependencies.loadOptionalProviders ??
+            (async () => {
+                const [{ CdpBrowserProvider }, { PlaywrightBrowserScenarioProvider }, { CdpElectronProvider }, { PlaywrightElectronActiveProvider }, { V8InspectorProvider },] = await Promise.all([
+                    import("./browser/CdpBrowserProvider.js"),
+                    import("./browser/PlaywrightBrowserScenarioProvider.js"),
+                    import("./browser/CdpElectronProvider.js"),
+                    import("./browser/PlaywrightElectronActiveProvider.js"),
+                    import("./browser/V8InspectorProvider.js"),
+                ]);
+                return {
+                    browserObservation: new CdpBrowserProvider(),
+                    browserScenarioCapture: new PlaywrightBrowserScenarioProvider(),
+                    electronObservation: new CdpElectronProvider(),
+                    electronActiveObservation: new PlaywrightElectronActiveProvider(),
+                    javascriptRuntimeObservation: new V8InspectorProvider(),
+                };
+            }),
         permissionAuthority: permissionAuthority.value,
         runtimeState,
     });
@@ -84,7 +89,6 @@ export const run = async (dependencies = runtimeDependencies()) => {
         dependencies,
         permissionAuthority: permissionAuthority.value,
         runtimeState,
-        liveServers: transport.liveServers,
         serverLogger,
     });
     createShutdown({