rea-agents 2.5.0 → 3.1.0

package/dist/server/createServer.js

@@ -1,51 +1,83 @@
 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 { 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 { LinuxJavaScriptReplayRunner } from "../replay/LinuxJavaScriptReplayRunner.js";
+import { SystemJavaScriptReplayHost } from "../replay/SystemJavaScriptReplayHost.js";
+import { mcpClientMetadata, 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 { registerEvidenceResources } from "./registerEvidenceResources.js";
 import { registerJavaScriptRuntimeObservationTools } from "./registerJavaScriptRuntimeObservationTools.js";
-import { registerApplicationTools } from "./registerApplicationTools.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 { 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 = "REA analyzes shipped artifacts. Route: ASAR/JavaScript -> analyze_javascript_application (configured root); archive/package -> inspect_artifact; 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. Check binary_session policy. Start with summaries and cite Evidence IDs. Never repeat identical analysis or read full Evidence without need.";
+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; browser/Electron -> list_browser_targets/list_electron_targets; approved -> capture_browser_scenario/capture_electron_scenario; Node/Electron Inspector -> list_javascript_runtime_targets; native binary/database -> open_binary, then binary_overview. Start with binary_session; use tools/list; capabilities via binary_session. 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 { LinuxJavaScriptReplayRunner } from "../replay/LinuxJavaScriptReplayRunner.js";
-import { SystemJavaScriptReplayHost } from "../replay/SystemJavaScriptReplayHost.js";
-import { PROCESS_CAPTURE_ELICITATION_POLICY, } from "./ProcessCaptureElicitation.js";
 const installSessionToolAvailability = (server, session, options) => {
     if (session === undefined)
         return undefined;
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
-        processPolicy: options.processPolicy ?? DENY_PROCESS_POLICY,
+        processPolicy: options.processPolicy?.() ?? DENY_PROCESS_POLICY,
         evidenceFilePolicy: options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY,
         investigationInputRoots: options.investigationInputRoots ?? [],
         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: {
+        resources: { subscribe: true },
+    },
+    inputRequired: {
+        maxRounds: 3,
+        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
@@ -59,33 +91,15 @@ 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 },
-        },
-        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 = createProcessCaptureElicitation(processCaptureStateCodec);
     const toolContext = {
         server,
         analysis,
@@ -104,105 +118,55 @@ export const createServer = (analysis, session, options = {}) => {
         registerEvidenceResources(server, session);
         registerSessionTools(server, session, toolLogger, {
             ...options,
-            ...(dynamicTools === undefined
+            ...(availability === undefined
                 ? {}
-                : { availabilityPolicy: dynamicTools.policy }),
+                : { availabilityPolicy: availability.policy }),
             ...(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(),
-            },
+            processCaptureElicitation,
         });
     }
-    dynamicTools?.controller.synchronize();
     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
         ? 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: [
-                {
-                    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);
-    registerOfficialTools(server, analysis, {
+    const analysisOptions = {
         logger,
         activeTarget,
         recordEvidence,
         recordUnknown,
-    });
+    };
+    registerOfficialTools(server, analysis, analysisOptions);
     registerEnhancedTools(server, analysis, {
-        logger,
-        activeTarget,
+        ...analysisOptions,
         analysisProfile: session === undefined ? undefined : () => session.analysisProfile(),
-        recordEvidence,
-        recordUnknown,
-    });
-    registerNativeTools(server, analysis, {
-        logger,
-        activeTarget,
-        recordEvidence,
     });
+    const evidenceOptions = { logger, activeTarget, recordEvidence };
+    registerNativeTools(server, analysis, evidenceOptions);
     registerArtifactTools(server, analysis, {
-        logger,
-        activeTarget,
-        recordEvidence,
+        ...evidenceOptions,
         ...(permissionAuthority === undefined ? {} : { permissionAuthority }),
     });
     registerManagedTools(server, analysis, {
-        logger,
-        activeTarget,
-        recordEvidence,
+        ...evidenceOptions,
         session,
     });
     if (session !== undefined)
@@ -212,39 +176,29 @@ const registerBinaryAnalysisTools = ({ server, analysis, session, options, logge
             recordEvidenceWithUnknown,
             session,
             runtime: {
-                policy: options.managedRuntimePolicy ?? {
-                    enabled: false,
-                    roots: [],
-                    executablePath: "/usr/bin/dotnet",
-                },
+                policy: options.managedRuntimePolicy ?? (() => MANAGED_RUNTIME_DISABLED),
                 authority: permissionAuthority,
             },
         });
 };
 const registerObservationTools = ({ server, session, options, logger, permissionAuthority, recordEvidence, recordEvidenceWithUnknown, }) => {
+    const common = { logger, permissionAuthority, recordEvidence };
     registerBrowserTools(server, {
-        logger,
+        ...common,
         browser: options.browserObservation,
-        permissionAuthority,
-        recordEvidence,
     });
     registerBrowserScenarioTool(server, {
-        logger,
+        ...common,
         provider: options.browserScenarioCapture,
-        permissionAuthority,
-        recordEvidence,
     });
     registerElectronTools(server, {
-        logger,
+        ...common,
         electron: options.electronObservation,
-        permissionAuthority,
-        recordEvidence,
+        electronActive: options.electronActiveObservation,
     });
     registerJavaScriptRuntimeObservationTools(server, {
-        logger,
+        ...common,
         runtime: options.javascriptRuntimeObservation,
-        permissionAuthority,
-        recordEvidence,
     });
     registerApplicationTools(server, {
         logger,
@@ -253,36 +207,39 @@ const registerObservationTools = ({ server, session, options, logger, permission
         evidenceLookup: session === undefined
             ? undefined
             : (evidenceId) => session.evidenceById(evidenceId),
-        evidenceFilePolicy: options.evidenceFilePolicy ?? {
-            roots: [],
-            maxBytes: 1,
-            maxDepth: 1,
-            maxStringLength: 1,
-            maxNodes: 1,
-        },
+        evidenceFilePolicy: options.evidenceFilePolicy ?? DENY_EVIDENCE_FILE_POLICY,
         permissionAuthority,
         retainCoverageWorkspace: session === undefined
             ? undefined
-            : (workspace) => {
-                const retained = session.retainReconstructionCoverageWorkspace(workspace);
-                if (retained === "added")
-                    server.sendResourceListChanged();
-                return retained;
-            },
+            : (workspace) => session.retainReconstructionCoverageWorkspace(workspace),
         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",
-            },
+            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);
+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, context) => {
+        const { createServerIdentity } = await import("../serverIdentity.js");
+        const { client, protocolVersion } = mcpClientMetadata(context);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(createServerIdentity({
+                        startedAt,
+                        ...(client === undefined ? {} : { client }),
+                        ...(protocolVersion === undefined ? {} : { protocolVersion }),
+                    }), null, 2),
+                },
+            ],
+        };
+    });
+};

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);

package/dist/server/registerApplicationTools/characterization.js

@@ -1,22 +1,18 @@
 import { executeNodeCharacterization, prepareNodeCharacterization, } from "../../application/NodeRuntimeCharacterizationService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { nodeCharacterizationExecutionInputSchema, nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationInputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
 import { parseEvidence } from "../../domain/evidence.js";
+import { nodeCharacterizationExecutionOutputSchema, nodeCharacterizationPreparationOutputSchema, } from "../../domain/nodeRuntimeCharacterization.js";
+import { mcpProgressReporter } from "../mcpProgress.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 { toCallToolResult } from "../toolResult.js";
 import { recordSources } from "./helpers.js";
 const prepareContract = applicationToolContract("prepare_node_characterization");
 const executeContract = applicationToolContract("execute_node_characterization");
 /** 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, {
+        const result = await logToolExecution(options.logger, prepareContract.name, () => prepareNodeCharacterization(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
@@ -31,10 +27,7 @@ export const registerCharacterizationTools = (server, options) => {
         });
     });
     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, {
+        const result = await logToolExecution(options.logger, executeContract.name, () => executeNodeCharacterization(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
@@ -44,7 +37,7 @@ export const registerCharacterizationTools = (server, options) => {
         const sources = [
             output.transformation_evidence,
             ...output.replay.source_evidence,
-            ...(output.replay.evidence === null ? [] : [output.replay.evidence]),
+            output.replay.evidence,
             output.evidence,
         ].map((item) => parseEvidence(item));
         const recorded = recordSources(options.recordEvidence, sources);

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -1,21 +1,16 @@
 import { resolveCompareJavaScriptExportShapesRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
 import { compareJavaScriptExportShapesEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareJavaScriptExportShapesRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascriptExportShapeComparisonSchemas.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
 const contract = applicationToolContract("compare_javascript_export_shapes");
 /** Register the execution-free exact JavaScript export-shape comparison. */
 export const registerCompareJavaScriptExportShapesTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsedInput = safeParseToolInput(compareJavaScriptExportShapesRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveCompareJavaScriptExportShapesRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveCompareJavaScriptExportShapesRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const parsed = resolved.value;

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -1,10 +1,8 @@
-import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { resolveCompareSourceToBundleRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { compareSourceToBundleEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareSourceToBundleRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { sourceToBundleComparisonResultSchema } from "../../domain/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
 import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
@@ -12,10 +10,7 @@ const contract = applicationToolContract("compare_source_to_bundle");
 /** Register conservative historical-source to bundle comparison. */
 export const registerCompareSourceToBundleTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsedInput = safeParseToolInput(compareSourceToBundleRequestSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const resolved = resolveCompareSourceToBundleRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveCompareSourceToBundleRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(compareSourceToBundleEvidenceValidated(resolved.value)));

package/dist/server/registerApplicationTools/compareVersions.js

@@ -1,21 +1,16 @@
-import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { resolveCompareApplicationVersionsRequestValidated } from "../../application/ApplicationWorkflowEvidenceResolver.js";
+import { compareApplicationVersionsEvidenceValidated } from "../../application/JavaScriptApplicationWorkflowService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { compareApplicationVersionsRequestSchema } from "../../contracts/applicationWorkflowInputContracts.js";
 import { applicationVersionComparisonResultSchema } from "../../domain/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { recordResult, recordSources } from "./helpers.js";
 const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
 export const registerCompareApplicationVersionsTool = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const parsedInput = safeParseToolInput(compareApplicationVersionsRequestSchema, input, compareContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, compareContract);
-        const resolved = resolveCompareApplicationVersionsRequestValidated(parsedInput.value, options.evidenceLookup);
+        const resolved = resolveCompareApplicationVersionsRequestValidated(input, options.evidenceLookup);
         if (!resolved.ok)
             return toCallToolResult(resolved, compareContract);
         const parsed = resolved.value;

package/dist/server/registerApplicationTools/controlledReplay.js

@@ -1,29 +1,24 @@
 import { runControlledReplayValidated } from "../../application/JavaScriptReplayService.js";
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "../../domain/javascriptReplay.js";
 import { parseEvidence } from "../../domain/evidence.js";
+import { controlledReplayOutputSchema } from "../../domain/javascriptReplay.js";
+import { mcpProgressReporter } from "../mcpProgress.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 { toCallToolResult } from "../toolResult.js";
 import { recordSources } from "./helpers.js";
 const replayContract = applicationToolContract("run_controlled_replay");
 /** Register the controlled JavaScript replay tool. */
 export const registerControlledReplayTool = (server, options) => {
     server.registerTool(replayContract.name, toolRegistrationOptions(replayContract), async (input, context) => {
-        const parsedInput = safeParseToolInput(controlledReplayInputSchema, input, replayContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, replayContract);
-        const parsed = parsedInput.value;
-        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, parsed, {
+        const result = await logToolExecution(options.logger, replayContract.name, () => runControlledReplayValidated(options.replay, input, {
             signal: context.mcpReq.signal,
             progress: mcpProgressReporter(context),
         }));
         if (!result.ok)
             return toCallToolResult(result, replayContract);
         const output = controlledReplayOutputSchema.parse(result.value);
-        if (output.evidence !== null) {
+        if (output.phase === "execute") {
             const sourcesRecorded = recordSources(options.recordEvidence, output.source_evidence.map((item) => parseEvidence(item)));
             if (!sourcesRecorded.ok)
                 return toCallToolResult(sourcesRecorded, replayContract);
@@ -32,7 +27,7 @@ export const registerControlledReplayTool = (server, options) => {
                 return toCallToolResult(recorded, replayContract);
         }
         return toCallToolResult(result, replayContract, {
-            evidenceResourcesAvailable: output.evidence !== null && options.recordEvidence !== undefined,
+            evidenceResourcesAvailable: output.phase === "execute" && options.recordEvidence !== undefined,
         });
     });
 };