rea-agents 3.1.0 → 3.2.1

package/dist/server/registerApplicationTools/readiness.js

@@ -1,50 +0,0 @@
-import { evaluateReconstructionReadinessValidated, resolveReconstructionReadinessRequest, } from "../../application/ReconstructionReadinessService.js";
-import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionReadinessReportSchema } from "../../domain/reconstructionReadinessSchemas.js";
-import { logToolExecution } from "../toolLogging.js";
-import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { toCallToolResult } from "../toolResult.js";
-import { recordSources } from "./helpers.js";
-const contract = applicationToolContract("evaluate_reconstruction_readiness");
-/** Register deterministic public-contract reconstruction conformance. */
-export const registerReconstructionReadinessTool = (server, options) => {
-    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const resolved = resolveReconstructionReadinessRequest(input);
-        if (!resolved.ok)
-            return toCallToolResult(resolved, contract);
-        const result = await logToolExecution(options.logger, contract.name, () => Promise.resolve(evaluateReconstructionReadinessValidated(resolved.value)));
-        if (!result.ok)
-            return toCallToolResult(result, contract);
-        const recorded = recordSources(options.recordEvidence, resolved.value.evidence_bundle.records);
-        if (!recorded.ok)
-            return toCallToolResult(recorded, contract);
-        const recordedResult = options.recordEvidence?.(result.value);
-        if (recordedResult !== undefined && !recordedResult.ok)
-            return toCallToolResult(recordedResult, contract);
-        const report = reconstructionReadinessReportSchema.parse(result.value.normalized_result);
-        const reportUri = `rea://evidence/${result.value.evidence_id}/reconstruction-readiness-report`;
-        const projection = {
-            schema: report.schema,
-            schema_version: report.schema_version,
-            report_id: report.report_id,
-            source_digest: report.source_digest,
-            report_digest: report.report_digest,
-            status: report.status,
-            summary: report.summary,
-            metrics: report.metrics,
-            report_resource_uri: reportUri,
-        };
-        return toCallToolResult({ ok: true, value: result.value }, contract, {
-            evidenceResourcesAvailable: recordedResult !== undefined,
-            evidenceResultProjection: projection,
-            evidenceTextProjection: projection,
-            resourceLinks: [
-                {
-                    uri: reportUri,
-                    name: report.report_id,
-                    description: "Full deterministic reconstruction readiness report",
-                },
-            ],
-        });
-    });
-};

package/dist/server/registerEvidenceResources.js

@@ -1,315 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { registerJavaScriptApplicationGraphResource } from "./registerJavaScriptApplicationGraphResource.js";
-import { registerReconstructionObligationLedgerResource } from "./registerReconstructionObligationLedgerResource.js";
-import { registerReconstructionReadinessResource } from "./registerReconstructionReadinessResource.js";
-/** Expose immutable session-owned Evidence v2 records as MCP resources. */
-export const registerEvidenceResources = (server, session) => {
-    registerReconstructionCoverageResource(server, session);
-    registerInvestigationWorkspaceResource(server, session);
-    registerSessionEvidenceResource(server, session);
-    registerEvidenceBundleResource(server, session);
-    registerAnalysisSnapshotResource(server, session);
-    registerArtifactPageResource(server, session);
-    registerFunctionDossierResource(server, session);
-    registerEvidenceSectionResource(server, session);
-    registerReconstructionObligationLedgerResource(server, session);
-    registerReconstructionReadinessResource(server, session);
-    registerJavaScriptApplicationGraphResource(server, session);
-    registerResidualUnknownResource(server, session);
-    session.onAnalysisSnapshotChanged?.(() => {
-        void server.server
-            .sendResourceUpdated({ uri: "rea://snapshot/current" })
-            .catch(() => undefined);
-    });
-};
-const registerReconstructionCoverageResource = (server, session) => {
-    server.registerResource("reconstruction-coverage-revision", new ResourceTemplate("rea://reconstruction-coverage/{workspaceId}/revision/{revision}", {
-        list: undefined,
-    }), {
-        title: "Reconstruction coverage revision",
-        description: "Canonical CAS-linked surfaces, owners, claims, verifiers, evidence, and completion boundaries.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const workspaceId = stringVariable(variables.workspaceId, uri.href);
-        const revisionText = stringVariable(variables.revision, uri.href);
-        if (!/^\d+$/u.test(revisionText))
-            throw new ResourceNotFoundError(uri.href);
-        const workspace = session.reconstructionCoverageWorkspace(workspaceId, Number(revisionText));
-        if (workspace === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, workspace);
-    });
-};
-const registerInvestigationWorkspaceResource = (server, session) => {
-    server.registerResource("investigation-workspace-revision", new ResourceTemplate("rea://workspace/{workspaceId}/revision/{revision}", {
-        list: undefined,
-    }), {
-        title: "Investigation workspace revision",
-        description: "Immutable session-retained workspace with CAS linkage.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const workspaceId = stringVariable(variables.workspaceId, uri.href);
-        const revisionText = stringVariable(variables.revision, uri.href);
-        if (!/^\d+$/u.test(revisionText))
-            throw new ResourceNotFoundError(uri.href);
-        const workspace = session.investigationWorkspace(workspaceId, Number(revisionText));
-        if (workspace === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, workspace);
-    });
-};
-const registerSessionEvidenceResource = (server, session) => {
-    server.registerResource("session-evidence", new ResourceTemplate("rea://evidence/{evidenceId}", {
-        list: undefined,
-    }), {
-        title: "Session evidence",
-        description: "Immutable Evidence v2 records owned by this REA session.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = variables.evidenceId;
-        if (typeof evidenceId !== "string")
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify(evidence, null, 2),
-                },
-            ],
-        };
-    });
-};
-const registerEvidenceBundleResource = (server, session) => {
-    server.registerResource("evidence-bundle", new ResourceTemplate("rea://evidence-bundle/{bundleDigest}", {
-        list: undefined,
-    }), {
-        title: "Evidence bundle",
-        description: "Immutable session-retained canonical Evidence v2 bundle.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const digest = stringVariable(variables.bundleDigest, uri.href);
-        if (!/^[a-f0-9]{64}$/u.test(digest))
-            throw new ResourceNotFoundError(uri.href);
-        const text = session.retainedEvidenceBundle(digest);
-        if (text === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text,
-                },
-            ],
-        };
-    });
-};
-const registerAnalysisSnapshotResource = (server, session) => {
-    server.registerResource("analysis-snapshot", "rea://snapshot/current", {
-        title: "Analysis snapshot",
-        description: "Mutable provider-neutral analysis snapshot for the current native target.",
-        mimeType: "application/json",
-    }, (uri) => {
-        const snapshot = session.exportAnalysisSnapshot();
-        if (!snapshot.ok)
-            return jsonResource(uri.href, {
-                state: "unavailable",
-                reason: snapshot.error.message,
-                remediation: "Open a native target with a concrete analysis profile. After metadata mutation, call open_binary again for the current target to begin a fresh cache.",
-            });
-        return jsonResource(uri.href, {
-            state: "available",
-            target: snapshot.value.target,
-            profile: snapshot.value.binding,
-            content_digest: contentDigest(snapshot.value),
-            entry_count: snapshot.value.entries.length,
-            snapshot: snapshot.value,
-        });
-    });
-};
-const registerArtifactPageResource = (server, session) => {
-    server.registerResource("artifact-page", new ResourceTemplate("rea://artifact/{manifestId}/{collection}", {
-        list: undefined,
-        complete: {
-            collection: (prefix) => ["nodes", "occurrences", "edges"].filter((value) => value.startsWith(prefix)),
-        },
-    }), {
-        title: "Artifact graph page",
-        description: "Deterministically paged artifact graph collection.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const manifestId = stringVariable(variables.manifestId, uri.href);
-        const collection = stringVariable(variables.collection, uri.href);
-        if (!ARTIFACT_COLLECTIONS.has(collection))
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session
-            .exportEvidenceBundle()
-            .records.find((record) => artifactManifestId(record.normalized_result) === manifestId);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        const result = objectValue(evidence.normalized_result);
-        const page = result?.[collection];
-        if (page === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, {
-            evidence_id: evidence.evidence_id,
-            manifest_id: manifestId,
-            collection,
-            page,
-            provider: evidence.provider,
-            limitations: evidence.limitations,
-        });
-    });
-};
-const registerFunctionDossierResource = (server, session) => {
-    server.registerResource("function-dossier", new ResourceTemplate("rea://function/{targetSha256}/{address}", {
-        list: undefined,
-    }), {
-        title: "Function dossier",
-        description: "Session-owned analyze_function dossier with provenance.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const targetSha256 = stringVariable(variables.targetSha256, uri.href);
-        const address = stringVariable(variables.address, uri.href);
-        const evidence = session
-            .exportEvidenceBundle()
-            .records.find((record) => record.operation === "analyze_function" &&
-            record.subject?.digest.sha256 === targetSha256 &&
-            functionAddress(record.normalized_result) === address);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, evidence);
-    });
-};
-const registerEvidenceSectionResource = (server, session) => {
-    server.registerResource("evidence-section", new ResourceTemplate("rea://evidence/{evidenceId}/section/{section}", {
-        list: undefined,
-        complete: {
-            section: (prefix) => EVIDENCE_SECTIONS.filter((section) => section.startsWith(prefix)),
-        },
-    }), {
-        title: "Evidence section",
-        description: "One independently useful bounded section of session Evidence v2.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = stringVariable(variables.evidenceId, uri.href);
-        const section = stringVariable(variables.section, uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        const value = evidenceSection(evidence.normalized_result, section);
-        if (value === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, {
-            evidence_id: evidence.evidence_id,
-            operation: evidence.operation,
-            authority: evidence.authority,
-            confidence: evidence.confidence,
-            provider: evidence.provider,
-            limitations: evidence.limitations,
-            section,
-            value,
-        });
-    });
-};
-const registerResidualUnknownResource = (server, session) => {
-    server.registerResource("residual-unknown", new ResourceTemplate("rea://unknown/{unknownId}", {
-        list: undefined,
-    }), {
-        title: "Residual unknown",
-        description: "Current session-owned residual unknown head.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const unknownId = stringVariable(variables.unknownId, uri.href);
-        const unknown = session
-            .listUnknowns()
-            .find(({ unknown_id }) => unknown_id === unknownId);
-        if (unknown === undefined)
-            throw new ResourceNotFoundError(uri.href);
-        const history = session
-            .exportEvidenceBundle()
-            .unknowns.filter(({ unknown_id }) => unknown_id === unknownId);
-        return jsonResource(uri.href, { current: unknown, history });
-    });
-};
-const EVIDENCE_SECTIONS = [
-    "result",
-    "terminal",
-    "filesystem",
-    "process",
-    "protocol",
-    "nodes",
-    "occurrences",
-    "edges",
-];
-const stringVariable = (value, uri) => {
-    if (typeof value !== "string")
-        throw new ResourceNotFoundError(uri);
-    return value;
-};
-const evidenceSection = (result, section) => {
-    if (section === "result")
-        return result;
-    if (typeof result !== "object" || result === null || Array.isArray(result))
-        return undefined;
-    if (section === "terminal")
-        return pick(result, ["frames", "rendered_frames", "interaction_events"]);
-    if (section === "filesystem")
-        return pick(result, [
-            "filesystem_checkpoints",
-            "filesystem_effects",
-            "files_before",
-            "files_after",
-        ]);
-    if (section === "process")
-        return pick(result, ["process_samples", "exit", "settlement", "cleanup"]);
-    if (section === "protocol")
-        return pick(result, [
-            "protocol_events",
-            "replay_transitions",
-            "shim_events",
-        ]);
-    const value = result[section];
-    return value === undefined ? undefined : value;
-};
-const pick = (result, names) => {
-    const entries = names.flatMap((name) => result[name] === undefined ? [] : [[name, result[name]]]);
-    return entries.length === 0 ? undefined : Object.fromEntries(entries);
-};
-const jsonResource = (uri, value) => ({
-    contents: [
-        {
-            uri,
-            mimeType: "application/json",
-            text: JSON.stringify(value, null, 2),
-        },
-    ],
-});
-const ARTIFACT_COLLECTIONS = new Set(["nodes", "occurrences", "edges"]);
-const objectValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
-    ? value
-    : undefined;
-const artifactManifestId = (value) => {
-    const manifest = objectValue(objectValue(value)?.manifest ?? null);
-    return typeof manifest?.manifest_id === "string"
-        ? manifest.manifest_id
-        : undefined;
-};
-const functionAddress = (value) => {
-    const result = objectValue(value);
-    const procedure = objectValue(result?.procedure ?? null);
-    const candidate = procedure?.address ?? result?.address;
-    return typeof candidate === "string" ? candidate : undefined;
-};
-const contentDigest = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Resource is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};

package/dist/server/registerJavaScriptApplicationGraphResource.js

@@ -1,65 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { javascriptApplicationAnalysisResultSchema } from "../domain/javascriptApplicationAnalysis.js";
-/** Register deterministic pages over one authenticated JavaScript graph. */
-export const registerJavaScriptApplicationGraphResource = (server, session) => {
-    server.registerResource("javascript-application-graph-page", new ResourceTemplate("rea://evidence/{evidenceId}/application-graph/{collection}/offset/{offset}/limit/{limit}", {
-        list: undefined,
-        complete: {
-            collection: (prefix) => ["nodes", "edges"].filter((name) => name.startsWith(prefix)),
-        },
-    }), {
-        title: "JavaScript application graph page",
-        description: "One deterministic bounded node or edge page from authenticated JavaScript application Evidence.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = stringVariable(variables.evidenceId, uri.href);
-        const collection = stringVariable(variables.collection, uri.href);
-        if (collection !== "nodes" && collection !== "edges")
-            throw new ResourceNotFoundError(uri.href);
-        const offset = pageInteger(variables.offset, uri.href, 0, 100_000);
-        const limit = pageInteger(variables.limit, uri.href, 1, 500);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined ||
-            evidence.operation !== "analyze_javascript_application")
-            throw new ResourceNotFoundError(uri.href);
-        const analysis = javascriptApplicationAnalysisResultSchema.safeParse(evidence.normalized_result);
-        if (!analysis.success)
-            throw new ResourceNotFoundError(uri.href);
-        const values = analysis.data.graph[collection];
-        const items = values.slice(offset, offset + limit);
-        const nextOffset = offset + items.length;
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify({
-                        evidence_id: evidence.evidence_id,
-                        graph_id: analysis.data.graph.graph_id,
-                        collection,
-                        items,
-                        offset,
-                        limit,
-                        total: values.length,
-                        next_offset: nextOffset < values.length ? nextOffset : null,
-                        has_more: nextOffset < values.length,
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-};
-const stringVariable = (value, uri) => {
-    if (typeof value !== "string")
-        throw new ResourceNotFoundError(uri);
-    return value;
-};
-const pageInteger = (value, uri, minimum, maximum) => {
-    const text = stringVariable(value, uri);
-    if (!/^\d+$/u.test(text))
-        throw new ResourceNotFoundError(uri);
-    const parsed = Number(text);
-    if (!Number.isSafeInteger(parsed) || parsed < minimum || parsed > maximum)
-        throw new ResourceNotFoundError(uri);
-    return parsed;
-};

package/dist/server/registerReconstructionObligationLedgerResource.js

@@ -1,32 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { reconstructionObligationLedgerPageSchema } from "../domain/reconstructionObligationLedgerSchemas.js";
-/** Expose retained obligation-ledger pages as typed Evidence resources. */
-export const registerReconstructionObligationLedgerResource = (server, session) => {
-    server.registerResource("reconstruction-obligation-ledger-page", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-obligation-ledger", {
-        list: undefined,
-    }), {
-        title: "Reconstruction obligation ledger page",
-        description: "One deterministic Evidence v2-backed obligation page with full-ledger closure digest and summaries.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = variables.evidenceId;
-        if (typeof evidenceId !== "string")
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined ||
-            evidence.predicate_type !== "rea.reconstruction-obligation-ledger/v1")
-            throw new ResourceNotFoundError(uri.href);
-        const page = reconstructionObligationLedgerPageSchema.safeParse(evidence.normalized_result);
-        if (!page.success)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify({ evidence_id: evidence.evidence_id, page: page.data }, null, 2),
-                },
-            ],
-        };
-    });
-};

package/dist/server/registerReconstructionReadinessResource.js

@@ -1,32 +0,0 @@
-import { ResourceNotFoundError, ResourceTemplate, } from "@modelcontextprotocol/server";
-import { reconstructionReadinessReportSchema } from "../domain/reconstructionReadinessSchemas.js";
-/** Expose retained full readiness reports outside compact tool responses. */
-export const registerReconstructionReadinessResource = (server, session) => {
-    server.registerResource("reconstruction-readiness-report", new ResourceTemplate("rea://evidence/{evidenceId}/reconstruction-readiness-report", {
-        list: undefined,
-    }), {
-        title: "Reconstruction readiness report",
-        description: "Full deterministic nine-stage conformance report and replay identity.",
-        mimeType: "application/json",
-    }, (uri, variables) => {
-        const evidenceId = variables.evidenceId;
-        if (typeof evidenceId !== "string")
-            throw new ResourceNotFoundError(uri.href);
-        const evidence = session.evidenceById(evidenceId);
-        if (evidence === undefined ||
-            evidence.predicate_type !== "rea.reconstruction-readiness-report/v1")
-            throw new ResourceNotFoundError(uri.href);
-        const report = reconstructionReadinessReportSchema.safeParse(evidence.normalized_result);
-        if (!report.success)
-            throw new ResourceNotFoundError(uri.href);
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: "application/json",
-                    text: JSON.stringify({ evidence_id: evidence.evidence_id, report: report.data }, null, 2),
-                },
-            ],
-        };
-    });
-};