rea-agents 6.1.0 → 6.2.0

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/registerManagedWorkflowTools/compareManagedMembers.js

@@ -3,7 +3,6 @@ import { compareManagedMembersEvidenceValidated } from "../../application/manage
 import { managedMemberComparisonResultSchema } from "../../domain/managed/managedMemberComparison.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const compareContract = managedWorkflowContract("compare_managed_members");
@@ -13,9 +12,9 @@ export const registerCompareManagedMembers = (server, options) => {
         const leftResolved = resolveManagedEvidence(input.left);
         const rightResolved = resolveManagedEvidence(input.right);
         if (!leftResolved.ok)
-            return toCallToolResult(leftResolved, compareContract);
+            return server.delivery.toCallToolResult(leftResolved, compareContract);
         if (!rightResolved.ok)
-            return toCallToolResult(rightResolved, compareContract);
+            return server.delivery.toCallToolResult(rightResolved, compareContract);
         const [left] = leftResolved.value;
         const [right] = rightResolved.value;
         if (left === undefined || right === undefined)
@@ -23,13 +22,13 @@ export const registerCompareManagedMembers = (server, options) => {
         const parsed = { left, right };
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareManagedMembersEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, compareContract);
+            return server.delivery.toCallToolResult(result, compareContract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.left,
             parsed.right,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, compareContract);
+            return server.delivery.toCallToolResult(recorded, compareContract);
         const comparison = managedMemberComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
         const output = unknown
@@ -51,6 +50,6 @@ export const registerCompareManagedMembers = (server, options) => {
                 relationships: [],
             })
             : options.recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, compareContract, output);
+        return server.delivery.toEvidenceToolResult(result.value, compareContract, output);
     });
 };

package/dist/server/registerManagedWorkflowTools/importManagedReconstruction.js

@@ -1,7 +1,6 @@
 import { importManagedReconstructionEvidenceValidated } from "../../application/managed/ManagedReconstructionService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const reconstructionContract = managedWorkflowContract("import_managed_reconstruction");
@@ -10,18 +9,18 @@ export const registerImportManagedReconstruction = (server, options) => {
     server.registerTool(reconstructionContract.name, toolRegistrationOptions(reconstructionContract), async (input) => {
         const resolved = resolveManagedEvidence(input.static_members);
         if (!resolved.ok)
-            return toCallToolResult(resolved, reconstructionContract);
+            return server.delivery.toCallToolResult(resolved, reconstructionContract);
         const staticMembers = resolved.value[0];
         if (staticMembers === undefined)
             throw new TypeError("Managed reconstruction Evidence resolution failed");
         const parsed = { ...input, static_members: staticMembers };
         const result = await logToolExecution(options.logger, reconstructionContract.name, () => Promise.resolve(importManagedReconstructionEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, reconstructionContract);
+            return server.delivery.toCallToolResult(result, reconstructionContract);
         const recordedSource = options.recordEvidence?.(parsed.static_members);
         if (recordedSource !== undefined && !recordedSource.ok)
-            return toCallToolResult(recordedSource, reconstructionContract);
+            return server.delivery.toCallToolResult(recordedSource, reconstructionContract);
         const recorded = options.recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, reconstructionContract, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, reconstructionContract, recorded);
     });
 };

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -2,7 +2,6 @@ import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { projectManagedApplicationGraphEvidence } from "../../application/managed/ManagedApplicationGraphService.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedArtifactEvidence, resolveManagedBoundaryEvidence, resolveManagedEvidence, sourceEvidence, } from "./evidence.js";
 const graphContract = managedWorkflowContract("project_managed_application_graph");
@@ -13,17 +12,17 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
             ? undefined
             : resolveManagedArtifactEvidence(input.managed_artifact);
         if (managedArtifact !== undefined && !managedArtifact.ok)
-            return toCallToolResult(managedArtifact, graphContract);
+            return server.delivery.toCallToolResult(managedArtifact, graphContract);
         const managedMembers = input.managed_members === undefined
             ? undefined
             : resolveManagedEvidence(input.managed_members);
         if (managedMembers !== undefined && !managedMembers.ok)
-            return toCallToolResult(managedMembers, graphContract);
+            return server.delivery.toCallToolResult(managedMembers, graphContract);
         const managedBoundaries = input.managed_native_boundaries === undefined
             ? undefined
             : resolveManagedBoundaryEvidence(input.managed_native_boundaries);
         if (managedBoundaries !== undefined && !managedBoundaries.ok)
-            return toCallToolResult(managedBoundaries, graphContract);
+            return server.delivery.toCallToolResult(managedBoundaries, graphContract);
         const parsed = {
             managed_artifact: managedArtifact?.value[0],
             managed_members: managedMembers?.value[0],
@@ -31,11 +30,11 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
         };
         const result = await logToolExecution(options.logger, graphContract.name, () => Promise.resolve(projectManagedApplicationGraphEvidence(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, graphContract);
+            return server.delivery.toCallToolResult(result, graphContract);
         const recordedSources = recordSessionEvidenceSources(options.recordEvidence, sourceEvidence(parsed));
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, graphContract);
+            return server.delivery.toCallToolResult(recordedSources, graphContract);
         const recorded = options.recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, graphContract, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, graphContract, recorded);
     });
 };

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -1,9 +1,8 @@
 import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 import { verifyManagedNativeBoundariesEvidence } from "../../application/managed/ManagedNativeVerificationService.js";
-import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerification.js";
+import { managedNativeVerificationResultSchema } from "../../domain/managed/managedNativeVerificationSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedBoundaryEvidence, resolveNativeEvidence, } from "./evidence.js";
 const nativeVerificationContract = managedWorkflowContract("verify_managed_native_boundaries");
@@ -12,10 +11,10 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
     server.registerTool(nativeVerificationContract.name, toolRegistrationOptions(nativeVerificationContract), async (input) => {
         const managedBoundaries = resolveManagedBoundaryEvidence(input.managed_boundaries);
         if (!managedBoundaries.ok)
-            return toCallToolResult(managedBoundaries, nativeVerificationContract);
+            return server.delivery.toCallToolResult(managedBoundaries, nativeVerificationContract);
         const nativeObservations = resolveNativeEvidence(input.native_observations);
         if (!nativeObservations.ok)
-            return toCallToolResult(nativeObservations, nativeVerificationContract);
+            return server.delivery.toCallToolResult(nativeObservations, nativeVerificationContract);
         const managedBoundary = managedBoundaries.value[0];
         if (managedBoundary === undefined)
             throw new TypeError("Managed boundary Evidence resolution failed");
@@ -26,10 +25,10 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
         };
         const result = await logToolExecution(options.logger, nativeVerificationContract.name, () => Promise.resolve(verifyManagedNativeBoundariesEvidence(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, nativeVerificationContract);
+            return server.delivery.toCallToolResult(result, nativeVerificationContract);
         const recordedSources = recordSessionEvidenceSources(options.recordEvidence, [parsed.managed_boundaries, ...parsed.native_observations]);
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, nativeVerificationContract);
+            return server.delivery.toCallToolResult(recordedSources, nativeVerificationContract);
         const verification = managedNativeVerificationResultSchema.parse(result.value.normalized_result);
         const unknown = verification.summary.unresolved > 0 ||
             verification.summary.contradicted > 0 ||
@@ -57,6 +56,6 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
                 relationships: [],
             })
             : options.recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, nativeVerificationContract, output);
+        return server.delivery.toEvidenceToolResult(result.value, nativeVerificationContract, output);
     });
 };

package/dist/server/registerOfficialTools.js

@@ -1,11 +1,9 @@
-import { z } from "zod";
 import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/officialToolContracts.js";
 import { createEvidence } from "../domain/evidence.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
+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";
 /** Register direct bridge proxies, preserving MCP cancellation and typed errors. */
 export const registerOfficialTools = (server, analysis, options) => {
     for (const contract of OFFICIAL_TOOL_CONTRACTS) {
@@ -18,7 +16,7 @@ export const registerOfficialTools = (server, analysis, options) => {
 };
 const registerOfficialTool = (server, analysis, contract, registration) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const arguments_ = projectOfficialArguments(contract, input);
+        const arguments_ = jsonObjectSchema.parse(contract.inputSchema.parse(input));
         const progress = mcpProgressReporter(context);
         const result = await runOfficialOperation(analysis, contract, arguments_, {
             logger: registration.logger,
@@ -26,7 +24,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
             progress,
         });
         if (!result.ok) {
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         }
         const evidence = createEvidence(result.value.subject ?? registration.activeTarget?.(), result.value.provider, {
             operation: contract.name,
@@ -40,7 +38,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
             locations: result.value.locations,
         });
         const recorded = registration.recordEvidence?.(evidence);
-        return toEvidenceToolResult(evidence, contract, recorded);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recorded);
     });
 };
 const runOfficialOperation = async (analysis, contract, arguments_, execution) => {
@@ -63,16 +61,3 @@ const runOfficialOperation = async (analysis, contract, arguments_, execution) =
     });
     return result;
 };
-const projectOfficialArguments = (contract, input) => {
-    // Annotation omissions preserve existing values; they are not Python defaults.
-    if (contract.name === "annotate_native_function")
-        return jsonObjectSchema.parse(contract.inputSchema.parse(input));
-    const parsed = jsonObjectSchema.parse(input);
-    if (!(contract.inputSchema instanceof z.ZodObject))
-        throw new TypeError("Official tool input contract must be an object schema");
-    const projected = {};
-    for (const key of Object.keys(contract.inputSchema.shape)) {
-        projected[key] = jsonValueSchema.parse(parsed[key] ?? null);
-    }
-    return projected;
-};

package/dist/server/registerProcessComparisonTool.js

@@ -5,14 +5,14 @@ import { describeValidationFailure } from "../domain/evidenceBundle.js";
 import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../domain/process/processCapture.js";
+import { compareProcessCaptures } from "../domain/process/processComparison.js";
+import { parseProcessCapture, } from "../domain/process/processCaptureParsing.js";
 import { err, ok } from "../domain/result.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { recordSessionEvidenceSources } from "./sessionEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { PROCESS_PROVIDER } from "./sessionToolPolicies.js";
+import { PROCESS_PROVIDER } from "../domain/process/processEvidenceProvider.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 const PROCESS_CAPTURE_EVIDENCE = {
     operation: "capture_process_scenario",
     predicate: "rea.process-capture",
@@ -60,10 +60,10 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const left = parseCaptureSide(contract.name, "left", input.left);
         if (!left.ok)
-            return toCallToolResult(left, contract);
+            return server.delivery.toCallToolResult(left, contract);
         const right = parseCaptureSide(contract.name, "right", input.right);
         if (!right.ok)
-            return toCallToolResult(right, contract);
+            return server.delivery.toCallToolResult(right, contract);
         const { record: leftRecord, capture: leftCapture } = left.value;
         const { record: rightRecord, capture: rightCapture } = right.value;
         const computed = await runDerivedOperation(context, contract.name, () => compareProcessCaptures(leftCapture, rightCapture, {
@@ -76,7 +76,7 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
             now,
         }));
         if (!computed.ok)
-            return toCallToolResult(computed, contract);
+            return server.delivery.toCallToolResult(computed, contract);
         const comparison = computed.value;
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
             predicateType: "rea.process-comparison",
@@ -99,8 +99,8 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
         });
         const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftRecord, rightRecord]);
         if (!recordedSources.ok)
-            return toCallToolResult(recordedSources, contract);
-        return toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, comparisonUnknownInput({
+            return server.delivery.toCallToolResult(recordedSources, contract);
+        return server.delivery.toEvidenceToolResult(evidence, contract, recordDerivedEvidence(session, evidence, comparisonUnknownInput({
             left_evidence_id: leftRecord.evidence_id,
             right_evidence_id: rightRecord.evidence_id,
             comparison_evidence_id: evidence.evidence_id,

package/dist/server/registerRecordedCrashTools.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 recorded crash inspection to its named contract and session Evidence owner. */
 export const registerRecordedCrashTools = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_recorded_crash");
     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/registerSessionRecordTools.js

@@ -2,7 +2,6 @@ import { readEvidenceBundle, writeEvidenceBundle, } from "../application/Evidenc
 import { toolContract } from "../contracts/toolContracts.js";
 import { ok } from "../domain/result.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register evidence bundle import and export tools. */
 export const registerEvidenceTools = (registration) => {
     registerExportEvidenceTool(registration);
@@ -10,37 +9,37 @@ export const registerEvidenceTools = (registration) => {
     registerSnapshotEvidenceTool(registration);
 };
 const registerExportEvidenceTool = ({ server, session, exportContract, }) => {
-    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
+    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input, context) => {
         const bundle = bundleForSerialization(session);
-        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite);
+        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite, context.mcpReq.signal);
         return written.ok
-            ? toCallToolResult(ok({
+            ? server.delivery.toCallToolResult(ok({
                 path: written.value.path,
                 bytes: written.value.bytes,
                 records: bundle.records.length,
                 unknowns: bundle.unknowns.length,
             }), exportContract)
-            : toCallToolResult(written, exportContract);
+            : server.delivery.toCallToolResult(written, exportContract);
     });
 };
 const registerSnapshotEvidenceTool = ({ server, session, snapshotContract, }) => {
-    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => toCallToolResult(ok(bundleForSerialization(session)), snapshotContract));
+    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => server.delivery.toCallToolResult(ok(bundleForSerialization(session)), snapshotContract));
 };
 const registerImportEvidenceTool = ({ server, session, importContract, }) => {
     server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
         const path = input.path;
         const loaded = await readEvidenceBundle(path);
         if (!loaded.ok)
-            return toCallToolResult(loaded, importContract);
+            return server.delivery.toCallToolResult(loaded, importContract);
         const retainedUnknownRevisions = new Set(bundleForSerialization(session).unknowns.map((unknown) => unknownRevisionKey(unknown)));
         const imported = session.importEvidenceBundle(loaded.value);
         return imported.ok
-            ? toCallToolResult(ok({
+            ? server.delivery.toCallToolResult(ok({
                 imported: imported.value,
                 unknowns_added: loaded.value.unknowns.filter((unknown) => !retainedUnknownRevisions.has(unknownRevisionKey(unknown))).length,
                 total: bundleForSerialization(session).records.length,
             }), importContract)
-            : toCallToolResult(imported, importContract);
+            : server.delivery.toCallToolResult(imported, importContract);
     });
 };
 const bundleForSerialization = (session) => session.evidenceBundleForSerialization?.() ?? session.exportEvidenceBundle();
@@ -49,15 +48,12 @@ const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.
 const registerListUnknownsTool = ({ server, session, }) => {
     const listContract = toolContract("list_unknowns");
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
-        const filters = input;
         const all = session.listUnknowns({
-            ...(filters.status === undefined ? {} : { status: filters.status }),
-            ...(filters.severity === undefined
-                ? {}
-                : { severity: filters.severity }),
-            ...(filters.domain === undefined ? {} : { domain: filters.domain }),
+            ...(input.status === undefined ? {} : { status: input.status }),
+            ...(input.severity === undefined ? {} : { severity: input.severity }),
+            ...(input.domain === undefined ? {} : { domain: input.domain }),
         });
-        return toCallToolResult(ok({
+        return server.delivery.toCallToolResult(ok({
             items: all,
             total: all.length,
         }), listContract);
@@ -67,19 +63,19 @@ const registerRecordUnknownTool = ({ server, session, }) => {
     const recordContract = toolContract("record_unknown");
     server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
         const result = session.recordUnknown(input);
-        return toCallToolResult(result, recordContract);
+        return server.delivery.toCallToolResult(result, recordContract);
     });
 };
 const registerUpdateUnknownTool = ({ server, session, }) => {
     const updateContract = toolContract("update_unknown");
     server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
         const result = session.updateUnknown(input);
-        return toCallToolResult(result, updateContract);
+        return server.delivery.toCallToolResult(result, updateContract);
     });
 };
 const registerVerifyUnknownTool = ({ server, session, }) => {
     const verifyContract = toolContract("verify_unknown_resolution");
-    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => toCallToolResult(session.verifyUnknownResolution(input.unknown_id), verifyContract));
+    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => server.delivery.toCallToolResult(session.verifyUnknownResolution(input.unknown_id), verifyContract));
 };
 export const registerUnknownTools = (registration) => {
     registerListUnknownsTool(registration);

package/dist/server/registerSessionStatusTool.js

@@ -5,13 +5,12 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { mcpClientMetadata } from "./mcpClientMetadata.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 import { err } from "../domain/result.js";
 /** Register the read-only provider and target status operation. */
 export const registerSessionStatusTool = (options) => {
     const { server, session, contract, startedAt, availabilityPolicy, androidAnalysisAvailability, } = options;
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const { client, clientFeatures, protocolVersion } = mcpClientMetadata(context);
+        const { client, clientFeatures, protocolVersion } = mcpClientMetadata(context, server.server);
         let androidAvailability;
         try {
             androidAvailability = await androidAnalysisAvailability(context.mcpReq.signal);
@@ -19,7 +18,7 @@ export const registerSessionStatusTool = (options) => {
         catch (cause) {
             if (!context.mcpReq.signal.aborted)
                 throw cause;
-            return toCallToolResult(err(new AnalysisCancelledError("binary_session")), contract);
+            return server.delivery.toCallToolResult(err(new AnalysisCancelledError("binary_session")), contract);
         }
         const status = session.status();
         const statusObject = jsonObjectSchema.parse(status);
@@ -43,7 +42,7 @@ export const registerSessionStatusTool = (options) => {
             ...(client === undefined ? {} : { client }),
             ...(protocolVersion === undefined ? {} : { protocolVersion }),
         });
-        return toCallToolResult({
+        return server.delivery.toCallToolResult({
             ok: true,
             value: projectSessionStatus({
                 status: statusObject,

package/dist/server/registerSessionTools.js

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { getNavigationContext, inspectAddressContext, } from "../application/AnalysisContextQueries.js";
 import { readAnalysisSnapshot } from "../application/binary/AnalysisSnapshotFiles.js";
 import { createProcessCaptureEvidence } from "../application/process/ProcessEvidence.js";
@@ -19,7 +18,6 @@ import { registerSessionStatusTool } from "./registerSessionStatusTool.js";
 import { sessionAvailabilityPolicy, } from "./sessionAvailabilityPolicy.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 const recordProcessResidualUnknowns = (session, evidence, residuals) => {
     for (const residual of residuals) {
         const unknown = session.recordUnknown({
@@ -48,7 +46,6 @@ const recordProcessResidualUnknowns = (session, evidence, residuals) => {
 };
 const registerProcessTools = ({ server, session, logger, captureContract, }) => {
     server.registerTool(captureContract.name, toolRegistrationOptions(captureContract), async (input, context) => {
-        const scenario = input;
         const progress = mcpProgressReporter(context);
         await progress.report({
             phase: captureContract.name,
@@ -56,7 +53,7 @@ const registerProcessTools = ({ server, session, logger, captureContract, }) =>
             total: 1,
             message: "started",
         });
-        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(scenario, context.mcpReq.signal));
+        const captured = await logToolExecution(logger, captureContract.name, () => captureProcessScenario(input, context.mcpReq.signal));
         await progress.report({
             phase: captureContract.name,
             completed: 1,
@@ -65,15 +62,15 @@ const registerProcessTools = ({ server, session, logger, captureContract, }) =>
             terminal: true,
         });
         if (!captured.ok)
-            return toCallToolResult(captured, captureContract);
-        const evidence = createProcessCaptureEvidence(scenario, captured.value);
+            return server.delivery.toCallToolResult(captured, captureContract);
+        const evidence = createProcessCaptureEvidence(input, captured.value);
         const recorded = session.recordEvidence(evidence);
         if (!recorded.ok)
-            return toCallToolResult(recorded, captureContract);
+            return server.delivery.toCallToolResult(recorded, captureContract);
         const unknowns = recordProcessResidualUnknowns(session, evidence, captured.value.residual_unknowns);
         if (!unknowns.ok)
-            return toCallToolResult(unknowns, captureContract);
-        return toEvidenceToolResult(evidence, captureContract, recorded);
+            return server.delivery.toCallToolResult(unknowns, captureContract);
+        return server.delivery.toEvidenceToolResult(evidence, captureContract, recorded);
     });
 };
 const registerLifecycleTools = (registration) => {
@@ -95,7 +92,7 @@ const registerOpenLifecycleTool = ({ server, session, logger, openContract, }) =
         if (input.snapshot_path !== undefined) {
             const loaded = await readAnalysisSnapshot(input.snapshot_path);
             if (!loaded.ok)
-                return toCallToolResult(loaded, openContract);
+                return server.delivery.toCallToolResult(loaded, openContract);
             snapshot = loaded.value;
         }
         const opened = await logToolExecution(logger, openContract.name, () => session.open(input.path, {
@@ -107,30 +104,27 @@ const registerOpenLifecycleTool = ({ server, session, logger, openContract, }) =
             ...(snapshot === undefined ? {} : { snapshot }),
         }));
         return opened.ok
-            ? toCallToolResult({
+            ? server.delivery.toCallToolResult({
                 ok: true,
                 value: {
                     path: opened.value.path,
                     format: opened.value.format,
                     kind: opened.value.kind,
-                    loaderArgs: z
-                        .array(z.string())
-                        .parse(session.openCompatibility().loaderArgs ?? []),
                     sha256: opened.value.sha256,
                     architecture: opened.value.architecture ?? null,
                 },
             }, openContract)
-            : toCallToolResult(opened, openContract);
+            : server.delivery.toCallToolResult(opened, openContract);
     });
 };
 const registerContextTools = (server, session) => {
     const navigationContract = toolContract("get_navigation_context");
     const addressContract = toolContract("inspect_address_context");
     server.registerTool(navigationContract.name, toolRegistrationOptions(navigationContract), async (input, context) => {
-        return toCallToolResult(await getNavigationContext(session, input, context.mcpReq.signal), navigationContract);
+        return server.delivery.toCallToolResult(await getNavigationContext(session, input, context.mcpReq.signal), navigationContract);
     });
     server.registerTool(addressContract.name, toolRegistrationOptions(addressContract), async (input, context) => {
-        return toCallToolResult(await inspectAddressContext(session, input, context.mcpReq.signal), addressContract);
+        return server.delivery.toCallToolResult(await inspectAddressContext(session, input, context.mcpReq.signal), addressContract);
     });
 };
 export const registerSessionTools = (server, session, logger, options = {}) => {
@@ -180,6 +174,6 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
 const missingAndroidAvailability = async () => ({
     status: "unavailable",
     code: "not_configured",
-    reason: "Set REA_JADX_MCP_JAR to a caller-supplied jadx-headless-mcp 0.7.1 JAR and provide a full JDK on Linux or macOS.",
+    reason: "Set REA_JADX_MCP_JAR to a caller-supplied jadx-headless-mcp 0.7.1 JAR and provide a full JDK on Linux, macOS, or Windows x64 with its matching bundled native controls.",
     diagnostics: { configured: false },
 });

package/dist/server/registerWebModuleTool.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 module relationship workflow to its exact canonical contract. */
 export const registerWebModuleTool = (server, service, logger, recordEvidence) => {
     const contract = toolContract("trace_web_module_imports");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const result = await logToolExecution(logger, contract.name, () => service.trace(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/registerWebNetworkCaptureTool.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 historical inspection to its named contract and caller-owned Evidence writer. */
 export const registerWebNetworkCaptureTool = (server, service, logger, recordEvidence) => {
     const contract = toolContract("inspect_web_network_capture");
@@ -19,8 +18,8 @@ export const registerWebNetworkCaptureTool = (server, service, logger, recordEvi
     server.registerTool(contract.name, { ...registration, inputSchema }, 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/registerWebRuntimeTools.js

@@ -2,7 +2,6 @@ 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";
 /** Bind distinct runtime operations to named contracts and the session's Evidence owner. */
 export const registerWebRuntimeTools = (server, service, logger, recordEvidence) => {
     const execution = toolContract("observe_web_execution");
@@ -13,15 +12,15 @@ export const registerWebRuntimeTools = (server, service, logger, recordEvidence)
             progress: mcpProgressReporter(context),
         }));
         if (!result.ok)
-            return toCallToolResult(result, execution);
+            return server.delivery.toCallToolResult(result, execution);
         const recorded = recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, execution, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, execution, recorded);
     });
     server.registerTool(listeners.name, toolRegistrationOptions(listeners), async (input, context) => {
         const result = await logToolExecution(logger, listeners.name, () => service.inspect(input, { signal: context.mcpReq.signal }));
         if (!result.ok)
-            return toCallToolResult(result, listeners);
+            return server.delivery.toCallToolResult(result, listeners);
         const recorded = recordEvidence?.(result.value);
-        return toEvidenceToolResult(result.value, listeners, recorded);
+        return server.delivery.toEvidenceToolResult(result.value, listeners, recorded);
     });
 };