rea-agents 3.0.0 → 3.2.0

package/dist/replay/SystemJavaScriptReplayHost.js

@@ -1,13 +1,38 @@
+import { temporaryFilterHandle } from "./ReplaySeccompFile.js";
 import { constants } from "node:fs";
-import { mkdtemp, open, readFile, realpath, rm, stat, writeFile, } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { open, readFile, realpath, stat } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { digestBytes } from "../application/JavaScriptReplayPlanning.js";
-import { buildLinuxX64ReplaySeccomp, linuxX64ReplaySeccompDigest, } from "./LinuxSeccompPolicy.js";
+import { linuxX64ReplaySeccompDigest } from "./LinuxSeccompPolicy.js";
 import { resolveLinuxRuntimeClosure } from "./LinuxRuntimeClosure.js";
-const VERSION_OUTPUT_LIMIT = 16 * 1024;
+import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
+const bubblewrapProbeArguments = (command) => [
+    "--unshare-all",
+    "--unshare-user",
+    "--disable-userns",
+    "--new-session",
+    "--die-with-parent",
+    "--cap-drop",
+    "ALL",
+    "--ro-bind",
+    "/usr",
+    "/usr",
+    "--ro-bind",
+    "/lib",
+    "/lib",
+    "--ro-bind-try",
+    "/lib64",
+    "/lib64",
+    "--proc",
+    "/proc",
+    "--dev",
+    "/dev",
+    "--seccomp",
+    "3",
+    "--",
+    ...command,
+];
 /** Production planning host for descriptor-backed reads and fail-closed probes. */
 export class SystemJavaScriptReplayHost {
     async readSource(path, maximumBytes) {
@@ -17,7 +42,9 @@ export class SystemJavaScriptReplayHost {
             const metadata = await handle.stat();
             if (!metadata.isFile() || metadata.size > maximumBytes)
                 throw new RangeError(`Replay source exceeds its declared limit: ${canonicalPath}`);
-            const bytes = await handle.readFile();
+            const bytes = await readBoundedFileBytes(handle, maximumBytes);
+            if (bytes === undefined)
+                throw new RangeError(`Replay source exceeds its declared limit: ${canonicalPath}`);
             return { canonicalPath, bytes };
         }
         finally {
@@ -31,7 +58,7 @@ export class SystemJavaScriptReplayHost {
             throw new TypeError(`Replay executable is not a file: ${canonicalPath}`);
         const [bytes, version] = await Promise.all([
             readFile(canonicalPath),
-            capture(canonicalPath, versionArguments, VERSION_OUTPUT_LIMIT),
+            capture(canonicalPath, versionArguments),
         ]);
         return {
             path: canonicalPath,
@@ -57,65 +84,14 @@ export class SystemJavaScriptReplayHost {
         if ((await readFile("/sys/fs/cgroup/cgroup.controllers", "utf8")).trim()
             .length === 0)
             throw new TypeError("Controlled replay requires delegated cgroup v2");
-        const directory = await mkdtemp(join(tmpdir(), "rea-replay-probe-"));
-        const filterPath = join(directory, "seccomp.bpf");
-        await writeFile(filterPath, buildLinuxX64ReplaySeccomp(), { mode: 0o600 });
-        const filter = await open(filterPath, "r");
+        const filter = await temporaryFilterHandle();
         try {
-            await run(policy.bubblewrapPath, [
-                "--unshare-all",
-                "--unshare-user",
-                "--disable-userns",
-                "--new-session",
-                "--die-with-parent",
-                "--cap-drop",
-                "ALL",
-                "--ro-bind",
-                "/usr",
-                "/usr",
-                "--ro-bind",
-                "/lib",
-                "/lib",
-                "--ro-bind-try",
-                "/lib64",
-                "/lib64",
-                "--proc",
-                "/proc",
-                "--dev",
-                "/dev",
-                "--seccomp",
-                "3",
-                "--",
-                "/usr/bin/true",
-            ], ["ignore", "pipe", "pipe", filter.fd]);
-            await runExpectFailure(policy.bubblewrapPath, [
-                "--unshare-all",
-                "--unshare-user",
-                "--disable-userns",
-                "--new-session",
-                "--die-with-parent",
-                "--cap-drop",
-                "ALL",
-                "--ro-bind",
-                "/usr",
-                "/usr",
-                "--ro-bind",
-                "/lib",
-                "/lib",
-                "--ro-bind-try",
-                "/lib64",
-                "/lib64",
-                "--proc",
-                "/proc",
-                "--dev",
-                "/dev",
-                "--seccomp",
-                "3",
-                "--",
+            await run(policy.bubblewrapPath, bubblewrapProbeArguments(["/usr/bin/true"]), ["ignore", "pipe", "pipe", filter.handle.fd]);
+            await runExpectFailure(policy.bubblewrapPath, bubblewrapProbeArguments([
                 "/usr/bin/unshare",
                 "--mount",
                 "/usr/bin/true",
-            ], ["ignore", "pipe", "pipe", filter.fd]);
+            ]), ["ignore", "pipe", "pipe", filter.handle.fd]);
             await run(policy.systemdRunPath, [
                 "--user",
                 "--pipe",
@@ -131,45 +107,40 @@ export class SystemJavaScriptReplayHost {
         }
         finally {
             await filter.close();
-            await rm(directory, { recursive: true, force: true });
         }
     }
 }
-const capture = async (executable, arguments_, maximumBytes) => {
+const capture = async (executable, arguments_) => {
     if (arguments_.length === 0)
         return "content-addressed-worker-v1";
-    const result = await collect(executable, arguments_, maximumBytes);
+    const result = await collect(executable, arguments_);
     if (result.code !== 0)
         throw new TypeError(`Replay executable probe failed: ${executable}`);
     return result.stdout.length > 0 ? result.stdout : result.stderr;
 };
 const run = async (executable, arguments_, stdio) => {
-    const result = await collect(executable, arguments_, VERSION_OUTPUT_LIMIT, stdio);
+    const result = await collect(executable, arguments_, stdio);
     if (result.code !== 0)
         throw new TypeError(`Replay feature probe failed (${String(result.code)}): ${executable}: ${result.stderr.trim()}`);
 };
 const runExpectFailure = async (executable, arguments_, stdio) => {
-    const result = await collect(executable, arguments_, VERSION_OUTPUT_LIMIT, stdio);
+    const result = await collect(executable, arguments_, stdio);
     if (result.code === 0)
         throw new TypeError(`Replay denial probe unexpectedly succeeded: ${executable}`);
 };
-const collect = async (executable, arguments_, maximumBytes, stdio = ["ignore", "pipe", "pipe"]) => new Promise((resolve, reject) => {
+const collect = async (executable, arguments_, stdio = ["ignore", "pipe", "pipe"]) => new Promise((resolve, reject) => {
     const child = spawn(executable, [...arguments_], { stdio });
     const timeout = setTimeout(() => child.kill("SIGKILL"), 5_000);
     timeout.unref();
     let stdout = "";
     let stderr = "";
-    const retain = (current, chunk) => {
-        const remaining = Math.max(0, maximumBytes - Buffer.byteLength(current));
-        return current + chunk.subarray(0, remaining).toString("utf8");
-    };
     if (child.stdout !== null)
         child.stdout.on("data", (chunk) => {
-            stdout = retain(stdout, chunk);
+            stdout += chunk.toString("utf8");
         });
     if (child.stderr !== null)
         child.stderr.on("data", (chunk) => {
-            stderr = retain(stderr, chunk);
+            stderr += chunk.toString("utf8");
         });
     child.once("error", (error) => {
         clearTimeout(timeout);

package/dist/server/ProcessCaptureElicitation.js

@@ -4,7 +4,6 @@ import { z } from "zod";
 import { PermissionRequiredError } from "../domain/errors.js";
 import { isPermissionRequestWithinCeiling, } from "../domain/permissionPolicy.js";
 const RESPONSE_KEY = "process_capture_grant";
-const STATE_VERSION = 1;
 /** Shared continuation, replay, and round limits for process capture consent. */
 export const PROCESS_CAPTURE_ELICITATION_POLICY = {
     protocolVersions: ["2026-07-28"],
@@ -22,7 +21,6 @@ const grantResponseJsonSchema = { ...z.toJSONSchema(grantResponseSchema) };
 Reflect.deleteProperty(grantResponseJsonSchema, "$schema");
 Reflect.deleteProperty(grantResponseJsonSchema, "additionalProperties");
 const stateSchema = z.strictObject({
-    version: z.literal(STATE_VERSION),
     nonce: z.string().uuid(),
     request: z.strictObject({
         capability: z.literal("process_capture"),
@@ -37,14 +35,13 @@ const stateSchema = z.strictObject({
 });
 /** Authorize capture or return a signed MCP input-required continuation. */
 export const authorizeProcessCaptureWithElicitation = async (authority, request, context, elicitation) => {
-    const supported = elicitation.supported(context);
     const initial = await authority.authorize(request, "read", {
-        elicitationSupported: supported,
+        remediation: elicitation.supported(context) ? "elicit" : "configure",
     });
     if (initial.ok || !(initial.error instanceof PermissionRequiredError))
         return initial;
     const denied = initial.error;
-    if (!supported ||
+    if (denied.remediation !== "elicit" ||
         denied.requested.capability !== "process_capture" ||
         denied.ceiling === null ||
         !isPermissionRequestWithinCeiling(denied.requested, denied.ceiling))
@@ -70,7 +67,6 @@ export const authorizeProcessCaptureWithElicitation = async (authority, request,
             return initial;
     }
     const state = await elicitation.stateCodec.mint({
-        version: STATE_VERSION,
         nonce: randomUUID(),
         request: {
             capability: "process_capture",
@@ -106,12 +102,12 @@ const grantAndAuthorize = async (authority, request, lifetime) => {
     const granted = authority.grant(grant);
     if (!granted.ok)
         return authority.authorize(request, "read", {
-            elicitationSupported: true,
+            remediation: "elicit",
         });
     let authorized;
     try {
         authorized = await authority.authorize(request, "read", {
-            elicitationSupported: true,
+            remediation: "elicit",
         });
     }
     catch (cause) {

package/dist/server/createServer.js

@@ -1,37 +1,77 @@
 import { randomBytes } from "node:crypto";
 import { CLIENT_CAPABILITIES_META_KEY, createRequestStateCodec, McpServer, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
+import { MANAGED_RUNTIME_DISABLED } from "../application/ManagedRuntimeCorrelationService.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
+import { LinuxJavaScriptReplayRunner } from "../replay/LinuxJavaScriptReplayRunner.js";
+import { SystemJavaScriptReplayHost } from "../replay/SystemJavaScriptReplayHost.js";
+import { mcpEnvelopeValue } from "./mcpClientMetadata.js";
+import { PROCESS_CAPTURE_ELICITATION_POLICY, } from "./ProcessCaptureElicitation.js";
+import { registerApplicationTools } from "./registerApplicationTools.js";
+import { registerArtifactTools } from "./registerArtifactTools.js";
+import { registerBrowserScenarioTool } from "./registerBrowserScenarioTool.js";
+import { registerBrowserTools } from "./registerBrowserTools.js";
+import { registerElectronTools } from "./registerElectronTools.js";
+import { registerEnhancedTools } from "./registerEnhancedTools.js";
+import { registerJavaScriptRuntimeObservationTools } from "./registerJavaScriptRuntimeObservationTools.js";
+import { registerManagedTools } from "./registerManagedTools.js";
+import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
+import { registerNativeTools } from "./registerNativeTools.js";
+import { registerOfficialTools } from "./registerOfficialTools.js";
 import { registerGuidedPrompts } from "./registerPrompts.js";
-import { registerEvidenceResources } from "./registerEvidenceResources.js";
+import { registerSessionTools } from "./registerSessionTools.js";
 import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
-import { DENY_EVIDENCE_FILE_POLICY, DENY_PROCESS_POLICY, } from "./sessionToolPolicies.js";
-import { installDynamicToolAvailability } from "./DynamicToolAvailability.js";
-const TARGET_FREE_INSTRUCTIONS = "ASAR/JavaScript -> analyze_javascript_application; archive/package -> open_binary(path), then inspect_artifact/inventory_artifact (active target); managed PE/CLI -> inspect_managed_artifact; passive browser/Electron -> list_browser_targets/list_electron_targets; approved browser interaction -> capture_browser_scenario; Node/Electron Inspector -> list_javascript_runtime_targets; native binary/database -> open_binary, then binary_overview. Start with binary_session; call only tools in tools/list. Hidden routes: binary_session detail=capabilities. Use summaries, cite Evidence IDs. Never repeat identical analysis or read full Evidence.";
-const ACTIVE_TARGET_INSTRUCTIONS = "REA analyzes the active reverse-engineering target. Start native analysis with binary_overview, then narrow with analyze_function, literal search, callers, callees, and xrefs. Prefer summary views, never repeat an identical call, and read full Evidence only when the task requires it.";
-import { PROCESS_CAPTURE_ELICITATION_POLICY, } from "./ProcessCaptureElicitation.js";
-import { LazyToolCatalog } from "./LazyToolCatalog.js";
+import { DENY_PROCESS_POLICY } from "./sessionToolPolicies.js";
+const TARGET_FREE_INSTRUCTIONS = "REA provides reverse-engineering tools for local artifacts, native binaries, managed code, browser pages, and runtimes. Use the tool that directly answers the question; discover targets or inspect inventory only when needed. Tool results include inline Evidence and report their coverage and limitations.";
+const ACTIVE_TARGET_INSTRUCTIONS = "REA analyzes the active reverse-engineering target. Use the analysis tool that answers the question directly. Search or list symbols when discovery is needed; analyze_function provides a function dossier, and focused procedure tools return individual facets.";
 const installSessionToolAvailability = (server, session, options) => {
     if (session === undefined)
         return undefined;
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
-        processPolicy: options.processPolicy ?? DENY_PROCESS_POLICY,
-        evidenceFilePolicy: options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY,
-        investigationInputRoots: options.investigationInputRoots ?? [],
+        processPolicy: options.processPolicy?.() ?? DENY_PROCESS_POLICY,
         optionalFeatures: {
             browserObservationEnabled: options.browserObservation !== undefined,
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
+            electronAutomationEnabled: options.electronActiveObservation !== undefined &&
+                options.permissionAuthority !== undefined,
             v8InspectorObservationEnabled: options.javascriptRuntimeObservation !== undefined,
-            javascriptReplayEnabled: options.javascriptReplayPolicy?.enabled ?? false,
-            managedRuntimeEnabled: options.managedRuntimePolicy?.enabled ?? false,
+            javascriptReplayEnabled: options.javascriptReplayPolicy?.().status === "enabled",
+            managedRuntimeEnabled: options.managedRuntimePolicy?.().status === "enabled",
         },
     });
     return {
         policy,
-        controller: installDynamicToolAvailability(server, session, policy),
     };
 };
+const createProcessCaptureElicitation = (stateCodec) => ({
+    stateCodec,
+    supported: (context) => {
+        const envelope = context.mcpReq.envelope;
+        const version = mcpEnvelopeValue(envelope, PROTOCOL_VERSION_META_KEY);
+        const capabilities = mcpEnvelopeValue(envelope, CLIENT_CAPABILITIES_META_KEY);
+        return (typeof version === "string" &&
+            PROCESS_CAPTURE_ELICITATION_POLICY.protocolVersions.some((supported) => supported === version) &&
+            isRecord(capabilities) &&
+            isRecord(capabilities.elicitation) &&
+            capabilities.elicitation.form !== undefined);
+    },
+    now: Date.now,
+    consumedNonces: new Map(),
+});
+const createMcpServer = (processCaptureStateCodec, session) => new McpServer({
+    name: PRODUCT_IDENTITY.mcpServerKey,
+    version: PRODUCT_IDENTITY.packageVersion,
+}, {
+    capabilities: {},
+    inputRequired: {
+        roundTimeoutMs: PROCESS_CAPTURE_ELICITATION_POLICY.roundTimeoutMs,
+    },
+    requestState: { verify: processCaptureStateCodec.verify },
+    instructions: session === undefined
+        ? ACTIVE_TARGET_INSTRUCTIONS
+        : TARGET_FREE_INSTRUCTIONS,
+});
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -45,100 +85,42 @@ export const createServer = (analysis, session, options = {}) => {
         key: randomBytes(32),
         ttlSeconds: PROCESS_CAPTURE_ELICITATION_POLICY.stateTtlSeconds,
     });
-    const server = new McpServer({
-        name: PRODUCT_IDENTITY.mcpServerKey,
-        version: PRODUCT_IDENTITY.packageVersion,
-    }, {
-        capabilities: {
-            tools: { listChanged: true },
-            resources: { listChanged: true, subscribe: true },
-        },
-        inputRequired: {
-            maxRounds: 3,
-            roundTimeoutMs: PROCESS_CAPTURE_ELICITATION_POLICY.roundTimeoutMs,
-        },
-        requestState: { verify: processCaptureStateCodec.verify },
-        instructions: session === undefined
-            ? ACTIVE_TARGET_INSTRUCTIONS
-            : TARGET_FREE_INSTRUCTIONS,
-    });
-    const dynamicTools = installSessionToolAvailability(server, session, options);
+    const server = createMcpServer(processCaptureStateCodec, session);
+    const availability = installSessionToolAvailability(server, session, options);
     server.server.onclose = () => {
         permissionAuthority?.clearSessionGrants();
     };
-    if (dynamicTools !== undefined)
-        server.server.oninitialized = () => server.sendToolListChanged();
-    session?.onAvailabilityChanged?.(() => server.sendToolListChanged());
-    registerServerIdentityResource(server, startedAt);
     const toolLogger = logger.child({ layer: "server" });
     const { activeTarget, recordEvidence, recordEvidenceWithUnknown } = createSessionRecorders(server, session);
-    const processCaptureElicitation = {
-        stateCodec: processCaptureStateCodec,
-        supported: (context) => {
-            const envelope = context.mcpReq.envelope;
-            const version = envelope?.[PROTOCOL_VERSION_META_KEY];
-            const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY];
-            return (typeof version === "string" &&
-                PROCESS_CAPTURE_ELICITATION_POLICY.protocolVersions.some((supported) => supported === version) &&
-                isRecord(capabilities) &&
-                isRecord(capabilities.elicitation) &&
-                capabilities.elicitation.form !== undefined);
-        },
-        now: Date.now,
-        consumedNonces: new Map(),
+    const processCaptureElicitation = createProcessCaptureElicitation(processCaptureStateCodec);
+    const toolContext = {
+        server,
+        analysis,
+        session,
+        options,
+        logger: toolLogger,
+        permissionAuthority,
+        activeTarget,
+        recordEvidence,
+        recordEvidenceWithUnknown,
     };
-    let optionalProviders;
-    const loadOptionalProviders = () => {
-        optionalProviders ??= options
-            .loadOptionalProviders?.()
-            .catch((cause) => {
-            optionalProviders = undefined;
-            throw cause;
-        });
-        return optionalProviders;
-    };
-    const lazyTools = new LazyToolCatalog(server, async (kind) => {
-        const needsObservationProviders = kind === "browser-provider" ||
-            kind === "electron-provider" ||
-            kind === "runtime-provider";
-        const [{ hydrateServerToolFamily }, loadedOptionalProviders] = await Promise.all([
-            import("./hydrateServerTools.js"),
-            needsObservationProviders ? loadOptionalProviders() : undefined,
-        ]);
-        const hydratedOptions = loadedOptionalProviders === undefined
-            ? options
-            : { ...options, ...loadedOptionalProviders };
-        await hydrateServerToolFamily({
-            kind,
-            server,
-            analysis,
-            session,
-            options: hydratedOptions,
-            context: {
-                logger: toolLogger,
-                permissionAuthority,
-                activeTarget,
-                recordEvidence,
-                recordEvidenceWithUnknown,
-                availabilityPolicy: dynamicTools?.policy,
-                startedAt,
-                processCaptureElicitation,
-            },
-        });
-    }, session !== undefined);
-    lazyTools.register();
+    registerBinaryAnalysisTools(toolContext);
+    registerObservationTools(toolContext);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
-        registerEvidenceResources(server, session);
+        registerSessionTools(server, session, toolLogger, {
+            ...options,
+            ...(availability === undefined
+                ? {}
+                : { availabilityPolicy: availability.policy }),
+            ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
+            startedAt,
+            processCaptureElicitation,
+        });
     }
-    dynamicTools?.controller.synchronize();
-    const close = server.close.bind(server);
-    server.close = async () => {
-        await lazyTools.close();
-        await close();
-    };
     return server;
 };
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const createSessionRecorders = (server, session) => ({
     activeTarget: session === undefined ? undefined : () => session.activeTarget(),
     recordEvidence: session === undefined
@@ -154,28 +136,72 @@ const createSessionRecorders = (server, session) => ({
             return recorded;
         },
 });
-const registerServerIdentityResource = (server, startedAt) => {
-    server.registerResource("server-identity", "rea://server/identity", {
-        title: "REA server identity",
-        description: "Live package, SDK, protocol, and catalog identity.",
-        mimeType: "application/json",
-    }, async (uri) => {
-        const { createServerIdentity } = await import("../serverIdentity.js");
-        const client = server.server.getClientVersion();
-        const protocolVersion = server.server.getNegotiatedProtocolVersion();
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify(createServerIdentity({
-                        startedAt,
-                        ...(client === undefined ? {} : { client }),
-                        ...(protocolVersion === undefined ? {} : { protocolVersion }),
-                    }), null, 2),
-                },
-            ],
-        };
+const registerBinaryAnalysisTools = ({ server, analysis, session, options, logger, permissionAuthority, activeTarget, recordEvidence, recordEvidenceWithUnknown, }) => {
+    const recordUnknown = session === undefined
+        ? undefined
+        : (input) => session.recordUnknown(input);
+    const analysisOptions = {
+        logger,
+        activeTarget,
+        recordEvidence,
+        recordUnknown,
+    };
+    registerOfficialTools(server, analysis, analysisOptions);
+    registerEnhancedTools(server, analysis, {
+        ...analysisOptions,
+        analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
+    });
+    const evidenceOptions = { logger, activeTarget, recordEvidence };
+    registerNativeTools(server, analysis, evidenceOptions);
+    registerArtifactTools(server, analysis, {
+        ...evidenceOptions,
+        ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
+    });
+    registerManagedTools(server, analysis, {
+        ...evidenceOptions,
+        session,
+    });
+    if (session !== undefined)
+        registerManagedWorkflowTools(server, {
+            logger,
+            recordEvidence,
+            recordEvidenceWithUnknown,
+            session,
+            runtime: {
+                policy: options.managedRuntimePolicy ?? (() => MANAGED_RUNTIME_DISABLED),
+                authority: permissionAuthority,
+            },
+        });
+};
+const registerObservationTools = ({ server, options, logger, permissionAuthority, recordEvidence, recordEvidenceWithUnknown, }) => {
+    const common = { logger, permissionAuthority, recordEvidence };
+    registerBrowserTools(server, {
+        ...common,
+        browser: options.browserObservation,
+    });
+    registerBrowserScenarioTool(server, {
+        ...common,
+        provider: options.browserScenarioCapture,
+    });
+    registerElectronTools(server, {
+        ...common,
+        electron: options.electronObservation,
+        electronActive: options.electronActiveObservation,
+    });
+    registerJavaScriptRuntimeObservationTools(server, {
+        ...common,
+        runtime: options.javascriptRuntimeObservation,
+    });
+    registerApplicationTools(server, {
+        logger,
+        recordEvidence,
+        recordEvidenceWithUnknown,
+        permissionAuthority,
+        replay: {
+            policy: options.javascriptReplayPolicy ?? (() => ({ status: "disabled" })),
+            host: options.javascriptReplayHost ?? new SystemJavaScriptReplayHost(),
+            runner: options.javascriptReplayRunner ?? new LinuxJavaScriptReplayRunner(),
+            authority: permissionAuthority,
+        },
     });
 };
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/mcpClientMetadata.js

@@ -0,0 +1,32 @@
+import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
+/** Client metadata bound to the current SDK request rather than server-global state. */
+export const mcpClientMetadata = (context) => {
+    const envelope = context.mcpReq.envelope;
+    const client = implementation(mcpEnvelopeValue(envelope, CLIENT_INFO_META_KEY));
+    const protocolVersion = mcpEnvelopeValue(envelope, PROTOCOL_VERSION_META_KEY);
+    return {
+        ...(client === undefined ? {} : { client }),
+        clientFeatures: capabilityFeatures(mcpEnvelopeValue(envelope, CLIENT_CAPABILITIES_META_KEY)),
+        ...(typeof protocolVersion === "string" ? { protocolVersion } : {}),
+    };
+};
+/** Read an SDK-defined metadata key from the SDK's currently opaque envelope type. */
+export const mcpEnvelopeValue = (envelope, key) => (envelope === undefined ? undefined : Reflect.get(envelope, key));
+const implementation = (value) => isRecord(value) &&
+    typeof value.name === "string" &&
+    typeof value.version === "string"
+    ? { name: value.name, version: value.version }
+    : undefined;
+const capabilityFeatures = (value) => {
+    const capabilities = isRecord(value) ? value : {};
+    const elicitation = isRecord(capabilities.elicitation)
+        ? capabilities.elicitation
+        : {};
+    return {
+        elicitation_form: elicitation.form !== undefined,
+        elicitation_url: elicitation.url !== undefined,
+        roots: capabilities.roots !== undefined,
+        sampling: capabilities.sampling !== undefined,
+    };
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);