rea-agents 3.0.0 → 3.2.0

package/dist/server/LazyToolCatalog.js

@@ -1,134 +0,0 @@
-import { fromJsonSchema, isCallToolResult, isInputRequiredResult, } from "@modelcontextprotocol/server";
-import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
-/**
- * Advertise the generated MCP catalog immediately and hydrate its callbacks
- * through the existing registrars on first execution.
- */
-export class LazyToolCatalog {
-    #server;
-    #hydrateRegistrations;
-    #includeSessionTools;
-    #tools = new Map();
-    #hydrations = new Map();
-    #hydrationQueue = Promise.resolve();
-    #closed = false;
-    constructor(server, hydrateRegistrations, includeSessionTools = true) {
-        this.#server = server;
-        this.#hydrateRegistrations = hydrateRegistrations;
-        this.#includeSessionTools = includeSessionTools;
-    }
-    /** Register every generated tool with a lazy callback. */
-    register() {
-        for (const contract of GENERATED_MCP_TOOL_CATALOG) {
-            if (contract.requiresSession && !this.#includeSessionTools)
-                continue;
-            const inputSchema = advertisedSchema(contract.inputSchema);
-            const outputSchema = advertisedSchema(contract.outputSchema);
-            let registered;
-            const callback = async (input, context) => {
-                await this.#hydrate(contract.kind);
-                const handler = registered?.handler;
-                if (handler === undefined || handler === callback)
-                    throw new Error(`MCP tool ${contract.name} was not hydrated`);
-                const result = await Reflect.apply(handler, undefined, [
-                    input,
-                    context,
-                ]);
-                if (isCallToolResult(result) || isInputRequiredResult(result))
-                    return result;
-                throw new TypeError(`MCP tool ${contract.name} returned an invalid result`);
-            };
-            registered = this.#server.registerTool(contract.name, {
-                title: contract.title,
-                description: contract.description,
-                inputSchema,
-                outputSchema,
-                annotations: contract.annotations,
-            }, callback);
-            this.#tools.set(contract.name, registered);
-        }
-    }
-    /** Wait for in-flight hydration and reject future first-use loading. */
-    async close() {
-        this.#closed = true;
-        await Promise.allSettled(this.#hydrations.values());
-    }
-    async #hydrate(kind) {
-        if (this.#closed)
-            throw new Error("MCP tool catalog is closed");
-        const existing = this.#hydrations.get(kind);
-        if (existing !== undefined) {
-            await existing;
-            return;
-        }
-        const hydration = this.#hydrationQueue
-            .catch(() => undefined)
-            .then(() => this.#runHydration(kind));
-        this.#hydrationQueue = hydration;
-        this.#hydrations.set(kind, hydration);
-        try {
-            await hydration;
-        }
-        catch (cause) {
-            if (this.#hydrations.get(kind) === hydration)
-                this.#hydrations.delete(kind);
-            throw cause;
-        }
-    }
-    async #runHydration(kind) {
-        if (this.#closed)
-            throw new Error("MCP tool catalog is closed");
-        const expected = GENERATED_MCP_TOOL_CATALOG.filter((contract) => contract.kind === kind &&
-            (this.#includeSessionTools || !contract.requiresSession)).map((contract) => contract.name);
-        const expectedNames = new Set(expected);
-        const hydrated = new Set();
-        const originalRegisterTool = this.#server.registerTool;
-        const hydrationRegisterTool = (...args) => {
-            const [name, config, callback] = args;
-            if (typeof name !== "string" ||
-                !isRecord(config) ||
-                typeof callback !== "function")
-                throw new TypeError("Invalid lazy MCP tool registration");
-            const registered = this.#tools.get(name);
-            if (registered === undefined || !expectedNames.has(name))
-                throw new TypeError(`MCP tool ${name} is not in the ${kind} catalog family`);
-            if (hydrated.has(name))
-                throw new TypeError(`MCP tool ${name} was hydrated more than once`);
-            hydrated.add(name);
-            Reflect.apply(registered.update, registered, [
-                {
-                    title: config.title,
-                    description: config.description,
-                    paramsSchema: config.inputSchema,
-                    outputSchema: config.outputSchema,
-                    annotations: config.annotations,
-                    callback,
-                },
-            ]);
-            return registered;
-        };
-        if (!Reflect.set(this.#server, "registerTool", hydrationRegisterTool))
-            throw new TypeError("Unable to install lazy MCP tool hydration");
-        try {
-            await this.#hydrateRegistrations(kind);
-        }
-        finally {
-            Reflect.set(this.#server, "registerTool", originalRegisterTool);
-        }
-        const missing = expected.filter((name) => !hydrated.has(name));
-        if (missing.length > 0)
-            throw new TypeError(`Generated MCP tools were not hydrated: ${missing.join(", ")}`);
-    }
-}
-const advertisedSchema = (jsonSchema) => fromJsonSchema(jsonSchema, DEFERRED_VALIDATION_PROVIDER);
-class DeferredValidationProvider {
-    getValidator() {
-        return (input) => ({
-            valid: true,
-            data: input,
-            errorMessage: undefined,
-        });
-    }
-}
-const DEFERRED_VALIDATION_PROVIDER = new DeferredValidationProvider();
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/server/hydrateServerTools.js

@@ -1,191 +0,0 @@
-/**
- * Install production callbacks on generated lazy tool registrations.
- */
-export const hydrateServerToolFamily = async ({ kind, server, analysis, session, options, context, }) => {
-    const toolContext = {
-        server,
-        analysis,
-        session,
-        options,
-        logger: context.logger,
-        permissionAuthority: context.permissionAuthority,
-        activeTarget: context.activeTarget,
-        recordEvidence: context.recordEvidence,
-        recordEvidenceWithUnknown: context.recordEvidenceWithUnknown,
-    };
-    switch (kind) {
-        case "official-proxy": {
-            const { registerOfficialTools } = await import("./registerOfficialTools.js");
-            registerOfficialTools(server, analysis, analysisOptions(toolContext));
-            return;
-        }
-        case "enhanced": {
-            const { registerEnhancedTools } = await import("./registerEnhancedTools.js");
-            registerEnhancedTools(server, analysis, enhancedOptions(toolContext));
-            return;
-        }
-        case "native-provider": {
-            const { registerNativeTools } = await import("./registerNativeTools.js");
-            registerNativeTools(server, analysis, evidenceOptions(toolContext));
-            return;
-        }
-        case "artifact-provider": {
-            const { registerArtifactTools } = await import("./registerArtifactTools.js");
-            registerArtifactTools(server, analysis, {
-                ...evidenceOptions(toolContext),
-                ...(context.permissionAuthority === undefined
-                    ? {}
-                    : { permissionAuthority: context.permissionAuthority }),
-            });
-            return;
-        }
-        case "managed-provider": {
-            const { registerManagedTools } = await import("./registerManagedTools.js");
-            registerManagedTools(server, analysis, {
-                ...evidenceOptions(toolContext),
-                session,
-            });
-            return;
-        }
-        case "application":
-            await registerApplicationFamily(toolContext);
-            return;
-        case "browser-provider":
-        case "electron-provider":
-        case "runtime-provider": {
-            await hydrateObservationFamily(kind, toolContext);
-            return;
-        }
-        case "session": {
-            if (session === undefined)
-                throw new TypeError("Session tools require a binary session");
-            const { registerSessionTools } = await import("./registerSessionTools.js");
-            registerSessionTools(server, session, context.logger, {
-                ...options,
-                ...(context.availabilityPolicy === undefined
-                    ? {}
-                    : { availabilityPolicy: context.availabilityPolicy }),
-                ...(context.permissionAuthority === undefined
-                    ? {}
-                    : { permissionAuthority: context.permissionAuthority }),
-                startedAt: context.startedAt,
-                processCaptureElicitation: context.processCaptureElicitation,
-            });
-        }
-    }
-};
-const hydrateObservationFamily = async (kind, context) => {
-    const common = {
-        logger: context.logger,
-        permissionAuthority: context.permissionAuthority,
-        recordEvidence: context.recordEvidence,
-    };
-    if (kind === "browser-provider") {
-        const [{ registerBrowserTools }, { registerBrowserScenarioTool }] = await Promise.all([
-            import("./registerBrowserTools.js"),
-            import("./registerBrowserScenarioTool.js"),
-        ]);
-        registerBrowserTools(context.server, {
-            ...common,
-            browser: context.options.browserObservation,
-        });
-        registerBrowserScenarioTool(context.server, {
-            ...common,
-            provider: context.options.browserScenarioCapture,
-        });
-        return;
-    }
-    if (kind === "electron-provider") {
-        const { registerElectronTools } = await import("./registerElectronTools.js");
-        registerElectronTools(context.server, {
-            ...common,
-            electron: context.options.electronObservation,
-        });
-        return;
-    }
-    const { registerJavaScriptRuntimeObservationTools } = await import("./registerJavaScriptRuntimeObservationTools.js");
-    registerJavaScriptRuntimeObservationTools(context.server, {
-        ...common,
-        runtime: context.options.javascriptRuntimeObservation,
-    });
-};
-const analysisOptions = ({ logger, activeTarget, recordEvidence, session, }) => {
-    const recordUnknown = session === undefined
-        ? undefined
-        : (input) => session.recordUnknown(input);
-    return {
-        logger,
-        activeTarget,
-        recordEvidence,
-        recordUnknown,
-    };
-};
-const enhancedOptions = (context) => ({
-    ...analysisOptions(context),
-    analysisProfile: context.session === undefined
-        ? undefined
-        : () => context.session?.analysisProfile(),
-});
-const evidenceOptions = ({ logger, activeTarget, recordEvidence, }) => ({
-    logger,
-    activeTarget,
-    recordEvidence,
-});
-const registerApplicationFamily = async ({ server, session, options, logger, permissionAuthority, recordEvidence, recordEvidenceWithUnknown, }) => {
-    const [{ registerApplicationTools }, { registerManagedWorkflowTools }, { LinuxJavaScriptReplayRunner }, { SystemJavaScriptReplayHost },] = await Promise.all([
-        import("./registerApplicationTools.js"),
-        import("./registerManagedWorkflowTools.js"),
-        import("../replay/LinuxJavaScriptReplayRunner.js"),
-        import("../replay/SystemJavaScriptReplayHost.js"),
-    ]);
-    if (session !== undefined)
-        registerManagedWorkflowTools(server, {
-            logger,
-            recordEvidence,
-            recordEvidenceWithUnknown,
-            session,
-            runtime: {
-                policy: options.managedRuntimePolicy ?? {
-                    enabled: false,
-                    roots: [],
-                    executablePath: "/usr/bin/dotnet",
-                },
-                authority: permissionAuthority,
-            },
-        });
-    registerApplicationTools(server, {
-        logger,
-        recordEvidence,
-        recordEvidenceWithUnknown,
-        evidenceLookup: session === undefined
-            ? undefined
-            : (evidenceId) => session.evidenceById(evidenceId),
-        evidenceFilePolicy: options.evidenceFilePolicy ?? {
-            roots: [],
-            maxBytes: 1,
-            maxDepth: 1,
-            maxStringLength: 1,
-            maxNodes: 1,
-        },
-        permissionAuthority,
-        retainCoverageWorkspace: session === undefined
-            ? undefined
-            : (workspace) => {
-                return session.retainReconstructionCoverageWorkspace(workspace);
-            },
-        replay: {
-            policy: options.javascriptReplayPolicy ?? {
-                enabled: false,
-                roots: [],
-                nodePath: process.execPath,
-                bubblewrapPath: "/usr/bin/bwrap",
-                systemdRunPath: "/usr/bin/systemd-run",
-                systemctlPath: "/usr/bin/systemctl",
-                shellPath: "/usr/bin/bash",
-            },
-            host: options.javascriptReplayHost ?? new SystemJavaScriptReplayHost(),
-            runner: options.javascriptReplayRunner ?? new LinuxJavaScriptReplayRunner(),
-            authority: permissionAuthority,
-        },
-    });
-};

package/dist/server/javascriptApplicationResult.js

@@ -1,106 +0,0 @@
-import { javascriptApplicationAnalysisResultSchema } from "../domain/javascriptApplicationAnalysis.js";
-import { compareCodePoints } from "../domain/javascriptApplicationGraph.js";
-import { javascriptApplicationAnalysisSummarySchema } from "../contracts/electronToolContracts.js";
-const DEFAULT_GRAPH_PAGE_LIMIT = 100;
-const ROOT_SAMPLE_LIMIT = 10;
-const TOP_FINDING_LIMIT = 20;
-const FINDING_PRIORITY = {
-    "browser-window": 0,
-    "electron-preload": 1,
-    "context-bridge-api": 2,
-    "ipc-channel": 3,
-    "ipc-handler": 4,
-    "electron-utility": 5,
-    endpoint: 6,
-    storage: 7,
-    worker: 8,
-    "service-worker": 9,
-    "native-addon": 10,
-    "native-export": 11,
-    "source-map": 12,
-};
-/** Project complete JavaScript application Evidence into a bounded agent result. */
-export const summarizeJavaScriptApplicationEvidence = (evidence) => {
-    const result = javascriptApplicationAnalysisResultSchema.parse(evidence.normalized_result);
-    const nodeKinds = new Map();
-    for (const node of result.graph.nodes)
-        nodeKinds.set(node.kind, (nodeKinds.get(node.kind) ?? 0) + 1);
-    const rootItems = result.graph.root_node_ids.slice(0, ROOT_SAMPLE_LIMIT);
-    const pageRoot = `rea://evidence/${evidence.evidence_id}/application-graph`;
-    const topFindings = [...result.graph.nodes]
-        .sort((left, right) => (FINDING_PRIORITY[left.kind] ?? Number.MAX_SAFE_INTEGER) -
-        (FINDING_PRIORITY[right.kind] ?? Number.MAX_SAFE_INTEGER) ||
-        compareCodePoints(left.node_id, right.node_id))
-        .slice(0, TOP_FINDING_LIMIT)
-        .map((node) => {
-        const observation = node.observations[0];
-        if (observation === undefined)
-            throw new TypeError("Application graph node has no observation");
-        return {
-            node_id: node.node_id,
-            kind: node.kind,
-            label: observation.label,
-            authority: observation.evidence.authority,
-            state: observation.evidence.state,
-            confidence: observation.evidence.confidence,
-            location: observation.evidence.location,
-        };
-    });
-    const summary = result.schema_version === 1 ? omitGraph(result) : omitGraphs(result);
-    const unknowns = new Set([
-        ...result.limitations,
-        ...result.graph.limitations,
-    ]);
-    if (result.statistics.parse_failures > 0)
-        unknowns.add(`${String(result.statistics.parse_failures)} JavaScript file(s) could not be parsed.`);
-    if (result.statistics.truncated_scopes > 0)
-        unknowns.add(`${String(result.statistics.truncated_scopes)} analysis scope(s) were truncated.`);
-    if (result.graph.coverage.status !== "complete")
-        unknowns.add(`Application graph coverage is ${result.graph.coverage.status}; omitted facts remain unknown.`);
-    return javascriptApplicationAnalysisSummarySchema.parse({
-        ...summary,
-        ...(result.schema_version === 1
-            ? {}
-            : {
-                semantic_graph: {
-                    graph_id: result.semantic_graph.graph_id,
-                    nodes: result.semantic_graph.nodes.length,
-                    relations: result.semantic_graph.relations.length,
-                    unknown_frontiers: result.semantic_graph.unknowns.length,
-                    fingerprints: result.semantic_graph.fingerprints.length,
-                    coverage: result.semantic_graph.coverage.status,
-                    query_tool: "trace_javascript_semantics",
-                },
-            }),
-        unknowns: [...unknowns],
-        graph: {
-            graph_id: result.graph.graph_id,
-            node_count: result.graph.nodes.length,
-            edge_count: result.graph.edges.length,
-            roots: {
-                items: rootItems,
-                total: result.graph.root_node_ids.length,
-                truncated: rootItems.length < result.graph.root_node_ids.length,
-            },
-            node_kinds: [...nodeKinds]
-                .sort(([left], [right]) => compareCodePoints(left, right))
-                .map(([kind, count]) => ({ kind, count })),
-            top_findings: topFindings,
-            coverage: result.graph.coverage,
-            limitations: result.graph.limitations,
-            pages: {
-                nodes: `${pageRoot}/nodes/offset/0/limit/${String(DEFAULT_GRAPH_PAGE_LIMIT)}`,
-                edges: `${pageRoot}/edges/offset/0/limit/${String(DEFAULT_GRAPH_PAGE_LIMIT)}`,
-                page_limit: DEFAULT_GRAPH_PAGE_LIMIT,
-            },
-        },
-    });
-};
-const omitGraph = (result) => {
-    const { graph: _graph, ...summary } = result;
-    return summary;
-};
-const omitGraphs = (result) => {
-    const { graph: _graph, semantic_graph: _semanticGraph, ...summary } = result;
-    return summary;
-};

package/dist/server/permissionFailure.js

@@ -1,12 +0,0 @@
-import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
-import { err } from "../domain/result.js";
-/** Preserve a typed permission denial or contain an unexpected authority error. */
-export const permissionFailure = (failure) => {
-    if (failure.ok)
-        return err(new AnalysisProtocolError("Expected a denied permission"));
-    return err(failure.error instanceof PermissionRequiredError
-        ? failure.error
-        : new AnalysisProtocolError(failure.error.message, {
-            cause: failure.error,
-        }));
-};

package/dist/server/registerApplicationTools/readiness.js

@@ -1,55 +0,0 @@
-import { evaluateReconstructionReadinessValidated, resolveReconstructionReadinessRequest, } from "../../application/ReconstructionReadinessService.js";
-import { applicationToolContract } from "../../contracts/applicationToolContracts.js";
-import { reconstructionReadinessInputSchema } from "../../domain/reconstructionReadinessSchemas.js";
-import { reconstructionReadinessReportSchema } from "../../domain/reconstructionReadinessSchemas.js";
-import { logToolExecution } from "../toolLogging.js";
-import { safeParseToolInput } from "../toolInputValidation.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 parsed = safeParseToolInput(reconstructionReadinessInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const resolved = resolveReconstructionReadinessRequest(parsed.value);
-        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",
-                },
-            ],
-        });
-    });
-};