rea-agents 6.1.0 → 6.2.0

package/dist/server/EvidenceMcpServer.js

@@ -1,35 +1,37 @@
 import { McpServer, isCallToolResult, isJSONRPCRequest, isJSONRPCNotification, isJSONRPCResultResponse, } from "@modelcontextprotocol/server";
 import { analysisErrorProjectionSchema } from "../contracts/errorSchemas.js";
-import { parseMcpResponseBudget } from "../config/mcpResponseBudget.js";
 import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { toErrorToolResult } from "./toolResult.js";
-import { encodeToolResult, MCP_RESULT_BUDGET_BYTES, } from "./toolResultEncoding.js";
+import { encodeToolResult } from "./toolResultEncoding.js";
 /** Bind oversized MCP error recovery to this server's Evidence ledger. */
 export class EvidenceMcpServer extends McpServer {
     recordEvidence;
-    constructor(info, options, recordEvidence) {
+    delivery;
+    constructor(info, options, recordEvidence, delivery) {
         super(info, options);
         this.recordEvidence = recordEvidence;
+        this.delivery = delivery;
     }
     /** Preserve the SDK transport lifecycle while retaining oversized errors. */
     connect(transport) {
-        return super.connect(new ErrorEvidenceTransport(transport, this.recordEvidence));
+        return super.connect(new ErrorEvidenceTransport(transport, this.recordEvidence, this.delivery));
     }
 }
 class ErrorEvidenceTransport {
     transport;
     recordEvidence;
+    delivery;
     onclose;
     onerror;
     onmessage;
     hasPerRequestStream;
     pendingTools = new Map();
-    constructor(transport, recordEvidence) {
+    constructor(transport, recordEvidence, delivery) {
         this.transport = transport;
         this.recordEvidence = recordEvidence;
+        this.delivery = delivery;
         if (transport.hasPerRequestStream !== undefined)
             this.hasPerRequestStream = transport.hasPerRequestStream;
         transport.onmessage = (message, extra) => {
@@ -83,7 +85,18 @@ class ErrorEvidenceTransport {
             : undefined;
         const tool = id === undefined ? undefined : this.pendingTools.get(id);
         try {
-            await this.transport.send(this.recoverError(message, tool), options);
+            const recovered = this.recoverError(message, tool);
+            if (isJSONRPCResultResponse(recovered) &&
+                isCallToolResult(recovered.result) &&
+                recovered.result.isError === true) {
+                // Keep the complete typed JSON in content. Error projections are not
+                // success outputSchema data; oversized recovery must consume their
+                // private structured carrier before it is removed from the wire.
+                const { structuredContent: _diagnostic, ...result } = recovered.result;
+                await this.transport.send({ ...recovered, result }, options);
+            }
+            else
+                await this.transport.send(recovered, options);
         }
         finally {
             if (!isJSONRPCRequest(message) && id !== undefined)
@@ -97,11 +110,9 @@ class ErrorEvidenceTransport {
             message.result.structuredContent === undefined)
             return message;
         const structured = jsonObjectSchema.parse(message.result.structuredContent);
-        const configured = parseMcpResponseBudget(process.env.REA_MCP_MAX_RESPONSE_BYTES);
-        const budget = configured.ok && configured.value !== undefined
-            ? configured.value - 1024
-            : MCP_RESULT_BUDGET_BYTES;
-        const encoded = encodeToolResult(structured, budget);
+        const budget = this.delivery.resultBudgetBytes;
+        // The delivered error omits structuredContent, so only its text counts.
+        const encoded = encodeToolResult(structured, budget, "text");
         if (encoded.ok)
             return message;
         const operation = tool ?? "mcp_tool_error";
@@ -139,8 +150,8 @@ class ErrorEvidenceTransport {
         }, {
             remediationAction: retained
                 ? "Export the retained original error through export_evidence_bundle to a caller-selected path. The connection remains usable."
-                : "Configure a larger REA_MCP_MAX_RESPONSE_BYTES and matching client receive buffer, then retry. The original error could not be retained by this server.",
+                : "Restart REA with a larger REA_MCP_MAX_RESPONSE_BYTES and matching client receive buffer, then retry. The original error could not be retained by this server.",
         });
-        return { ...message, result: toErrorToolResult(failure) };
+        return { ...message, result: this.delivery.toErrorToolResult(failure) };
     }
 }

package/dist/server/createServer.js

@@ -1,10 +1,14 @@
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { createEvmInterfaceService } from "../composition/evm.js";
 import { registerEvmTools } from "./registerEvmTools.js";
 import { registerRecordedCrashTools } from "./registerRecordedCrashTools.js";
 import { createRecordedCrashService } from "../composition/binaryDiagnostics.js";
+import { registerAnalysisViewTool } from "./registerAnalysisViewTool.js";
 import { registerBinaryDiagnosticsTools } from "./registerBinaryDiagnosticsTools.js";
 import { createBinaryLayoutService } from "../composition/binaryDiagnostics.js";
 import { EvidenceMcpServer } from "./EvidenceMcpServer.js";
+import { createToolResultDelivery, } from "./toolResult.js";
+import { parseMcpResponseBudget } from "../config/mcpResponseBudget.js";
 import { isAbsolute } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { silentLogger } from "../logger.js";
@@ -42,35 +46,27 @@ import { registerSessionTools } from "./registerSessionTools.js";
 import { sessionAvailabilityPolicy } from "./sessionAvailabilityPolicy.js";
 const TARGET_FREE_INSTRUCTIONS = "REA provides reverse-engineering tools for local artifacts, native binaries, managed code, browser pages, and runtimes. Use the tool that directly answers the question; discover targets or inspect inventory only when needed. Tool results include inline Evidence and report their coverage and limitations.";
 const ACTIVE_TARGET_INSTRUCTIONS = "REA analyzes the active reverse-engineering target. Use the analysis tool that answers the question directly. Search or list symbols when discovery is needed; analyze_function provides a function dossier, and focused procedure tools return individual facets.";
-const installSessionToolAvailability = (server, session, options) => {
+const installSessionToolAvailability = (session, options, environment) => {
     if (session === undefined)
         return undefined;
+    const linux = process.platform === "linux";
+    const linuxX64 = linux && process.arch === "x64";
+    const pwntools = linuxX64 && isAbsolute(environment.REA_PWNTOOLS_PYTHON ?? "");
     const policy = sessionAvailabilityPolicy(options.availabilityPolicy, {
         optionalProviderLoadFailures: options.optionalProviderLoadFailures,
         optionalFeatures: {
-            evmInterfaceEnabled: options.evmInterface !== undefined ||
-                (process.platform === "linux" && process.arch === "x64"),
+            evmInterfaceEnabled: options.evmInterface !== undefined || linuxX64,
             webModuleResolutionEnabled: options.webModuleTrace !== undefined ||
-                isAbsolute(process.env.REA_BROWSER_EXECUTABLE ?? ""),
-            recordedCrashEnabled: options.recordedCrash !== undefined ||
-                (process.platform === "linux" &&
-                    process.arch === "x64" &&
-                    isAbsolute(process.env.REA_PWNTOOLS_PYTHON ?? "")),
-            binaryLayoutEnabled: options.binaryLayout !== undefined ||
-                (process.platform === "linux" &&
-                    process.arch === "x64" &&
-                    isAbsolute(process.env.REA_PWNTOOLS_PYTHON ?? "")),
+                isAbsolute(environment.REA_BROWSER_EXECUTABLE ?? ""),
+            recordedCrashEnabled: options.recordedCrash !== undefined || pwntools,
+            binaryLayoutEnabled: options.binaryLayout !== undefined || pwntools,
             firmwareInspectionEnabled: options.firmwareAnalysis !== undefined ||
-                (process.platform === "linux" &&
-                    isAbsolute(process.env.REA_BINWALK_COMMAND ?? "")),
+                (linux && isAbsolute(environment.REA_BINWALK_COMMAND ?? "")),
             firmwareExtractionEnabled: options.firmwareAnalysis !== undefined ||
-                (process.platform === "linux" &&
-                    isAbsolute(process.env.REA_UNBLOB_COMMAND ?? "")),
+                (linux && isAbsolute(environment.REA_UNBLOB_COMMAND ?? "")),
             browserObservationEnabled: options.browserObservation !== undefined,
             javascriptRecoveryEnabled: options.javascriptRecovery !== undefined ||
-                (process.platform === "linux" &&
-                    process.arch === "x64" &&
-                    isAbsolute(process.env.REA_WAKARU_COMMAND ?? "")),
+                (linuxX64 && isAbsolute(environment.REA_WAKARU_COMMAND ?? "")),
             browserScenarioEnabled: options.browserScenarioCapture !== undefined,
             electronObservationEnabled: options.electronObservation !== undefined,
             electronAutomationEnabled: options.electronActiveObservation !== undefined,
@@ -81,7 +77,7 @@ const installSessionToolAvailability = (server, session, options) => {
         policy,
     };
 };
-const createMcpServer = (session) => new EvidenceMcpServer({
+const createMcpServer = (session, delivery) => new EvidenceMcpServer({
     name: PRODUCT_IDENTITY.mcpServerKey,
     version: PRODUCT_IDENTITY.packageVersion,
 }, {
@@ -91,25 +87,29 @@ const createMcpServer = (session) => new EvidenceMcpServer({
         : TARGET_FREE_INSTRUCTIONS,
 }, session === undefined
     ? undefined
-    : (evidence) => session.recordEvidence(evidence));
+    : (evidence) => session.recordEvidence(evidence), delivery);
 /**
  * Construct one MCP server without acquiring subprocess resources.
  * Supplying a session adds target lifecycle tools; omitting it retains the
  * fixed-target seam used by focused tests and embedders.
  */
 export const createServer = (analysis, session, options = {}) => {
+    const environment = snapshotEnvironment(options.environment ?? process.env);
+    const delivery = selectToolResultDelivery(environment, options.delivery);
+    const selectedOptions = { ...options, environment, delivery };
     const startedAt = new Date().toISOString();
     const logger = options.logger ?? silentLogger;
-    const server = createMcpServer(session);
-    const android = options.androidAnalysis ?? createAndroidAnalysisProvider();
-    const availability = installSessionToolAvailability(server, session, options);
+    const server = createMcpServer(session, delivery);
+    const android = options.androidAnalysis ?? createAndroidAnalysisProvider(environment);
+    const availability = installSessionToolAvailability(session, selectedOptions, environment);
     const toolLogger = logger.child({ layer: "server" });
     const { evidenceById, activeTarget, recordEvidence, recordEvidenceWithUnknown, } = createSessionRecorders(server, session);
     const toolContext = {
         server,
         analysis,
         session,
-        options,
+        options: selectedOptions,
+        environment,
         logger: toolLogger,
         evidenceById,
         activeTarget,
@@ -131,21 +131,12 @@ export const createServer = (analysis, session, options = {}) => {
             if (result.status === "rejected")
                 throw result.reason;
     };
-    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence);
-    registerBinaryDiagnosticsTools(server, options.binaryLayout ?? createBinaryLayoutService(), toolLogger, recordEvidence);
-    registerEvmTools(server, options.evmInterface ?? createEvmInterfaceService(), toolLogger, recordEvidence);
-    registerRecordedCrashTools(server, options.recordedCrash ?? createRecordedCrashService(), toolLogger, recordEvidence);
-    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider()), toolLogger, recordEvidence);
+    registerConfiguredAnalysisTools(toolContext, android);
     registerObservationTools(toolContext);
-    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(), toolLogger, recordEvidence);
-    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(), toolLogger, recordEvidence);
-    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence);
-    registerWebNetworkCaptureTool(server, options.webNetworkCapture ?? createWebNetworkCaptureService(), toolLogger, recordEvidence);
-    registerJavaScriptRecoveryTool(server, new JavaScriptRecoveryService(options.javascriptRecovery ?? createJavaScriptRecoveryProvider()), toolLogger, recordEvidence);
     registerGuidedPrompts(server, analysis, session);
     if (session !== undefined) {
         registerSessionTools(server, session, toolLogger, {
-            ...options,
+            ...selectedOptions,
             ...(availability === undefined
                 ? {}
                 : { availabilityPolicy: availability.policy }),
@@ -155,6 +146,28 @@ export const createServer = (analysis, session, options = {}) => {
     }
     return server;
 };
+const selectToolResultDelivery = (environment, selected) => {
+    if (selected !== undefined)
+        return selected;
+    const configured = parseMcpResponseBudget(environment.REA_MCP_MAX_RESPONSE_BYTES);
+    if (!configured.ok)
+        throw configured.error;
+    return createToolResultDelivery(configured.value);
+};
+const registerConfiguredAnalysisTools = ({ server, options, environment, logger: toolLogger, evidenceById, recordEvidence, }, android) => {
+    registerAndroidTools(server, new AndroidAnalysisService(android), toolLogger, recordEvidence);
+    registerBinaryDiagnosticsTools(server, options.binaryLayout ?? createBinaryLayoutService(environment), toolLogger, recordEvidence);
+    registerAnalysisViewTool(server, toolLogger, evidenceById, recordEvidence);
+    registerEvmTools(server, options.evmInterface ?? createEvmInterfaceService(environment), toolLogger, recordEvidence);
+    registerRecordedCrashTools(server, options.recordedCrash ?? createRecordedCrashService(environment), toolLogger, recordEvidence);
+    registerFirmwareTools(server, new FirmwareAnalysisService(options.firmwareAnalysis ?? createFirmwareAnalysisProvider(environment)), toolLogger, recordEvidence);
+    registerWebModuleTool(server, options.webModuleTrace ?? createWebModuleTraceService(environment), toolLogger, recordEvidence);
+    registerWebSourceLocationTool(server, options.webSourceLocation ?? createWebSourceLocationService(environment), toolLogger, recordEvidence);
+    registerWebRuntimeTools(server, options.webRuntime ?? createWebRuntimeService(), toolLogger, recordEvidence);
+    registerWebNetworkCaptureTool(server, options.webNetworkCapture ?? createWebNetworkCaptureService(environment), toolLogger, recordEvidence);
+    registerJavaScriptRecoveryTool(server, new JavaScriptRecoveryService(options.javascriptRecovery ??
+        createJavaScriptRecoveryProvider(environment)), toolLogger, recordEvidence);
+};
 const createSessionRecorders = (server, session) => ({
     evidenceById: session === undefined
         ? undefined

package/dist/server/mcpClientMetadata.js

@@ -1,12 +1,19 @@
 import { CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, PROTOCOL_VERSION_META_KEY, } from "@modelcontextprotocol/server";
-/** Client metadata bound to the current SDK request rather than server-global state. */
-export const mcpClientMetadata = (context) => {
+/**
+ * Client metadata for the current request. A 2026-era request carries it in
+ * its per-request envelope; a 2025-era connection sends no envelope, so its
+ * `initialize` handshake supplies the values.
+ */
+export const mcpClientMetadata = (context, connection) => {
     const envelope = context.mcpReq.envelope;
-    const client = implementation(mcpEnvelopeValue(envelope, CLIENT_INFO_META_KEY));
-    const protocolVersion = mcpEnvelopeValue(envelope, PROTOCOL_VERSION_META_KEY);
+    // The SDK deprecates these accessors only in favor of the envelope, which
+    // 2025-era requests do not carry; they still return initialize values.
+    const value = (key, initialized) => envelope === undefined ? initialized() : mcpEnvelopeValue(envelope, key);
+    const client = implementation(value(CLIENT_INFO_META_KEY, () => connection.getClientVersion()));
+    const protocolVersion = value(PROTOCOL_VERSION_META_KEY, () => connection.getNegotiatedProtocolVersion());
     return {
         ...(client === undefined ? {} : { client }),
-        clientFeatures: capabilityFeatures(mcpEnvelopeValue(envelope, CLIENT_CAPABILITIES_META_KEY)),
+        clientFeatures: capabilityFeatures(value(CLIENT_CAPABILITIES_META_KEY, () => connection.getClientCapabilities())),
         ...(typeof protocolVersion === "string" ? { protocolVersion } : {}),
     };
 };

package/dist/server/promptCompletion.js

@@ -2,13 +2,10 @@ import { z } from "zod";
 import { uniqueSorted } from "../domain/canonicalOrdering.js";
 import { artifactInventoryResultSchema } from "../domain/artifactGraph.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
-import { parseProcessCapture } from "../domain/process/processCapture.js";
+import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 const documentListSchema = z.array(z.string().min(1));
 const providerStatusSchema = z.object({
-    providers: z.array(z.object({ id: z.string().min(1) })),
-    analysis_provider_candidates: z
-        .array(z.object({ provider: z.object({ id: z.string().min(1) }) }))
-        .optional(),
+    analysis_provider_candidates: z.array(z.object({ provider: z.object({ id: z.string().min(1) }) })),
 });
 /** Build live completion over the active provider and session ledger. */
 export const createPromptCompletionSource = (analysis, session) => ({
@@ -74,9 +71,7 @@ const providerCandidates = (session) => {
     const parsed = providerStatusSchema.safeParse(session.status());
     if (!parsed.success)
         return [];
-    const candidates = (parsed.data.analysis_provider_candidates?.length ?? 0) > 0
-        ? (parsed.data.analysis_provider_candidates?.map(({ provider }) => provider.id) ?? [])
-        : parsed.data.providers.map(({ id }) => id);
+    const candidates = parsed.data.analysis_provider_candidates.map(({ provider }) => provider.id);
     return ["auto", ...candidates];
 };
 const evidenceCandidates = (kind, session) => {

package/dist/server/registerAnalysisViewTool.js

@@ -0,0 +1,15 @@
+import { inspectAnalysisView } from "../application/analysisView/AnalysisViewService.js";
+import { toolContract } from "../contracts/toolContracts.js";
+import { logToolExecution } from "./toolLogging.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+/** Bind selected-view projection to its named contract and session Evidence owner. */
+export const registerAnalysisViewTool = (server, logger, evidenceById, recordEvidence) => {
+    const contract = toolContract("inspect_analysis_view");
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
+        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(inspectAnalysisView(input, evidenceById)));
+        if (!result.ok)
+            return server.delivery.toCallToolResult(result, contract);
+        const recorded = recordEvidence?.(result.value);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
+    });
+};

package/dist/server/registerAndroidTools.js

@@ -2,7 +2,6 @@ import { AndroidAnalysisService } from "../application/android/AndroidAnalysisSe
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult, toEvidenceToolResult } from "./toolResult.js";
 /** Bind Android handlers to their exact named contracts through shared workflows. */
 export const registerAndroidTools = (server, service, logger, recordEvidence) => {
     const handler = (contract) => {
@@ -10,9 +9,9 @@ export const registerAndroidTools = (server, service, logger, recordEvidence) =>
         return async (input, context) => {
             const result = await logToolExecution(logger, name, () => service.execute(name, 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);
         };
     };
     const packageContract = toolContract("inspect_android_package");

package/dist/server/registerApplicationTools/compareExportShapes.js

@@ -5,7 +5,6 @@ import { applicationToolContract } from "../../contracts/applicationToolContract
 import { javaScriptExportShapeComparisonResultSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_javascript_export_shapes");
 /** Register the execution-free exact JavaScript export-shape comparison. */
@@ -13,19 +12,19 @@ export const registerCompareJavaScriptExportShapesTool = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const resolved = resolvePairedEvidenceRequest(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(compareJavaScriptExportShapesEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = recordSessionEvidenceSources(options.recordEvidence, [
             parsed.left,
             parsed.right,
         ]);
         if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
+            return server.delivery.toCallToolResult(recorded, contract);
         const comparison = javaScriptExportShapeComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, contract, result.value, unknown ? "javascript-export-shape" : undefined);
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value, unknown ? "javascript-export-shape" : undefined);
     });
 };

package/dist/server/registerApplicationTools/compareSourceToBundle.js

@@ -5,7 +5,6 @@ import { applicationToolContract } from "../../contracts/applicationToolContract
 import { sourceToBundleComparisonResultSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const contract = applicationToolContract("compare_source_to_bundle");
 /** Register conservative historical-source to bundle comparison. */
@@ -13,18 +12,18 @@ export const registerCompareSourceToBundleTool = (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(compareSourceToBundleEvidenceValidated(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 server.delivery.toCallToolResult(recorded, contract);
         const comparison = sourceToBundleComparisonResultSchema.parse(result.value.normalized_result);
-        return recordResult(options, contract, result.value, comparison.summary.unknown > 0
+        return recordResult({ ...options, delivery: server.delivery }, contract, result.value, comparison.summary.unknown > 0
             ? "source-to-bundle-comparison"
             : undefined);
     });

package/dist/server/registerApplicationTools/compareVersions.js

@@ -5,7 +5,6 @@ import { applicationToolContract } from "../../contracts/applicationToolContract
 import { applicationVersionComparisonResultSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 import { recordResult } from "./helpers.js";
 const compareContract = applicationToolContract("compare_application_versions");
 /** Register the provider-neutral JavaScript version comparison tool. */
@@ -13,11 +12,11 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
         const resolved = resolvePairedEvidenceRequest(input, options.evidenceById);
         if (!resolved.ok)
-            return toCallToolResult(resolved, compareContract);
+            return server.delivery.toCallToolResult(resolved, compareContract);
         const parsed = resolved.value;
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareApplicationVersionsEvidenceValidated(parsed)));
         if (!result.ok)
-            return toCallToolResult(result, compareContract);
+            return server.delivery.toCallToolResult(result, compareContract);
         const sources = [
             parsed.left,
             parsed.right,
@@ -26,9 +25,9 @@ export const registerCompareApplicationVersionsTool = (server, options) => {
         ];
         const recorded = recordSessionEvidenceSources(options.recordEvidence, sources);
         if (!recorded.ok)
-            return toCallToolResult(recorded, compareContract);
+            return server.delivery.toCallToolResult(recorded, compareContract);
         const comparison = applicationVersionComparisonResultSchema.parse(result.value.normalized_result);
         const unknown = comparison.summary.unknown > 0;
-        return recordResult(options, compareContract, result.value, unknown ? "application-version-comparison" : undefined);
+        return recordResult({ ...options, delivery: server.delivery }, compareContract, result.value, unknown ? "application-version-comparison" : undefined);
     });
 };

package/dist/server/registerApplicationTools/coverage.js

@@ -2,12 +2,11 @@ import { evaluateReconstructionCoverage } from "../../application/Reconstruction
 import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
 const contract = applicationToolContract("evaluate_reconstruction_coverage");
 /** Register the inline fail-closed reconstruction coverage evaluator. */
 export const registerCoverageTools = (server, options) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
         const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(evaluateReconstructionCoverage(input)));
-        return toCallToolResult(result, contract);
+        return server.delivery.toCallToolResult(result, contract);
     });
 };

package/dist/server/registerApplicationTools/helpers.js

@@ -1,10 +1,9 @@
 import { APPLICATION_TOOL_CONTRACTS } from "../../contracts/applicationToolContracts.js";
-import { toEvidenceToolResult } from "../toolResult.js";
 export const recordResult = (options, contract, evidence, unknownKind) => {
     const recorded = unknownKind === undefined
         ? options.recordEvidence?.(evidence)
         : options.recordEvidenceWithUnknown?.(evidence, unknownRegistration(evidence, unknownKind));
-    return toEvidenceToolResult(evidence, contract, recorded);
+    return options.delivery.toEvidenceToolResult(evidence, contract, recorded);
 };
 const unknownRegistration = (evidence, kind) => ({
     question: kind === "application-version-comparison"

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) => {