rea-agents 6.0.0 → 6.2.0

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,55 +9,51 @@ export const registerEvidenceTools = (registration) => {
     registerSnapshotEvidenceTool(registration);
 };
 const registerExportEvidenceTool = ({ server, session, exportContract, }) => {
-    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
-        const bundle = session.exportEvidenceBundle();
-        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite);
+    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input, context) => {
+        const bundle = bundleForSerialization(session);
+        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(session.exportEvidenceBundle()), 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);
-        const retainedUnknownRevisions = new Set(session
-            .exportEvidenceBundle()
-            .unknowns.map((unknown) => unknownRevisionKey(unknown)));
+            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: session.exportEvidenceBundle().records.length,
+                total: bundleForSerialization(session).records.length,
             }), importContract)
-            : toCallToolResult(imported, importContract);
+            : server.delivery.toCallToolResult(imported, importContract);
     });
 };
+const bundleForSerialization = (session) => session.evidenceBundleForSerialization?.() ?? session.exportEvidenceBundle();
 const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
 /** Register residual-unknown query and mutation tools. */
 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);
@@ -68,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

@@ -1,18 +1,31 @@
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
 import { toolContract } from "../contracts/toolContracts.js";
 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 } = options;
-    server.registerTool(contract.name, toolRegistrationOptions(contract), (input, context) => {
-        const { client, clientFeatures, protocolVersion } = mcpClientMetadata(context);
+    const { server, session, contract, startedAt, availabilityPolicy, androidAnalysisAvailability, } = options;
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const { client, clientFeatures, protocolVersion } = mcpClientMetadata(context, server.server);
+        let androidAvailability;
+        try {
+            androidAvailability = await androidAnalysisAvailability(context.mcpReq.signal);
+        }
+        catch (cause) {
+            if (!context.mcpReq.signal.aborted)
+                throw cause;
+            return server.delivery.toCallToolResult(err(new AnalysisCancelledError("binary_session")), contract);
+        }
         const status = session.status();
         const statusObject = jsonObjectSchema.parse(status);
-        const toolAvailability = buildCapabilityInventory(status, availabilityPolicy(), clientFeatures);
+        const toolAvailability = buildCapabilityInventory(status, {
+            ...availabilityPolicy(),
+            androidAnalysisAvailability: androidAvailability,
+        }, clientFeatures);
         const serverIdentity = createServerIdentity({
             startedAt,
             expected: {
@@ -29,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 } 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,19 +62,19 @@ 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 toCallToolResult(ok(evidence), captureContract);
+            return server.delivery.toCallToolResult(unknowns, captureContract);
+        return server.delivery.toEvidenceToolResult(evidence, captureContract, recorded);
     });
 };
 const registerLifecycleTools = (registration) => {
-    const { server, session, statusContract, startedAt, availabilityPolicy } = registration;
+    const { server, session, statusContract, startedAt, availabilityPolicy, androidAnalysisAvailability, } = registration;
     registerOpenLifecycleTool(registration);
     registerCloseLifecycleTool(registration);
     registerSessionStatusTool({
@@ -86,6 +83,7 @@ const registerLifecycleTools = (registration) => {
         contract: statusContract,
         startedAt,
         availabilityPolicy,
+        androidAnalysisAvailability,
     });
 };
 const registerOpenLifecycleTool = ({ server, session, logger, openContract, }) => {
@@ -94,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, {
@@ -106,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 = {}) => {
@@ -153,6 +148,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
         statusContract,
         startedAt: options.startedAt ?? new Date().toISOString(),
         availabilityPolicy: sessionAvailabilityPolicy(options.availabilityPolicy, {}),
+        androidAnalysisAvailability: options.androidAnalysisAvailability ?? missingAndroidAvailability,
     });
     registerEvidenceTools({
         server,
@@ -175,3 +171,9 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
     registerUnknownTools({ server, session });
     registerContextTools(server, session);
 };
+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, macOS, or Windows x64 with its matching bundled native controls.",
+    diagnostics: { configured: false },
+});

package/dist/server/registerWebModuleTool.js

@@ -1,17 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } 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 recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        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 } 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,10 +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 recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        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 } 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,19 +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 recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, execution)
-            : toCallToolResult(result, execution);
+        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 recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, listeners)
-            : toCallToolResult(result, listeners);
+        return server.delivery.toEvidenceToolResult(result.value, listeners, recorded);
     });
 };

package/dist/server/registerWebScriptTool.js

@@ -2,17 +2,14 @@ import { exportWebScriptsValidated } from "../application/WebScriptExportService
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Register local script export without requiring a live browser provider. */
 export const registerWebScriptTool = (server, options) => {
     const contract = toolContract("export_web_scripts");
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
         const result = await logToolExecution(options.logger, contract.name, () => exportWebScriptsValidated(input, { signal: context.mcpReq.signal }));
         if (!result.ok)
-            return toCallToolResult(result, contract);
+            return server.delivery.toCallToolResult(result, contract);
         const recorded = options.recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/registerWebSourceLocationTool.js

@@ -1,17 +1,14 @@
 import { toolContract } from "../contracts/toolContracts.js";
 import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { toCallToolResult } from "./toolResult.js";
 /** Bind source point tracing to its exact named contract and session Evidence owner. */
 export const registerWebSourceLocationTool = (server, service, logger, recordEvidence) => {
     const contract = toolContract("trace_web_source_location");
     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 recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, contract)
-            : toCallToolResult(result, contract);
+        return server.delivery.toEvidenceToolResult(result.value, contract, recorded);
     });
 };

package/dist/server/runDerivedOperation.js

@@ -1,5 +1,8 @@
 import { setImmediate } from "node:timers/promises";
+import { z } from "zod";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { AnalysisCancelledError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
+import { describeValidationFailure } from "../domain/evidenceBundle.js";
 import { err, ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
 /** Run synchronous derived work with transport yields and a publication guard. */
@@ -19,9 +22,18 @@ export const runDerivedOperation = async (context, operation, compute) => {
         value = compute();
     }
     catch (cause) {
-        return err(cause instanceof AnalysisCancelledError
-            ? cause
-            : new AnalysisInputError(operation, { cause }));
+        // Typed causes already name the failed constraint; keep their issues.
+        if (cause instanceof AnalysisError)
+            return err(cause);
+        return err(new AnalysisInputError(operation, { cause }, cause instanceof TypeError || cause instanceof z.ZodError
+            ? [
+                {
+                    path: [],
+                    reason: "invalid_value",
+                    message: describeValidationFailure(cause),
+                },
+            ]
+            : []));
     }
     await progress.report({
         phase: "compute",

package/dist/server/sessionAvailabilityPolicy.js

@@ -9,7 +9,6 @@ export const sessionAvailabilityPolicy = (configured, defaults) => {
             binaryLayoutEnabled: defaults.optionalFeatures?.binaryLayoutEnabled ?? false,
             firmwareInspectionEnabled: defaults.optionalFeatures?.firmwareInspectionEnabled ?? false,
             firmwareExtractionEnabled: defaults.optionalFeatures?.firmwareExtractionEnabled ?? false,
-            androidAnalysisEnabled: defaults.optionalFeatures?.androidAnalysisEnabled ?? false,
             javascriptRecoveryEnabled: defaults.optionalFeatures?.javascriptRecoveryEnabled ?? false,
             webModuleResolutionEnabled: defaults.optionalFeatures?.webModuleResolutionEnabled ?? false,
             browserObservationEnabled: defaults.optionalFeatures?.browserObservationEnabled ?? false,

package/dist/server/toolRegistrationOptions.js

@@ -1,9 +1,9 @@
-import { toolInputSchemaWithMetadata } from "../contracts/toolSchemaMetadata.js";
+import { toolInputSchemaWithMetadata, toolOutputSchemaWithMetadata, } from "../contracts/toolSchemaMetadata.js";
 /** Project the canonical Zod contracts directly into SDK registration. */
 export const toolRegistrationOptions = (contract) => ({
     title: contract.title,
     description: contract.description,
     inputSchema: toolInputSchemaWithMetadata(contract),
-    outputSchema: contract.outputSchema,
+    outputSchema: toolOutputSchemaWithMetadata(contract),
     annotations: contract.annotations,
 });

package/dist/server/toolResult.js

@@ -1,53 +1,77 @@
+import { STDIO_DEFAULT_MAX_BUFFER_SIZE } from "@modelcontextprotocol/server";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import {} from "../domain/analysisErrorBase.js";
-/**
- * Serialize an application result as MCP text and structured content.
- * Shared error projection preserves actionable local diagnostics while omitting
- * raw cause objects; explicitly retained bounded command output stays visible.
- */
-export const toCallToolResult = (result, contract) => result.ok ? successResult(result.value, contract) : errorResult(result.error);
-const errorResult = (error) => {
-    const projected = projectAnalysisError(error);
-    const structuredContent = { error: projected };
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(structuredContent),
-            },
-        ],
-        structuredContent,
-        isError: true,
-    };
-};
-const successResult = (value, contract) => {
-    const candidate = projectEvidence(value) ??
-        (contract.kind === "session" ? { result: value } : value);
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(candidate),
-            },
-        ],
-        structuredContent: candidate,
-    };
-};
-const projectEvidence = (value) => {
-    if (typeof value !== "object" ||
-        value === null ||
-        Array.isArray(value) ||
-        typeof value.evidence_id !== "string" ||
-        !/^ev_[a-f0-9]{64}$/u.test(value.evidence_id) ||
-        !("normalized_result" in value))
-        return undefined;
-    const normalizedResult = value.normalized_result;
-    const evidenceId = value.evidence_id;
-    if (normalizedResult === undefined || typeof evidenceId !== "string")
-        return undefined;
-    return {
-        result: normalizedResult,
-        evidence_id: evidenceId,
-        evidence: value,
-    };
-};
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { encodeToolResult, MCP_RESULT_STRING_LIMIT, } from "./toolResultEncoding.js";
+/** Create one delivery policy from the already selected, parsed response budget. */
+export const createToolResultDelivery = (maximumResponseBytes) => new ToolResultDelivery(maximumResponseBytes ?? STDIO_DEFAULT_MAX_BUFFER_SIZE);
+/** Immutable encoding and recovery policy shared by one MCP server. */
+export class ToolResultDelivery {
+    resultBudgetBytes;
+    constructor(maximumResponseBytes) {
+        this.resultBudgetBytes = maximumResponseBytes - 1024;
+        Object.freeze(this);
+    }
+    /** Serialize a plain application result or its actionable error. */
+    toCallToolResult(result, contract) {
+        return result.ok
+            ? this.successResult(contract.kind === "session" ? { result: result.value } : result.value, contract)
+            : this.toErrorToolResult(result.error);
+    }
+    /** Deliver Evidence using the producer's explicit recording acknowledgment. */
+    toEvidenceToolResult(evidence, contract, recorded) {
+        return recorded !== undefined && !recorded.ok
+            ? this.toErrorToolResult(recorded.error)
+            : this.successResult(evidence, contract, {
+                evidence_id: evidence.evidence_id,
+                ...(recorded === undefined
+                    ? {}
+                    : {
+                        evidence_reference: {
+                            kind: "retained-evidence",
+                            evidence_id: evidence.evidence_id,
+                        },
+                    }),
+            });
+    }
+    /** Project an error without allocating oversized repeated MCP text. */
+    toErrorToolResult(error) {
+        const structuredContent = { error: projectAnalysisError(error) };
+        // Errors reach the wire as text only; the structured copy is a private
+        // carrier the transport removes after its own budget check.
+        const encoded = encodeToolResult(structuredContent, this.resultBudgetBytes, "text");
+        // The transport retains an oversized projected error before replacing it
+        // with a recoverable delivery constraint, using this same budget.
+        return {
+            content: encoded.ok ? [{ type: "text", text: encoded.text }] : [],
+            structuredContent,
+            isError: true,
+        };
+    }
+    successResult(value, contract, recovery = {}) {
+        const encoded = encodeToolResult(value, this.resultBudgetBytes);
+        if (encoded.ok)
+            return {
+                content: [{ type: "text", text: encoded.text }],
+                structuredContent: value,
+            };
+        const retainedEvidence = recovery.evidence_reference !== undefined;
+        const recoveryAdvice = retainedEvidence
+            ? "Export retained evidence to consume the complete analysis, or use complete CLI JSON output."
+            : encoded.constraint === "string-length"
+                ? "Use complete CLI JSON output to consume the analysis."
+                : "Use a larger MCP response budget with a matching client receive buffer, or use complete CLI JSON output to consume the analysis.";
+        return this.toErrorToolResult(new AnalysisResourceConstraintError(contract.name, "transport", encoded.constraint === "string-length"
+            ? `The operation completed, but its complete MCP response exceeds Node's single-string representation limit. ${recoveryAdvice}`
+            : `The operation completed, but its complete MCP response exceeds the stdio response budget. The analysis result was not truncated. ${recoveryAdvice}`, {
+            boundary: "mcp-response",
+            default_receive_buffer_bytes: STDIO_DEFAULT_MAX_BUFFER_SIZE,
+            result_budget_bytes: this.resultBudgetBytes,
+            max_string_code_units: MCP_RESULT_STRING_LIMIT,
+            response_bytes_at_least: encoded.bytesAtLeast,
+            response_code_units_at_least: encoded.codeUnitsAtLeast,
+            constraint: encoded.constraint,
+            ...recovery,
+        }));
+    }
+}

package/dist/server/toolResultEncoding.js

@@ -0,0 +1,34 @@
+import { constants as bufferConstants } from "node:buffer";
+import { bufferedJsonParts, jsonParts } from "../domain/jsonSerialization.js";
+export const MCP_RESULT_STRING_LIMIT = bufferConstants.MAX_STRING_LENGTH - 1024;
+const RESULT_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({
+    content: [{ type: "text", text: "" }],
+    structuredContent: null,
+})) - 4;
+const TEXT_RESULT_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ content: [{ type: "text", text: "" }] }));
+/** Account for the delivered JSON representations before allocating the complete text. */
+export const encodeToolResult = (value, budgetBytes, representations = "structured-and-text") => {
+    const structured = representations === "structured-and-text";
+    const parts = [];
+    let bytes = structured ? RESULT_ENVELOPE_BYTES : TEXT_RESULT_ENVELOPE_BYTES;
+    let codeUnits = bytes;
+    for (const part of bufferedJsonParts(jsonParts(value))) {
+        const escapedPart = JSON.stringify(part);
+        bytes +=
+            (structured ? Buffer.byteLength(part) : 0) +
+                Buffer.byteLength(escapedPart) -
+                2;
+        codeUnits += (structured ? part.length : 0) + escapedPart.length - 2;
+        if (bytes > budgetBytes || codeUnits > MCP_RESULT_STRING_LIMIT)
+            return {
+                ok: false,
+                bytesAtLeast: bytes,
+                codeUnitsAtLeast: codeUnits,
+                constraint: codeUnits > MCP_RESULT_STRING_LIMIT
+                    ? "string-length"
+                    : "receive-buffer",
+            };
+        parts.push(part);
+    }
+    return { ok: true, text: parts.join(""), bytes };
+};

package/dist/windows/WindowsNativeLoader.js

@@ -34,6 +34,7 @@ const inspectionSchema = z.strictObject({
     privateDacl: z.literal(true),
     atomicJobAssignment: z.literal(true),
     killOnOwnerClose: z.literal(true),
+    protocolStdin: z.boolean().optional(),
 });
 const bindingSchema = z.strictObject({
     call: z.custom((value) => typeof value === "function"),