rea-agents 6.1.0 → 6.3.0

package/dist/server/registerApplicationTools/obligationLedger.js

@@ -3,7 +3,6 @@ import { buildReconstructionObligationLedgerEvidenceValidated, resolveReconstruc
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("build_reconstruction_obligation_ledger");
 /** Register conservative reconstruction-obligation generation and closure. */
@@ -11,13 +10,13 @@ export const registerReconstructionObligationLedgerTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolveReconstructionObligationLedgerRequest(input);
         if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
+            return server.delivery.toCallToolResult(resolved, contract);
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(buildReconstructionObligationLedgerEvidenceValidated(resolved.value)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, resolved.value.evidence_bundle.records);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
-        return recordResult(options, contract, result.value);
+            return server.delivery.toCallToolResult(recorded, contract);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
     });
 };

package/dist/server/registerApplicationTools/projectMobileApplicationGraph.js

@@ -4,7 +4,6 @@ import { APPLICATION_TOOL_CONTRACTS, applicationToolContract, } from "../../cont
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 /** Register execution-free Android and Apple inventory projection tools. */
 export const registerProjectMobileApplicationGraphTools = (server, options) => {
@@ -26,11 +25,11 @@ const registerProjection = (context) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(project(input)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recordedSources = recordSessionEvidenceSources(options.recordEvidence, inventoryEvidenceSources(input));
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, contract);
-        return recordResult(options, contract, result.value);
+            return server.delivery.toCallToolResult(recordedSources, contract);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
     });
 };
 const inventoryEvidenceSources = (input) => {

package/dist/server/registerApplicationTools/traceFeature.js

@@ -4,7 +4,6 @@ import { traceApplicationFeatureEvidenceValidated } from "../../application/java
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const traceContract = applicationToolContract("trace_application_feature");
 /** Register the provider-neutral JavaScript feature trace tool. */
@@ -12,15 +11,15 @@ export const registerTraceFeatureTool = (server, options) => {
     server.registerTool(traceContract.name, toolRegistrationOptions(traceContract), async (input) => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, traceContract);
+            return server.delivery.toCallToolResult(resolved, traceContract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, traceContract.name, () => Promise.resolve(traceApplicationFeatureEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, traceContract);
+            return server.delivery.toCallToolResult(result, traceContract);
         const sources = [parsed.application, ...parsed.native_observations];
         const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
-            return toCallToolResult(recorded, traceContract);
-        return recordResult(options, traceContract, result.value);
+            return server.delivery.toCallToolResult(recorded, traceContract);
+        return recordResult({ ...options, delivery: server.delivery }, traceContract, result.value);
     });
 };

package/dist/server/registerApplicationTools/traceSemantics.js

@@ -4,7 +4,6 @@ import { traceJavaScriptSemanticsEvidenceValidated } from "../../application/jav
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("trace_javascript_semantics");
 /** Register the bounded JavaScript semantic relation trace tool. */
@@ -12,16 +11,16 @@ export const registerTraceJavaScriptSemanticsTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolveApplicationEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
+            return server.delivery.toCallToolResult(resolved, contract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(traceJavaScriptSemanticsEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.application,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
-        return recordResult(options, contract, result.value);
+            return server.delivery.toCallToolResult(recorded, contract);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value);
     });
 };

package/dist/server/registerArtifactComparisonTool.js

@@ -4,9 +4,8 @@ import { createEvidence, parseEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { ARTIFACT_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
+import { ARTIFACT_COMPARISON_PROVIDER } from "../application/InvestigationProviders.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Register Evidence-backed deterministic artifact comparison. */
 export const registerArtifactComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
@@ -16,13 +15,13 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             return { left, right, comparison: compareArtifacts(left, right) };
         });
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const { left, right, comparison } = computed.value;
         const sources = [left, right];
         for (const source of sources) {
             const recordedSource = session.recordEvidence(source);
             if (!recordedSource.ok)
-                return toCallToolResult(recordedSource, contract);
+                return server.delivery.toCallToolResult(recordedSource, contract);
         }
         const leftEvidenceIds = [left.evidence_id];
         const rightEvidenceIds = [right.evidence_id];
@@ -39,7 +38,7 @@ export const registerArtifactComparisonTool = (server, session, contract) => {
             limitations: comparison.limitations,
             evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
         });
-        return toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status, evidence.evidence_id)));
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, artifactUnknownInput(left, right, comparison.status, evidence.evidence_id)));
     });
 };
 const artifactUnknownInput = (left, right, status, comparisonEvidenceId) => {

package/dist/server/registerArtifactTools.js

@@ -2,8 +2,8 @@ import { ARTIFACT_TOOL_CONTRACTS } from "../contracts/artifactToolContracts.js";
 import { registerEvidenceTools } from "./registerEvidenceTools.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 /** Register deterministic artifact inventory and safe extraction operations. */
-export const registerArtifactTools = (server, analysis, options) => {
-    registerEvidenceTools(server, analysis, ARTIFACT_TOOL_CONTRACTS, {
+export const registerArtifactTools = (server, options) => {
+    registerEvidenceTools(server, ARTIFACT_TOOL_CONTRACTS, {
         ...options,
         sourceEvidence: (operation, result) => operation === "inspect_artifact"
             ? artifactInspectionResultSchema

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,23 +3,24 @@ 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) => {
         const progress = mcpProgressReporter(context);
         const snapshotPath = input.snapshot_path;
         if (snapshotPath === undefined) {
+            // Enqueue the lifecycle transition before awaiting progress transport so
+            // a later open request cannot overtake this close.
+            const closing = logToolExecution(logger, closeContract.name, () => session.close({ progress }));
             await reportLifecycleStart(progress, closeContract.name);
-            const closed = await logToolExecution(logger, closeContract.name, () => session.close({ progress }));
+            const closed = await closing;
             await reportLifecycleEnd(progress, closeContract.name, closed.ok);
-            return toCallToolResult(closed, closeContract);
+            return server.delivery.toCallToolResult(closed, closeContract);
         }
+        const closing = logToolExecution(logger, closeContract.name, () => session.closeWithSnapshot(snapshotPath, input.overwrite, { progress }));
         await reportLifecycleStart(progress, closeContract.name, "saving snapshot; closing provider");
-        const closed = await logToolExecution(logger, closeContract.name, () => session.closeWithSnapshot(snapshotPath, input.overwrite, {
-            progress,
-        }));
+        const closed = await closing;
         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);
 };