rea-agents 6.1.0 → 6.3.0

package/dist/server/registerEnhancedTools.js

@@ -1,14 +1,14 @@
-import { EnhancedTools, } from "../application/EnhancedTools.js";
+import { EnhancedTools } from "../application/EnhancedTools.js";
 import { createWorkflowEvidence, workflowSnapshotRecord, recordWorkflowUnknowns, } from "../application/WorkflowEvidence.js";
 import { toolContract } from "../contracts/toolContracts.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 import { executeFunctionAnalysisEvidence } from "../application/FunctionAnalysisEvidence.js";
 /** Register composed workflows against the same port as direct bridge tools. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
-export const registerEnhancedTools = (server, analysis, options) => {
+export const registerEnhancedTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const nativeDispatchMetadata = toolContract("inspect_native_dispatch_metadata");
     const objcClasses = toolContract("get_objc_classes");
     const objcProtocols = toolContract("get_objc_protocols");
@@ -23,125 +23,130 @@ export const registerEnhancedTools = (server, analysis, options) => {
     const traceCallPath = toolContract("trace_call_path");
     const traceNativeUiAction = toolContract("trace_native_ui_action");
     const traceNativeValues = toolContract("trace_native_values");
-    server.registerTool(traceNativeValues.name, toolRegistrationOptions(traceNativeValues), (input, context) => executeEnhancedTool(analysis, options, traceNativeValues, {
+    server.registerTool(traceNativeValues.name, toolRegistrationOptions(traceNativeValues), (input, context) => executeEnhancedTool(registration, traceNativeValues, {
         validatedCall: { name: "trace_native_values", input },
         context,
     }));
-    server.registerTool(nativeDispatchMetadata.name, toolRegistrationOptions(nativeDispatchMetadata), (input, context) => executeEnhancedTool(analysis, options, nativeDispatchMetadata, {
+    server.registerTool(nativeDispatchMetadata.name, toolRegistrationOptions(nativeDispatchMetadata), (input, context) => executeEnhancedTool(registration, nativeDispatchMetadata, {
         validatedCall: { name: "inspect_native_dispatch_metadata", input },
         context,
     }));
-    server.registerTool(objcClasses.name, toolRegistrationOptions(objcClasses), (input, context) => executeEnhancedTool(analysis, options, objcClasses, {
+    server.registerTool(objcClasses.name, toolRegistrationOptions(objcClasses), (input, context) => executeEnhancedTool(registration, objcClasses, {
         validatedCall: { name: "get_objc_classes", input },
         context,
     }));
-    server.registerTool(objcProtocols.name, toolRegistrationOptions(objcProtocols), (input, context) => executeEnhancedTool(analysis, options, objcProtocols, {
+    server.registerTool(objcProtocols.name, toolRegistrationOptions(objcProtocols), (input, context) => executeEnhancedTool(registration, objcProtocols, {
         validatedCall: { name: "get_objc_protocols", input },
         context,
     }));
-    server.registerTool(batchDecompile.name, toolRegistrationOptions(batchDecompile), (input, context) => executeEnhancedTool(analysis, options, batchDecompile, {
+    server.registerTool(batchDecompile.name, toolRegistrationOptions(batchDecompile), (input, context) => executeEnhancedTool(registration, batchDecompile, {
         validatedCall: { name: "batch_decompile", input },
         context,
     }));
-    server.registerTool(callGraph.name, toolRegistrationOptions(callGraph), (input, context) => executeEnhancedTool(analysis, options, callGraph, {
+    server.registerTool(callGraph.name, toolRegistrationOptions(callGraph), (input, context) => executeEnhancedTool(registration, callGraph, {
         validatedCall: { name: "get_call_graph", input },
         context,
     }));
-    server.registerTool(swiftTypes.name, toolRegistrationOptions(swiftTypes), (input, context) => executeEnhancedTool(analysis, options, swiftTypes, {
+    server.registerTool(swiftTypes.name, toolRegistrationOptions(swiftTypes), (input, context) => executeEnhancedTool(registration, swiftTypes, {
         validatedCall: { name: "analyze_swift_types", input },
         context,
     }));
-    server.registerTool(xrefsToName.name, toolRegistrationOptions(xrefsToName), (input, context) => executeEnhancedTool(analysis, options, xrefsToName, {
+    server.registerTool(xrefsToName.name, toolRegistrationOptions(xrefsToName), (input, context) => executeEnhancedTool(registration, xrefsToName, {
         validatedCall: { name: "find_xrefs_to_name", input },
         context,
     }));
-    server.registerTool(binaryOverview.name, toolRegistrationOptions(binaryOverview), (input, context) => executeEnhancedTool(analysis, options, binaryOverview, {
+    server.registerTool(binaryOverview.name, toolRegistrationOptions(binaryOverview), (input, context) => executeEnhancedTool(registration, binaryOverview, {
         validatedCall: { name: "binary_overview", input },
         context,
     }));
-    server.registerTool(analyzeFunction.name, toolRegistrationOptions(analyzeFunction), (input, context) => executeEnhancedTool(analysis, options, analyzeFunction, {
+    server.registerTool(analyzeFunction.name, toolRegistrationOptions(analyzeFunction), (input, context) => executeEnhancedTool(registration, analyzeFunction, {
         validatedCall: { name: "analyze_function", input },
         context,
     }));
-    server.registerTool(inspectNativeApi.name, toolRegistrationOptions(inspectNativeApi), (input, context) => executeEnhancedTool(analysis, options, inspectNativeApi, {
+    server.registerTool(inspectNativeApi.name, toolRegistrationOptions(inspectNativeApi), (input, context) => executeEnhancedTool(registration, inspectNativeApi, {
         validatedCall: { name: "inspect_native_api", input },
         context,
     }));
-    server.registerTool(traceFeature.name, toolRegistrationOptions(traceFeature), (input, context) => executeEnhancedTool(analysis, options, traceFeature, {
+    server.registerTool(traceFeature.name, toolRegistrationOptions(traceFeature), (input, context) => executeEnhancedTool(registration, traceFeature, {
         validatedCall: { name: "trace_feature", input },
         context,
     }));
-    server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(analysis, options, traceCallPath, {
+    server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(registration, traceCallPath, {
         validatedCall: { name: "trace_call_path", input },
         context,
     }));
-    server.registerTool(traceNativeUiAction.name, toolRegistrationOptions(traceNativeUiAction), (input, context) => executeEnhancedTool(analysis, options, traceNativeUiAction, {
+    server.registerTool(traceNativeUiAction.name, toolRegistrationOptions(traceNativeUiAction), (input, context) => executeEnhancedTool(registration, traceNativeUiAction, {
         validatedCall: { name: "trace_native_ui_action", input },
         context,
     }));
 };
-const executeEnhancedTool = async (analysis, registration, contract, request) => {
-    const { validatedCall, context } = request;
-    const name = validatedCall.name;
-    const progress = mcpProgressReporter(context);
-    await progress.report({
-        phase: name,
-        completed: 0,
-        total: 1,
-        message: "started",
-    });
-    const parsedInput = validatedCall.input;
-    const parameters = jsonParameters(parsedInput);
-    if (name === "analyze_function")
-        return executeFunctionTool(analysis, registration, contract, {
-            context,
-            parameters,
+const executeEnhancedTool = async (registration, contract, request) => {
+    const admitted = await registration.withAdmittedAnalysis(request.validatedCall.name, request.context.mcpReq.signal, async (admittedAnalysis) => {
+        const { validatedCall, context } = request;
+        const name = validatedCall.name;
+        const progress = mcpProgressReporter(context);
+        await progress.report({
+            phase: name,
+            completed: 0,
+            total: 1,
+            message: "started",
         });
-    const services = new EnhancedTools({
-        execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
-            ...executionOptions,
-            progress,
-        }),
-    });
-    const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall, context.mcpReq.signal));
-    await progress.report({
-        phase: name,
-        completed: 1,
-        total: 1,
-        message: result.ok ? "completed" : "failed",
-        terminal: true,
-    });
-    if (result.ok) {
-        const evidence = createWorkflowEvidence({
-            target: registration.activeTarget?.(),
-            operation: name,
-            parameters,
-            result: result.value,
-            upstreamProfile: registration.analysisProfile?.(),
+        const parsedInput = validatedCall.input;
+        const parameters = jsonParameters(parsedInput);
+        if (name === "analyze_function")
+            return executeFunctionTool(admittedAnalysis, registration, contract, {
+                context,
+                parameters,
+            });
+        const services = new EnhancedTools({
+            execute: (operation, operationParameters, executionOptions) => admittedAnalysis.execute(operation, operationParameters, {
+                ...executionOptions,
+                progress,
+            }),
         });
-        const recorded = registration.recordEvidence?.(evidence);
-        if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, contract);
-        if (name !== "trace_native_ui_action" &&
-            registration.allowsSnapshotReplay?.(name) === true) {
-            const workflowRecord = workflowSnapshotRecord(evidence, name);
-            if (workflowRecord !== undefined) {
-                const snapshot = registration.recordWorkflowSnapshot?.(workflowRecord);
-                if (snapshot !== undefined && !snapshot.ok)
-                    return toCallToolResult(snapshot, contract);
+        const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall, context.mcpReq.signal));
+        await progress.report({
+            phase: name,
+            completed: 1,
+            total: 1,
+            message: result.ok ? "completed" : "failed",
+            terminal: true,
+        });
+        if (result.ok) {
+            const evidence = createWorkflowEvidence({
+                target: registration.activeTarget?.(),
+                operation: name,
+                parameters,
+                result: result.value,
+                upstreamProfile: registration.analysisProfile?.(),
+            });
+            const recorded = registration.recordEvidence?.(evidence);
+            if (recorded !== undefined && !recorded.ok)
+                return registration.delivery.toCallToolResult(recorded, contract);
+            if (name !== "trace_native_ui_action" &&
+                registration.allowsSnapshotReplay?.(name) === true) {
+                const workflowRecord = workflowSnapshotRecord(evidence, name);
+                if (workflowRecord !== undefined) {
+                    const snapshot = registration.recordWorkflowSnapshot?.(workflowRecord);
+                    if (snapshot !== undefined && !snapshot.ok)
+                        return registration.delivery.toCallToolResult(snapshot, contract);
+                }
             }
+            const unknowns = recordWorkflowUnknowns({
+                name,
+                result: result.value,
+                evidenceId: evidence.evidence_id,
+                recordUnknown: registration.recordUnknown,
+            });
+            if (!unknowns.ok)
+                return registration.delivery.toCallToolResult(unknowns, contract);
+            return registration.delivery.toEvidenceToolResult(evidence, contract, recorded);
         }
-        const unknowns = recordWorkflowUnknowns({
-            name,
-            result: result.value,
-            evidenceId: evidence.evidence_id,
-            recordUnknown: registration.recordUnknown,
-        });
-        if (!unknowns.ok)
-            return toCallToolResult(unknowns, contract);
-        return toEvidenceToolResult(evidence, contract, recorded);
-    }
-    return toCallToolResult(result, contract);
+        return registration.delivery.toCallToolResult(result, contract);
+    });
+    return admitted.ok
+        ? admitted.value
+        : registration.delivery.toCallToolResult(admitted, contract);
 };
 const executeFunctionTool = async (analysis, registration, contract, request) => {
     const { context, parameters } = request;
@@ -158,7 +163,7 @@ const executeFunctionTool = async (analysis, registration, contract, request) =>
         terminal: true,
     });
     if (!result.ok)
-        return toCallToolResult(result, contract);
-    return toEvidenceToolResult(result.value, contract, registration.recordEvidence?.(result.value));
+        return registration.delivery.toCallToolResult(result, contract);
+    return registration.delivery.toEvidenceToolResult(result.value, contract, registration.recordEvidence?.(result.value));
 };
 const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));

package/dist/server/registerEvidenceTools.js

@@ -3,59 +3,66 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 import { createArtifactExtractionDestination } from "../application/artifacts/ArtifactExtractionDestination.js";
 /** Register provider-backed contracts that return atomic Evidence observations. */
-export const registerEvidenceTools = (server, analysis, contracts, options) => {
+export const registerEvidenceTools = (server, contracts, options) => {
     for (const contract of contracts) {
         server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-            const progress = mcpProgressReporter(context);
-            await progress.report({
-                phase: contract.name,
-                completed: 0,
-                total: 1,
-                message: "started",
-            });
-            const parameters = jsonObjectSchema.parse(input);
-            const executionParameters = contract.name === "extract_artifact"
-                ? {
-                    ...parameters,
-                    output_root: createArtifactExtractionDestination(),
+            const admitted = await options.withAdmittedAnalysis(contract.name, context.mcpReq.signal, async (admittedAnalysis) => {
+                const analysis = options.analysisForAdmission?.(admittedAnalysis) ??
+                    admittedAnalysis;
+                const progress = mcpProgressReporter(context);
+                await progress.report({
+                    phase: contract.name,
+                    completed: 0,
+                    total: 1,
+                    message: "started",
+                });
+                const parameters = jsonObjectSchema.parse(input);
+                const executionParameters = contract.name === "extract_artifact"
+                    ? {
+                        ...parameters,
+                        output_root: createArtifactExtractionDestination(),
+                    }
+                    : parameters;
+                const execution = await logToolExecution(options.logger, contract.name, () => analysis.execute(contract.name, executionParameters, {
+                    signal: context.mcpReq.signal,
+                    progress,
+                }));
+                await progress.report({
+                    phase: contract.name,
+                    completed: 1,
+                    total: 1,
+                    message: execution.ok ? "completed" : "failed",
+                    terminal: true,
+                });
+                if (!execution.ok)
+                    return server.delivery.toCallToolResult(execution, contract);
+                const sourceEvidence = options.sourceEvidence?.(contract.name, execution.value.result) ??
+                    [];
+                const evidence = createEvidence(execution.value.subject ?? options.activeTarget?.(), execution.value.provider, {
+                    operation: contract.name,
+                    parameters,
+                    result: execution.value.result,
+                    ...(execution.value.analysisProfile === undefined
+                        ? {}
+                        : { analysisProfile: execution.value.analysisProfile }),
+                    rawResult: execution.value.rawResult,
+                    limitations: execution.value.limitations,
+                    locations: execution.value.locations,
+                    evidenceLinks: sourceEvidence.map(({ evidence_id: id }) => id),
+                });
+                for (const source of sourceEvidence) {
+                    const sourceRecorded = options.recordEvidence?.(source);
+                    if (sourceRecorded !== undefined && !sourceRecorded.ok)
+                        return server.delivery.toCallToolResult(sourceRecorded, contract);
                 }
-                : parameters;
-            const execution = await logToolExecution(options.logger, contract.name, () => analysis.execute(contract.name, executionParameters, {
-                signal: context.mcpReq.signal,
-                progress,
-            }));
-            await progress.report({
-                phase: contract.name,
-                completed: 1,
-                total: 1,
-                message: execution.ok ? "completed" : "failed",
-                terminal: true,
-            });
-            if (!execution.ok)
-                return toCallToolResult(execution, contract);
-            const sourceEvidence = options.sourceEvidence?.(contract.name, execution.value.result) ?? [];
-            const evidence = createEvidence(execution.value.subject ?? options.activeTarget?.(), execution.value.provider, {
-                operation: contract.name,
-                parameters,
-                result: execution.value.result,
-                ...(execution.value.analysisProfile === undefined
-                    ? {}
-                    : { analysisProfile: execution.value.analysisProfile }),
-                rawResult: execution.value.rawResult,
-                limitations: execution.value.limitations,
-                locations: execution.value.locations,
-                evidenceLinks: sourceEvidence.map(({ evidence_id: id }) => id),
+                const recorded = options.recordEvidence?.(evidence);
+                return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
             });
-            for (const source of sourceEvidence) {
-                const sourceRecorded = options.recordEvidence?.(source);
-                if (sourceRecorded !== undefined && !sourceRecorded.ok)
-                    return toCallToolResult(sourceRecorded, contract);
-            }
-            const recorded = options.recordEvidence?.(evidence);
-            return toEvidenceToolResult(evidence, contract, recorded);
+            return admitted.ok
+                ? admitted.value
+                : server.delivery.toCallToolResult(admitted, contract);
         });
     }
 };

package/dist/server/registerEvmTools.js

@@ -1,15 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind the named EVM contract to shared validation and session Evidence recording. */
 export const registerEvmTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_evm_interface");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const result = await logToolExecution(logger, contract.name, () => service.inspect(input, { signal: context.mcpReq.signal }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, contract, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerFirmwareTools.js

@@ -1,7 +1,6 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind firmware handlers to their exact named schemas. */
 export const registerFirmwareTools = (server, service, logger, recordEvidence) => {
     const handler = (contract) => async (input, context) => {
@@ -9,9 +8,9 @@ export const registerFirmwareTools = (server, service, logger, recordEvidence) =
             signal: context.mcpReq.signal,
         }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, contract, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     };
     const inspect = toolContract("inspect_firmware_regions");
     server.registerTool(inspect.name, toolRegistrationOptions(inspect), handler(inspect));

package/dist/server/registerFunctionComparisonTool.js

@@ -2,14 +2,13 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { err } from "../domain/result.js";
-import { compareFunctions } from "../domain/functionComparison.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
+import { FUNCTION_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
+import { compareFunctions } from "../domain/functionComparison.js";
 /** Register explicit Evidence-backed function comparison. */
 export const registerFunctionComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -20,22 +19,22 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             rightEvidence = parseEvidence(input.right);
         }
         catch (cause) {
-            return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
+            return server.delivery.toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
         }
         if (leftEvidence.operation !== "analyze_function" ||
             rightEvidence.operation !== "analyze_function" ||
             leftEvidence.predicate_type !== "rea.analysis" ||
             rightEvidence.predicate_type !== "rea.analysis")
-            return toCallToolResult(err(new EvidenceIntegrityError("Expected analyze_function Evidence")), contract);
+            return server.delivery.toCallToolResult(err(new EvidenceIntegrityError("Expected analyze_function Evidence")), contract);
         const leftIds = [leftEvidence.evidence_id];
         const rightIds = [rightEvidence.evidence_id];
         const computed = await runDerivedOperation(context, contract.name, () => compareFunctions(leftEvidence, rightEvidence));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const comparison = computed.value;
         const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftEvidence, rightEvidence]);
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, contract);
+            return server.delivery.toCallToolResult(recordedSources, contract);
         const evidence = createEvidence(undefined, FUNCTION_COMPARISON_PROVIDER, {
             predicateType: "rea.function-comparison",
             operation: contract.name,
@@ -55,7 +54,7 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             rightIds,
             comparisonEvidenceId: evidence.evidence_id,
         }));
-        return toEvidenceToolResult(evidence, contract, recorded);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const functionUnknownInput = ({ status, leftIds, rightIds, comparisonEvidenceId, }) => {

package/dist/server/registerInvestigationTools.js

@@ -3,13 +3,12 @@ import { buildCallPath } from "../domain/callPath.js";
 import { findChangedBehavior } from "../domain/changedBehavior.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { verifyReconstruction } from "../domain/reconstructionVerification.js";
 import { correlateStaticAndRuntime } from "../domain/staticRuntimeCorrelation.js";
 import { comparisonClosure, evidenceClosure, functionEvidenceIds, isIncomplete, recordWorkflowEvidence, } from "./registerInvestigationTools/helpers.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "./sessionToolPolicies.js";
+import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
+import { verifyReconstruction } from "../domain/reconstructionVerification.js";
 /** Register Evidence-composed differential investigation workflows. */
 export const registerInvestigationTools = (server, session) => {
     registerChangedBehavior(server, session, toolContract("find_changed_behavior"));
@@ -21,11 +20,11 @@ const registerChangedBehavior = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, comparisonClosure(input.comparisons));
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(input.comparisons));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {
             predicateType: "rea.changed-behavior",
@@ -51,18 +50,18 @@ const registerChangedBehavior = (server, session, contract) => {
                 },
             ],
         });
-        return toEvidenceToolResult(evidence, contract, recorded);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const registerCallPath = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const closure = evidenceClosure(session, functionEvidenceIds(input.functions));
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const computed = await runDerivedOperation(context, contract.name, () => buildCallPath(input));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, CALL_PATH_PROVIDER, {
             predicateType: "rea.call-path",
@@ -89,7 +88,7 @@ const registerCallPath = (server, session, contract) => {
                 },
             ],
         });
-        return toEvidenceToolResult(evidence, contract, recorded);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const registerStaticRuntime = (server, session, contract) => {
@@ -99,11 +98,11 @@ const registerStaticRuntime = (server, session, contract) => {
             ...input.runtime_comparisons,
         ]));
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const computed = await runDerivedOperation(context, contract.name, () => correlateStaticAndRuntime(input));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const evidence = createEvidence(undefined, STATIC_RUNTIME_PROVIDER, {
             predicateType: "rea.static-runtime-correlation",
@@ -117,7 +116,7 @@ const registerStaticRuntime = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown" || result.status === "truncated", {
             question: "Does runtime behavior match the available static analysis?",
             domain: "static-runtime-correlation",
             requiredAuthority: null,
@@ -136,11 +135,11 @@ const registerReconstruction = (server, session, contract) => {
         const owned = session.exportEvidenceBundle();
         const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(input.specification, owned));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const result = computed.value;
         const closure = evidenceClosure(session, result.evidence_links);
         if (!closure.ok)
-            return toCallToolResult(closure, contract);
+            return server.delivery.toCallToolResult(closure, contract);
         const links = closure.value;
         const evidence = createEvidence(undefined, RECONSTRUCTION_PROVIDER, {
             predicateType: "rea.reconstruction-verification",
@@ -155,7 +154,7 @@ const registerReconstruction = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown", {
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordWorkflowEvidence(session, evidence, result.status === "unknown", {
             question: "Does the reconstruction satisfy every declared claim?",
             domain: "reconstruction-verification",
             requiredAuthority: null,

package/dist/server/registerJavaScriptRecoveryTool.js

@@ -1,15 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind optional recovery to its exact named contract without acquiring an engine. */
 export const registerJavaScriptRecoveryTool = (server, service, logger, recordEvidence) => {
     const contract = toolContract("recover_javascript_sources");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const result = await logToolExecution(logger, contract.name, () => service.recover(input, { signal: context.mcpReq.signal }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, contract, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -5,13 +5,13 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { observeJavaScriptRuntimeInputSchema } from "../domain/javascript/javascriptRuntimeObservation.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register passive Inspector tools even when policy keeps them unavailable. */
 export const registerJavaScriptRuntimeObservationTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const listContract = toolContract("list_javascript_runtime_targets");
     const observeContract = toolContract("observe_javascript_runtime");
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, parsed, { signal })));
-    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, async (parsed, signal) => {
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(registration, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, parsed, { signal })));
+    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(registration, observeContract, { input, context }, async (parsed, signal) => {
         const request = observeJavaScriptRuntimeInputSchema.parse(parsed);
         return observeJavaScriptRuntime(options.runtime, request, { signal });
     }));
@@ -19,10 +19,10 @@ export const registerJavaScriptRuntimeObservationTools = (server, options) => {
 const runRuntimeTool = async (options, contract, request, execute) => {
     const { input, context } = request;
     if (options.loadFailure !== undefined)
-        return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
+        return options.delivery.toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, context.mcpReq.signal));
     if (!result.ok)
-        return toCallToolResult(result, contract);
+        return options.delivery.toCallToolResult(result, contract);
     const recorded = options.recordEvidence?.(result.value);
-    return toEvidenceToolResult(result.value, contract, recorded);
+    return options.delivery.toEvidenceToolResult(result.value, contract, recorded);
 };

package/dist/server/registerManagedTools.js

@@ -5,9 +5,9 @@ import { registerEvidenceTools } from "./registerEvidenceTools.js";
 import { runManagedProviderExecution } from "../composition/directAnalysis.js";
 import { isManagedToolName } from "../contracts/managed/managedToolContracts.js";
 /** Register execution-free managed PE/CLI inspection. */
-export const registerManagedTools = (server, analysis, options) => {
+export const registerManagedTools = (server, options) => {
     let selectedManagedPath;
-    const managedAnalysis = {
+    const analysisForAdmission = (analysis) => ({
         execute: async (operation, parameters, executionOptions) => {
             if (!isManagedToolName(operation))
                 return analysis.execute(operation, parameters, executionOptions);
@@ -32,6 +32,9 @@ export const registerManagedTools = (server, analysis, options) => {
                 selectedManagedPath = requestedPath;
             return execution;
         },
-    };
-    registerEvidenceTools(server, managedAnalysis, MANAGED_TOOL_CONTRACTS, options);
+    });
+    registerEvidenceTools(server, MANAGED_TOOL_CONTRACTS, {
+        ...options,
+        analysisForAdmission,
+    });
 };