rea-agents 1.7.0 → 2.1.0

package/dist/replay/SystemJavaScriptReplayHost.js

@@ -0,0 +1,182 @@
+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 { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import { digestBytes } from "../application/JavaScriptReplayPlanning.js";
+import { buildLinuxX64ReplaySeccomp, linuxX64ReplaySeccompDigest, } from "./LinuxSeccompPolicy.js";
+import { resolveLinuxRuntimeClosure } from "./LinuxRuntimeClosure.js";
+const VERSION_OUTPUT_LIMIT = 16 * 1024;
+/** Production planning host for descriptor-backed reads and fail-closed probes. */
+export class SystemJavaScriptReplayHost {
+    async readSource(path, maximumBytes) {
+        const canonicalPath = await realpath(path);
+        const handle = await open(canonicalPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            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();
+            return { canonicalPath, bytes };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async identifyExecutable(path, versionArguments) {
+        const canonicalPath = await realpath(path);
+        const metadata = await stat(canonicalPath);
+        if (!metadata.isFile())
+            throw new TypeError(`Replay executable is not a file: ${canonicalPath}`);
+        const [bytes, version] = await Promise.all([
+            readFile(canonicalPath),
+            capture(canonicalPath, versionArguments, VERSION_OUTPUT_LIMIT),
+        ]);
+        return {
+            path: canonicalPath,
+            version: version.trim(),
+            sha256: digestBytes(bytes),
+        };
+    }
+    identifyWorker() {
+        return this.identifyExecutable(fileURLToPath(new URL("./JavaScriptReplayWorker.js", import.meta.url)), []);
+    }
+    identifyRuntimeClosure(nodePath) {
+        return resolveLinuxRuntimeClosure(nodePath);
+    }
+    seccompDigest() {
+        return linuxX64ReplaySeccompDigest();
+    }
+    async probe(policy) {
+        if (process.platform !== "linux" || process.arch !== "x64")
+            throw new TypeError("Controlled replay requires Linux x86_64 in v1");
+        const bwrapMetadata = await stat(policy.bubblewrapPath);
+        if ((bwrapMetadata.mode & 0o4000) !== 0)
+            throw new TypeError("Setuid Bubblewrap is not admitted by replay policy");
+        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");
+        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",
+                "--",
+                "/usr/bin/unshare",
+                "--mount",
+                "/usr/bin/true",
+            ], ["ignore", "pipe", "pipe", filter.fd]);
+            await run(policy.systemdRunPath, [
+                "--user",
+                "--pipe",
+                "--wait",
+                "--service-type=exec",
+                "--quiet",
+                "--property=MemoryMax=16777216",
+                "--property=MemorySwapMax=0",
+                "--property=TasksMax=2",
+                "--",
+                "/usr/bin/true",
+            ]);
+        }
+        finally {
+            await filter.close();
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+}
+const capture = async (executable, arguments_, maximumBytes) => {
+    if (arguments_.length === 0)
+        return "content-addressed-worker-v1";
+    const result = await collect(executable, arguments_, maximumBytes);
+    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);
+    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);
+    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 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);
+        });
+    if (child.stderr !== null)
+        child.stderr.on("data", (chunk) => {
+            stderr = retain(stderr, chunk);
+        });
+    child.once("error", (error) => {
+        clearTimeout(timeout);
+        reject(error);
+    });
+    child.once("close", (code) => {
+        clearTimeout(timeout);
+        resolve({ code, stdout, stderr });
+    });
+});

package/dist/server/ProcessCaptureElicitation.js

@@ -0,0 +1,157 @@
+import { randomUUID } from "node:crypto";
+import { acceptedContent, inputRequired, inputResponse, } from "@modelcontextprotocol/server";
+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"],
+    stateTtlSeconds: 600,
+    roundTimeoutMs: 600_000,
+    maxConsumedNonces: 4_096,
+};
+const grantResponseSchema = z.strictObject({
+    lifetime: z.enum(["once", "session"]).meta({ default: "session" }),
+});
+const grantResponseJsonSchema = { ...z.toJSONSchema(grantResponseSchema) };
+// MCP elicitation accepts a reduced JSON Schema subset. These generator
+// annotations do not change the schema's fields or validation semantics; the
+// Standard Schema marker would make the SDK regenerate the removed keywords.
+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"),
+        roots: z.array(z.string()),
+        executables: z.array(z.string()),
+        environment_names: z.array(z.string()),
+        origins: z.array(z.string()).optional(),
+        network: z.enum(["none", "loopback", "external"]),
+        mount: z.boolean(),
+        operation_identity: z.string(),
+    }),
+});
+/** 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,
+    });
+    if (initial.ok || !(initial.error instanceof PermissionRequiredError))
+        return initial;
+    const denied = initial.error;
+    if (!supported ||
+        denied.requested.capability !== "process_capture" ||
+        denied.ceiling === null ||
+        !isPermissionRequestWithinCeiling(denied.requested, denied.ceiling))
+        return initial;
+    const encodedState = context.mcpReq.requestState();
+    if (encodedState !== undefined) {
+        const state = stateSchema.safeParse(encodedState);
+        if (!state.success || !sameRequest(state.data.request, denied.requested))
+            return initial;
+        const response = inputResponse(context.mcpReq.inputResponses, RESPONSE_KEY);
+        if (response.kind === "elicit") {
+            if (!consumeNonce(elicitation.consumedNonces, state.data.nonce, elicitation.now()))
+                return initial;
+        }
+        if (response.kind === "elicit" && response.action === "accept") {
+            const content = acceptedContent(context.mcpReq.inputResponses, RESPONSE_KEY, grantResponseSchema);
+            if (content === undefined)
+                return initial;
+            return grantAndAuthorize(authority, state.data.request, content.lifetime);
+        }
+        if (response.kind === "elicit" &&
+            (response.action === "decline" || response.action === "cancel"))
+            return initial;
+    }
+    const state = await elicitation.stateCodec.mint({
+        version: STATE_VERSION,
+        nonce: randomUUID(),
+        request: {
+            capability: "process_capture",
+            roots: [...denied.requested.roots],
+            executables: [...denied.requested.executables],
+            environment_names: [...denied.requested.environment_names],
+            network: denied.requested.network,
+            mount: denied.requested.mount,
+            operation_identity: denied.requested.operation_identity,
+            ...(denied.requested.origins === undefined
+                ? {}
+                : { origins: [...denied.requested.origins] }),
+        },
+    });
+    return inputRequired({
+        inputRequests: {
+            [RESPONSE_KEY]: inputRequired.elicit({
+                message: permissionMessage(denied.requested),
+                requestedSchema: grantResponseJsonSchema,
+            }),
+        },
+        requestState: state,
+    });
+};
+const grantAndAuthorize = async (authority, request, lifetime) => {
+    const grant = {
+        ...request,
+        grant_id: `elicited:${randomUUID()}`,
+        lifetime,
+        operation_identity: lifetime === "once" ? request.operation_identity : null,
+        expires_at: null,
+    };
+    const granted = authority.grant(grant);
+    if (!granted.ok)
+        return authority.authorize(request, "read", {
+            elicitationSupported: true,
+        });
+    let authorized;
+    try {
+        authorized = await authority.authorize(request, "read", {
+            elicitationSupported: true,
+        });
+    }
+    catch (cause) {
+        authority.revoke(grant.grant_id);
+        throw cause;
+    }
+    if (!authorized.ok)
+        authority.revoke(grant.grant_id);
+    return authorized;
+};
+const sameRequest = (left, right) => left.capability === right.capability &&
+    left.network === right.network &&
+    left.mount === right.mount &&
+    left.operation_identity === right.operation_identity &&
+    sameOptionalStrings(left.origins, right.origins) &&
+    sameStrings(left.roots, right.roots) &&
+    sameStrings(left.executables, right.executables) &&
+    sameStrings(left.environment_names, right.environment_names);
+const sameStrings = (left, right) => left.length === right.length &&
+    left.every((value, index) => value === right[index]);
+const sameOptionalStrings = (left, right) => left === undefined
+    ? right === undefined
+    : right !== undefined && sameStrings(left, right);
+const consumeNonce = (consumed, nonce, now) => {
+    for (const [candidate, expiresAt] of consumed)
+        if (expiresAt <= now)
+            consumed.delete(candidate);
+    if (consumed.has(nonce) ||
+        consumed.size >= PROCESS_CAPTURE_ELICITATION_POLICY.maxConsumedNonces)
+        return false;
+    consumed.set(nonce, now + PROCESS_CAPTURE_ELICITATION_POLICY.stateTtlSeconds * 1_000);
+    return true;
+};
+const permissionMessage = (request) => [
+    "Allow REA to run this exact process-capture scope?",
+    `Executable: ${request.executables.join(", ") || "none"}`,
+    `Filesystem roots: ${request.roots.join(", ") || "none"}`,
+    `Environment names: ${request.environment_names.join(", ") || "none"}`,
+    `Origins: ${request.origins?.join(", ") || "none"}`,
+    `Network: ${request.network}`,
+    `Mount access: ${request.mount ? "yes" : "no"}`,
+    "Choose whether the grant applies once or for this MCP session.",
+].join("\n");

package/dist/server/createServer.js

@@ -1,16 +1,23 @@
-import { McpServer } from "@modelcontextprotocol/server";
+import { randomBytes } from "node:crypto";
+import { CLIENT_CAPABILITIES_META_KEY, createRequestStateCodec, McpServer, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { registerEnhancedTools } from "./registerEnhancedTools.js";
 import { registerOfficialTools } from "./registerOfficialTools.js";
 import { registerSessionTools } from "./registerSessionTools.js";
 import { registerNativeTools } from "./registerNativeTools.js";
 import { registerArtifactTools } from "./registerArtifactTools.js";
+import { registerManagedTools } from "./registerManagedTools.js";
+import { registerManagedWorkflowTools } from "./registerManagedWorkflowTools.js";
 import { silentLogger } from "../logger.js";
 import { registerGuidedPrompts } from "./registerPrompts.js";
 import { registerEvidenceResources } from "./registerEvidenceResources.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { registerBrowserTools } from "./registerBrowserTools.js";
 import { registerElectronTools } from "./registerElectronTools.js";
+import { registerApplicationTools } from "./registerApplicationTools.js";
+import { LinuxJavaScriptReplayRunner } from "../replay/LinuxJavaScriptReplayRunner.js";
+import { SystemJavaScriptReplayHost } from "../replay/SystemJavaScriptReplayHost.js";
+import { PROCESS_CAPTURE_ELICITATION_POLICY, } from "./ProcessCaptureElicitation.js";
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
@@ -19,6 +26,11 @@ import { registerElectronTools } from "./registerElectronTools.js";
 export const createServer = (analysis, session, options = {}) => {
     const startedAt = new Date().toISOString();
     const logger = options.logger ?? silentLogger;
+    const permissionAuthority = options.permissionAuthority?.createConnectionAuthority();
+    const processCaptureStateCodec = createRequestStateCodec({
+        key: randomBytes(32),
+        ttlSeconds: PROCESS_CAPTURE_ELICITATION_POLICY.stateTtlSeconds,
+    });
     const server = new McpServer({
         name: PRODUCT_IDENTITY.mcpServerKey,
         version: PRODUCT_IDENTITY.packageVersion,
@@ -27,17 +39,88 @@ export const createServer = (analysis, session, options = {}) => {
             tools: { listChanged: true },
             resources: { listChanged: true },
         },
+        inputRequired: {
+            maxRounds: 3,
+            roundTimeoutMs: PROCESS_CAPTURE_ELICITATION_POLICY.roundTimeoutMs,
+        },
+        requestState: { verify: processCaptureStateCodec.verify },
         instructions: session === undefined
             ? "Reverse-engineering tools for an active analysis target. Start with binary_overview."
             : "Reverse-engineering tools for configured analysis providers. Open a target with open_binary, then start with binary_overview.",
     });
+    server.server.onclose = () => {
+        permissionAuthority?.clearSessionGrants();
+    };
     session?.onAvailabilityChanged?.(() => server.sendToolListChanged());
+    registerServerIdentityResource(server, startedAt);
+    const toolLogger = logger.child({ layer: "server" });
+    const { activeTarget, recordEvidence, recordEvidenceWithUnknown } = createSessionRecorders(server, session);
+    const toolContext = {
+        server,
+        analysis,
+        session,
+        options,
+        logger: toolLogger,
+        permissionAuthority,
+        activeTarget,
+        recordEvidence,
+        recordEvidenceWithUnknown,
+    };
+    registerBinaryAnalysisTools(toolContext);
+    registerObservationTools(toolContext);
+    registerGuidedPrompts(server, analysis, session);
+    if (session !== undefined) {
+        registerEvidenceResources(server, session);
+        registerSessionTools(server, session, toolLogger, {
+            ...options,
+            ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
+            startedAt,
+            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(),
+            },
+        });
+    }
+    return server;
+};
+const createSessionRecorders = (server, session) => ({
+    activeTarget: session === undefined ? undefined : () => session.activeTarget(),
+    recordEvidence: session === undefined
+        ? undefined
+        : (evidence) => {
+            const recorded = session.recordEvidence(evidence);
+            if (recorded.ok && recorded.value === "added")
+                server.sendResourceListChanged();
+            return recorded;
+        },
+    recordEvidenceWithUnknown: session === undefined
+        ? undefined
+        : (evidence, input) => {
+            const recorded = session.recordEvidenceWithUnknown(evidence, input);
+            if (recorded.ok)
+                server.sendResourceListChanged();
+            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",
     }, (uri) => {
         const client = server.server.getClientVersion();
+        const protocolVersion = server.server.getNegotiatedProtocolVersion();
         return {
             contents: [
                 {
@@ -46,75 +129,109 @@ export const createServer = (analysis, session, options = {}) => {
                     text: JSON.stringify(createServerIdentity({
                         startedAt,
                         ...(client === undefined ? {} : { client }),
-                        ...(server.server.getNegotiatedProtocolVersion() === undefined
-                            ? {}
-                            : {
-                                protocolVersion: server.server.getNegotiatedProtocolVersion(),
-                            }),
+                        ...(protocolVersion === undefined ? {} : { protocolVersion }),
                     }), null, 2),
                 },
             ],
         };
     });
-    const toolLogger = logger.child({ layer: "server" });
-    const activeTarget = session === undefined ? undefined : () => session.activeTarget();
-    const recordEvidence = session === undefined
+};
+const registerBinaryAnalysisTools = ({ server, analysis, session, options, logger, permissionAuthority, activeTarget, recordEvidence, recordEvidenceWithUnknown, }) => {
+    const recordUnknown = session === undefined
         ? undefined
-        : (evidence) => {
-            const recorded = session.recordEvidence(evidence);
-            if (recorded.ok && recorded.value === "added")
-                server.sendResourceListChanged();
-            return recorded;
-        };
+        : (input) => session.recordUnknown(input);
     registerOfficialTools(server, analysis, {
-        logger: toolLogger,
+        logger,
         activeTarget,
         recordEvidence,
-        recordUnknown: session === undefined
-            ? undefined
-            : (input) => session.recordUnknown(input),
+        recordUnknown,
     });
     registerEnhancedTools(server, analysis, {
-        logger: toolLogger,
+        logger,
         activeTarget,
         analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
         recordEvidence,
-        recordUnknown: session === undefined
-            ? undefined
-            : (input) => session.recordUnknown(input),
+        recordUnknown,
     });
     registerNativeTools(server, analysis, {
-        logger: toolLogger,
+        logger,
         activeTarget,
         recordEvidence,
     });
     registerArtifactTools(server, analysis, {
-        logger: toolLogger,
+        logger,
+        activeTarget,
+        recordEvidence,
+        ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
+    });
+    registerManagedTools(server, analysis, {
+        logger,
         activeTarget,
         recordEvidence,
-        ...(options.permissionAuthority === undefined
-            ? {}
-            : { permissionAuthority: options.permissionAuthority }),
     });
+    if (session !== undefined)
+        registerManagedWorkflowTools(server, {
+            logger,
+            recordEvidence,
+            recordEvidenceWithUnknown,
+            session,
+            runtime: {
+                policy: options.managedRuntimePolicy ?? {
+                    enabled: false,
+                    roots: [],
+                    executablePath: "/usr/bin/dotnet",
+                },
+                authority: permissionAuthority,
+            },
+        });
+};
+const registerObservationTools = ({ server, session, options, logger, permissionAuthority, recordEvidence, recordEvidenceWithUnknown, }) => {
     registerBrowserTools(server, {
-        logger: toolLogger,
+        logger,
         browser: options.browserObservation,
-        permissionAuthority: options.permissionAuthority,
+        permissionAuthority,
         recordEvidence,
     });
     registerElectronTools(server, {
-        logger: toolLogger,
+        logger,
         electron: options.electronObservation,
-        permissionAuthority: options.permissionAuthority,
+        permissionAuthority,
         recordEvidence,
     });
-    registerGuidedPrompts(server, analysis, session);
-    if (session !== undefined) {
-        registerEvidenceResources(server, session);
-        registerSessionTools(server, session, toolLogger, {
-            ...options,
-            startedAt,
-        });
-    }
-    return server;
+    registerApplicationTools(server, {
+        logger,
+        recordEvidence,
+        recordEvidenceWithUnknown,
+        evidenceFilePolicy: options.evidenceFilePolicy ?? {
+            roots: [],
+            maxBytes: 1,
+            maxDepth: 1,
+            maxStringLength: 1,
+            maxNodes: 1,
+        },
+        permissionAuthority,
+        retainCoverageWorkspace: session === undefined
+            ? undefined
+            : (workspace) => {
+                const retained = session.retainReconstructionCoverageWorkspace(workspace);
+                if (retained === "added")
+                    server.sendResourceListChanged();
+                return retained;
+            },
+        replay: {
+            policy: options.javascriptReplayPolicy ?? {
+                enabled: false,
+                roots: [],
+                nodePath: process.execPath,
+                bubblewrapPath: "/usr/bin/bwrap",
+                systemdRunPath: "/usr/bin/systemd-run",
+                systemctlPath: "/usr/bin/systemctl",
+                shellPath: "/usr/bin/bash",
+            },
+            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/registerApplicationTools/characterization.js

@@ -0,0 +1,57 @@
+import { executeNodeCharacterization, prepareNodeCharacterization, } from "../../application/NodeRuntimeCharacterizationService.js";
+import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
+import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
+import { parseEvidence } from "../../domain/evidence.js";
+import { logToolExecution } from "../toolLogging.js";
+import { toCallToolResult } from "../toolResult.js";
+import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { safeParseToolInput } from "../toolInputValidation.js";
+import { mcpProgressReporter } from "../mcpProgress.js";
+import { recordSources } from "./helpers.js";
+const prepareContract = APPLICATION_TOOL_CONTRACTS[3];
+const executeContract = APPLICATION_TOOL_CONTRACTS[4];
+/** Register node runtime characterization prepare and execute tools. */
+export const registerCharacterizationTools = (server, options) => {
+    server.registerTool(prepareContract.name, toolRegistrationOptions(prepareContract), async (input, context) => {
+        const parsed = safeParseToolInput(nodeCharacterizationPreparationInputSchema, input, prepareContract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, prepareContract);
+        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, parsed.value, {
+            signal: context.mcpReq.signal,
+            progress: mcpProgressReporter(context),
+        }));
+        if (!result.ok)
+            return toCallToolResult(result, prepareContract);
+        const output = nodeCharacterizationPreparationOutputSchema.parse(result.value);
+        const recorded = options.recordEvidence?.(parseEvidence(output.transformation_evidence));
+        if (recorded !== undefined && !recorded.ok)
+            return toCallToolResult(recorded, prepareContract);
+        return toCallToolResult(result, prepareContract, {
+            evidenceResourcesAvailable: options.recordEvidence !== undefined,
+        });
+    });
+    server.registerTool(executeContract.name, toolRegistrationOptions(executeContract), async (input, context) => {
+        const parsed = safeParseToolInput(nodeCharacterizationExecutionInputSchema, input, executeContract.name);
+        if (!parsed.ok)
+            return toCallToolResult(parsed, executeContract);
+        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, parsed.value, {
+            signal: context.mcpReq.signal,
+            progress: mcpProgressReporter(context),
+        }));
+        if (!result.ok)
+            return toCallToolResult(result, executeContract);
+        const output = nodeCharacterizationExecutionOutputSchema.parse(result.value);
+        const sources = [
+            output.transformation_evidence,
+            ...output.replay.source_evidence,
+            ...(output.replay.evidence === null ? [] : [output.replay.evidence]),
+            output.evidence,
+        ].map((item) => parseEvidence(item));
+        const recorded = recordSources(options.recordEvidence, sources);
+        if (!recorded.ok)
+            return toCallToolResult(recorded, executeContract);
+        return toCallToolResult(result, executeContract, {
+            evidenceResourcesAvailable: options.recordEvidence !== undefined,
+        });
+    });
+};