rea-agents 6.1.0 → 6.2.0

package/dist/server/registerBinaryDiagnosticsTools.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 offline layout inspection to its named contract and session Evidence owner. */
 export const registerBinaryDiagnosticsTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_binary_layout");
     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/registerBrowserScenarioTool.js

@@ -5,20 +5,19 @@ import { toolContract } from "../contracts/toolContracts.js";
 import { browserScenarioSchema } from "../domain/browserScenario.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register the browser scenario tool with execution-time provider diagnostics. */
 export const registerBrowserScenarioTool = (server, options) => {
     const contract = toolContract("capture_browser_scenario");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const scenario = browserScenarioSchema.parse(input);
         if (options.loadFailure !== undefined)
-            return toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
+            return server.delivery.toCallToolResult(err(optionalProviderUnavailable(options.loadFailure, contract.name)), contract);
         const result = await logToolExecution(options.logger, contract.name, () => captureBrowserScenario(options.provider, scenario, {
             signal: context.mcpReq.signal,
         }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = options.recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, contract, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerBrowserTools.js

@@ -7,10 +7,10 @@ import { inspectWebPageInputSchema } from "../domain/browserObservation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register browser tools with execution-time provider diagnostics. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerBrowserTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const listContract = toolContract("list_browser_targets");
     const inspectContract = toolContract("inspect_web_page");
     const analyzeContract = toolContract("analyze_web_bundle");
@@ -19,42 +19,39 @@ export const registerBrowserTools = (server, options) => {
     const captureDiffContract = toolContract("compare_web_captures");
     const screenshotContract = toolContract("capture_web_screenshot");
     const screenshotDiffContract = toolContract("compare_web_screenshots");
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(options, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, parsed, {
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runBrowserTool(registration, listContract, { input, context }, (parsed, { signal }) => listBrowserTargets(options.browser, parsed, {
         signal,
     })));
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(options, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, inspectWebPageInputSchema.parse(parsed), { signal, progress })));
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, analyzeWebBundleInputSchema.parse(parsed), {
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runBrowserTool(registration, inspectContract, { input, context }, (parsed, { signal, progress }) => inspectWebPage(options.browser, inspectWebPageInputSchema.parse(parsed), { signal, progress })));
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runBrowserTool(registration, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeWebBundle(options.browser, analyzeWebBundleInputSchema.parse(parsed), {
         signal,
         progress,
     })));
-    server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), (input, context) => runBrowserTool(options, sessionContract, { input, context }, (parsed, { signal, progress }) => observeWebSession(options.browser, parsed, {
+    server.registerTool(sessionContract.name, toolRegistrationOptions(sessionContract), (input, context) => runBrowserTool(registration, sessionContract, { input, context }, (parsed, { signal, progress }) => observeWebSession(options.browser, parsed, {
         signal,
         progress,
     })));
-    server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), (input, context) => runBrowserTool(options, webMcpContract, { input, context }, (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, parsed, {
+    server.registerTool(webMcpContract.name, toolRegistrationOptions(webMcpContract), (input, context) => runBrowserTool(registration, webMcpContract, { input, context }, (parsed, { signal, progress }) => discoverWebMcpTools(options.browser, parsed, {
         signal,
         progress,
     })));
-    server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), (input, context) => runBrowserTool(options, captureDiffContract, { input, context }, (parsed) => compareWebCaptureEvidence(options.browser, parsed)));
-    server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), (input, context) => runBrowserTool(options, screenshotContract, { input, context }, (parsed, { signal, progress }) => captureWebScreenshot(options.browser, parsed, {
+    server.registerTool(captureDiffContract.name, toolRegistrationOptions(captureDiffContract), (input, context) => runBrowserTool(registration, captureDiffContract, { input, context }, (parsed) => compareWebCaptureEvidence(options.browser, parsed)));
+    server.registerTool(screenshotContract.name, toolRegistrationOptions(screenshotContract), (input, context) => runBrowserTool(registration, screenshotContract, { input, context }, (parsed, { signal, progress }) => captureWebScreenshot(options.browser, parsed, {
         signal,
         progress,
     })));
-    server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), (input, context) => runBrowserTool(options, screenshotDiffContract, { input, context }, (parsed) => compareWebScreenshotEvidence(options.browser, parsed)));
+    server.registerTool(screenshotDiffContract.name, toolRegistrationOptions(screenshotDiffContract), (input, context) => runBrowserTool(registration, screenshotDiffContract, { input, context }, (parsed) => compareWebScreenshotEvidence(options.browser, parsed)));
 };
 const runBrowserTool = 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, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),
     }));
     if (!result.ok)
-        return toCallToolResult(result, contract);
-    return evidenceResult(options, contract, result.value);
-};
-const evidenceResult = (options, contract, evidence) => {
-    const recorded = options.recordEvidence?.(evidence);
-    return toEvidenceToolResult(evidence, contract, recorded);
+        return options.delivery.toCallToolResult(result, contract);
+    const recorded = options.recordEvidence?.(result.value);
+    return options.delivery.toEvidenceToolResult(result.value, contract, recorded);
 };

package/dist/server/registerBundleComparisonTool.js

@@ -4,9 +4,8 @@ import { compareBundles } from "../domain/bundleComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { BUNDLE_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
+import { BUNDLE_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register canonical Evidence bundle comparison. */
 export const registerBundleComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -15,12 +14,12 @@ export const registerBundleComparisonTool = (server, session, contract) => {
             readEvidenceBundle(input.right_bundle_path),
         ]);
         if (!left.ok)
-            return toCallToolResult(left, contract);
+            return server.delivery.toCallToolResult(left, contract);
         if (!right.ok)
-            return toCallToolResult(right, contract);
+            return server.delivery.toCallToolResult(right, contract);
         const computed = await runDerivedOperation(context, contract.name, () => compareBundles(left.value, right.value, input.record_pairs));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const comparison = computed.value;
         const evidence = createEvidence(undefined, BUNDLE_COMPARISON_PROVIDER, {
             predicateType: "rea.bundle-comparison",
@@ -36,6 +35,6 @@ export const registerBundleComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
         });
         const recorded = session.recordEvidence(evidence);
-        return toEvidenceToolResult(evidence, contract, recorded);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };

package/dist/server/registerCloseLifecycleTool.js

@@ -3,7 +3,6 @@ import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register provider cleanup and optional pre-close snapshot persistence. */
 export const registerCloseLifecycleTool = ({ server, session, logger, closeContract, }) => {
     server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input, context) => {
@@ -13,13 +12,13 @@ export const registerCloseLifecycleTool = ({ server, session, logger, closeContr
             await reportLifecycleStart(progress, closeContract.name);
             const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
             await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-            return toCallToolResult(closed, closeContract);
+            return server.delivery.toCallToolResult(closed, closeContract);
         }
         await reportLifecycleStart(progress, closeContract.name, "saving snapshot; closing provider");
         const closed = await logToolExecution(logger, closeContract.name, () => session.closeWithSnapshot(snapshotPath, input.overwrite, {
             progress,
         }));
         await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-        return toCallToolResult(closed.ok ? ok({ ...closed.value }) : closed, closeContract);
+        return server.delivery.toCallToolResult(closed.ok ? ok({ ...closed.value }) : closed, closeContract);
     });
 };

package/dist/server/registerElectronTools.js

@@ -9,28 +9,28 @@ import { inspectElectronPageInputSchema } from "../domain/javascript/electronObs
 import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register Electron tools even when a provider is absent. */
 // oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerElectronTools = (server, options) => {
+    const registration = { ...options, delivery: server.delivery };
     const listContract = toolContract("list_electron_targets");
     const inspectContract = toolContract("inspect_electron_page");
     const analyzeContract = toolContract("analyze_javascript_application");
     const reconcileContract = toolContract("reconcile_javascript_runtime");
     const activeContract = toolContract("capture_electron_scenario");
-    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(options, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, parsed, {
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runElectronTool(registration, listContract, { input, context }, (parsed, { signal }) => listElectronTargets(options.electron, parsed, {
         signal,
     })));
-    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(options, inspectContract, { input, context }, async (parsed, { signal, progress }) => {
+    server.registerTool(inspectContract.name, toolRegistrationOptions(inspectContract), (input, context) => runElectronTool(registration, inspectContract, { input, context }, async (parsed, { signal, progress }) => {
         const request = inspectElectronPageInputSchema.parse(parsed);
         return inspectElectronPage(options.electron, request, {
             signal,
             progress,
         });
     }));
-    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(options, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(parsed, { signal, progress })));
-    server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), (input, context) => runElectronTool(options, reconcileContract, { input, context }, (parsed) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed))));
-    server.registerTool(activeContract.name, toolRegistrationOptions(activeContract), (input, context) => runElectronTool(options, activeContract, { input, context }, (parsed, { signal, progress }) => captureElectronScenario(options.electronActive, parsed, {
+    server.registerTool(analyzeContract.name, toolRegistrationOptions(analyzeContract), (input, context) => runElectronTool(registration, analyzeContract, { input, context }, (parsed, { signal, progress }) => analyzeJavaScriptApplicationValidated(parsed, { signal, progress })));
+    server.registerTool(reconcileContract.name, toolRegistrationOptions(reconcileContract), (input, context) => runElectronTool(registration, reconcileContract, { input, context }, (parsed) => Promise.resolve(reconcileJavaScriptRuntimeEvidenceValidated(parsed))));
+    server.registerTool(activeContract.name, toolRegistrationOptions(activeContract), (input, context) => runElectronTool(registration, activeContract, { input, context }, (parsed, { signal, progress }) => captureElectronScenario(options.electronActive, parsed, {
         signal,
         progress,
     })));
@@ -44,16 +44,13 @@ const runElectronTool = async (options, contract, request, execute) => {
             ? options.observationLoadFailure
             : undefined;
     if (failure !== undefined)
-        return toCallToolResult(err(optionalProviderUnavailable(failure, contract.name)), contract);
+        return options.delivery.toCallToolResult(err(optionalProviderUnavailable(failure, contract.name)), contract);
     const result = await logToolExecution(options.logger, contract.name, () => execute(input, {
         signal: context.mcpReq.signal,
         progress: mcpProgressReporter(context),
     }));
     if (!result.ok)
-        return toCallToolResult(result, contract);
-    return evidenceResult(options, contract, result.value);
-};
-const evidenceResult = (options, contract, evidence) => {
-    const recorded = options.recordEvidence?.(evidence);
-    return toEvidenceToolResult(evidence, contract, recorded);
+        return options.delivery.toCallToolResult(result, contract);
+    const recorded = options.recordEvidence?.(result.value);
+    return options.delivery.toEvidenceToolResult(result.value, contract, recorded);
 };

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) => {
+    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,59 +23,59 @@ 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, 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(analysis, registration, traceNativeUiAction, {
         validatedCall: { name: "trace_native_ui_action", input },
         context,
     }));
@@ -121,14 +121,14 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
         });
         const recorded = registration.recordEvidence?.(evidence);
         if (recorded !== undefined && !recorded.ok)
-            return toCallToolResult(recorded, contract);
+            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 toCallToolResult(snapshot, contract);
+                    return registration.delivery.toCallToolResult(snapshot, contract);
             }
         }
         const unknowns = recordWorkflowUnknowns({
@@ -138,10 +138,10 @@ const executeEnhancedTool = async (analysis, registration, contract, request) =>
             recordUnknown: registration.recordUnknown,
         });
         if (!unknowns.ok)
-            return toCallToolResult(unknowns, contract);
-        return toEvidenceToolResult(evidence, contract, recorded);
+            return registration.delivery.toCallToolResult(unknowns, contract);
+        return registration.delivery.toEvidenceToolResult(evidence, contract, recorded);
     }
-    return toCallToolResult(result, contract);
+    return registration.delivery.toCallToolResult(result, contract);
 };
 const executeFunctionTool = async (analysis, registration, contract, request) => {
     const { context, parameters } = request;
@@ -158,7 +158,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,7 +3,6 @@ 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) => {
@@ -35,7 +34,7 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 terminal: true,
             });
             if (!execution.ok)
-                return toCallToolResult(execution, contract);
+                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,
@@ -52,10 +51,10 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
             for (const source of sourceEvidence) {
                 const sourceRecorded = options.recordEvidence?.(source);
                 if (sourceRecorded !== undefined && !sourceRecorded.ok)
-                    return toCallToolResult(sourceRecorded, contract);
+                    return server.delivery.toCallToolResult(sourceRecorded, contract);
             }
             const recorded = options.recordEvidence?.(evidence);
-            return toEvidenceToolResult(evidence, contract, recorded);
+            return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
         });
     }
 };

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