rea-agents 3.0.0 → 3.1.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/toolInputValidation.js

@@ -1,77 +0,0 @@
-import { z } from "zod";
-import { AnalysisInputError, } from "../domain/errors.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { err, ok } from "../domain/result.js";
-import { closeObjectSchemas } from "./toolRegistrationOptions.js";
-/** Parse one MCP request exactly once and retain only schema-owned correction data. */
-export const safeParseToolInput = (schema, input, operation) => {
-    const unknownIssues = unknownArgumentIssues(schema, input);
-    if (unknownIssues.length > 0)
-        return err(new AnalysisInputError(operation, undefined, unknownIssues));
-    const parsed = schema.safeParse(input);
-    return parsed.success
-        ? ok(parsed.data)
-        : err(new AnalysisInputError(operation, undefined, projectInputIssues(parsed.error.issues, input)));
-};
-const schemaCache = new WeakMap();
-const unknownArgumentIssues = (schema, input) => {
-    let jsonSchema = schemaCache.get(schema);
-    if (jsonSchema === undefined) {
-        const converter = schema["~standard"].jsonSchema?.input;
-        if (converter === undefined)
-            throw new TypeError("Tool input schema does not expose Standard JSON Schema");
-        jsonSchema = closeObjectSchemas(converter({ target: "draft-2020-12" }));
-        schemaCache.set(schema, jsonSchema);
-    }
-    return scanUnknownArguments(input, jsonSchema, jsonSchema, []);
-};
-const scanUnknownArguments = (value, schema, root, path) => {
-    const resolved = resolveSchema(schema, root);
-    if (Array.isArray(value)) {
-        const items = objectValue(resolved.items);
-        return items === undefined
-            ? []
-            : value.flatMap((item, index) => scanUnknownArguments(item, items, root, [...path, index]));
-    }
-    if (!isObject(value))
-        return [];
-    const variants = schemaVariants(resolved, root);
-    const properties = Object.fromEntries(variants.flatMap((variant) => Object.entries(objectValue(variant.properties) ?? {})));
-    const closed = variants.length > 0 &&
-        variants.every((variant) => variant.additionalProperties !== true &&
-            !isObject(variant.additionalProperties));
-    const issues = [];
-    for (const [key, child] of Object.entries(value)) {
-        const propertySchema = objectValue(properties[key]);
-        if (propertySchema === undefined) {
-            if (closed)
-                issues.push({ path: [...path, key], reason: "unknown_argument" });
-            continue;
-        }
-        issues.push(...scanUnknownArguments(child, propertySchema, root, [...path, key]));
-    }
-    return issues;
-};
-const schemaVariants = (schema, root) => {
-    const resolved = resolveSchema(schema, root);
-    const variants = [resolved.oneOf, resolved.anyOf, resolved.allOf]
-        .flatMap((value) => (Array.isArray(value) ? value : []))
-        .flatMap((value) => {
-        const object = objectValue(value);
-        return object === undefined ? [] : schemaVariants(object, root);
-    });
-    if (variants.length > 0)
-        return variants;
-    return resolved.type === "object" || isObject(resolved.properties)
-        ? [resolved]
-        : [];
-};
-const resolveSchema = (schema, root) => {
-    const reference = schema.$ref;
-    if (typeof reference !== "string" || !reference.startsWith("#/$defs/"))
-        return schema;
-    const definition = objectValue(objectValue(root.$defs)?.[reference.slice(8)]);
-    return definition === undefined ? schema : definition;
-};
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const objectValue = (value) => isObject(value) ? value : undefined;

package/scripts/package-runner-bootstrap.mjs

@@ -1,72 +0,0 @@
-import { spawn } from "node:child_process";
-import { resolve } from "node:path";
-
-const BOOTSTRAP_MARKER = "REA_PACKAGE_RUNNER_BOOTSTRAPPED";
-
-/**
- * Plan a current-release setup bootstrap when bare npx selected a project-local
- * package. Explicit `npm exec --package=<name>@<version>` rollbacks bypass it.
- */
-export function packageRunnerSetupPlan(input) {
-  if (input.args[0] !== "setup") return undefined;
-  if (input.environment[BOOTSTRAP_MARKER] === "1") return undefined;
-  if (input.environment.npm_lifecycle_event !== "npx") return undefined;
-
-  const localPrefix = input.environment.npm_config_local_prefix;
-  if (localPrefix === undefined || localPrefix.length === 0) return undefined;
-  if (
-    !isPackageBelowLocalPrefix(
-      input.packageRoot,
-      localPrefix,
-      input.packageName,
-    )
-  )
-    return undefined;
-
-  const requestedPackage = input.environment.npm_config_package;
-  if (
-    requestedPackage !== undefined &&
-    isExactPackageVersion(requestedPackage, input.packageName)
-  )
-    return undefined;
-
-  return {
-    command: "npm",
-    args: [
-      "exec",
-      "--yes",
-      `--package=${input.packageName}@latest`,
-      "--",
-      "rea",
-      ...input.args,
-    ],
-  };
-}
-
-/** Execute a planned package-runner bootstrap and return its exit status. */
-export async function runPackageRunnerSetupBootstrap(input) {
-  const plan = packageRunnerSetupPlan(input);
-  if (plan === undefined) return undefined;
-
-  return await new Promise((resolveExitCode) => {
-    const child = spawn(plan.command, plan.args, {
-      stdio: "inherit",
-      env: { ...input.environment, [BOOTSTRAP_MARKER]: "1" },
-    });
-    child.once("error", () => resolveExitCode(1));
-    child.once("exit", (code) => resolveExitCode(code ?? 1));
-  });
-}
-
-function isPackageBelowLocalPrefix(packageRoot, localPrefix, packageName) {
-  const expectedRoot = resolve(localPrefix, "node_modules", packageName);
-  return resolve(packageRoot) === expectedRoot;
-}
-
-function isExactPackageVersion(packageSpecifier, packageName) {
-  const version = packageSpecifier.slice(`${packageName}@`.length);
-  return (
-    packageSpecifier.startsWith(`${packageName}@`) &&
-    /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u.test(version)
-  );
-}