rea-agents 2.4.0 → 3.0.0

package/dist/hopper/HopperResponseStream.js

@@ -0,0 +1,46 @@
+import { parseBridgeMessageLine, } from "./protocol.js";
+const MAX_LINE_BYTES = 10 * 1024 * 1024;
+/** Incrementally validates bounded Hopper NDJSON response frames. */
+export class HopperResponseStream {
+    options;
+    #buffer = "";
+    constructor(options) {
+        this.options = options;
+    }
+    push(chunk) {
+        this.#buffer += chunk;
+        let newline = this.#buffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = this.#buffer.slice(0, newline).trim();
+            this.#buffer = this.#buffer.slice(newline + 1);
+            if (Buffer.byteLength(line) > MAX_LINE_BYTES) {
+                this.options.abort("Hopper response exceeded the maximum line size");
+                return;
+            }
+            if (line.length > 0 && !this.#acceptLine(line))
+                return;
+            newline = this.#buffer.indexOf("\n");
+        }
+        if (Buffer.byteLength(this.#buffer) > MAX_LINE_BYTES) {
+            this.options.abort("Hopper response exceeded the maximum line size");
+        }
+    }
+    reset() {
+        this.#buffer = "";
+    }
+    #acceptLine(line) {
+        const parsed = parseBridgeMessageLine(line);
+        if (!parsed.ok) {
+            this.options.abort(parsed.error.message, parsed.error);
+            return false;
+        }
+        if (this.options.accept(parsed.value))
+            return true;
+        if (parsed.value.id >= this.options.nextRequestId() ||
+            this.options.hasQueued(parsed.value.id)) {
+            this.options.abort("Hopper returned an unknown response id");
+            return false;
+        }
+        return true;
+    }
+}

package/dist/hopper/protocol.js

@@ -2,29 +2,72 @@ import { z } from "zod";
 import { HopperProtocolError, HopperRemoteError } from "../domain/errors.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
+const remoteErrorSchema = z
+    .object({
+    code: z.number().int(),
+    message: z.string().max(512),
+    type: z
+        .enum([
+        "remote",
+        "authorization",
+        "invalid_request",
+        "capability_unavailable",
+        "bridge_exception",
+    ])
+        .default("remote"),
+})
+    .strict();
 const responseSchema = z.union([
-    z.object({
+    z
+        .object({
         id: z.number().int().nonnegative(),
         result: jsonValueSchema,
-    }),
-    z.object({
+    })
+        .strict(),
+    z
+        .object({
         id: z.number().int().nonnegative(),
-        error: z.object({
-            code: z.number().int(),
-            message: z.string(),
-            type: z
-                .enum([
-                "remote",
-                "authorization",
-                "invalid_request",
-                "bridge_exception",
-            ])
-                .default("remote"),
-        }),
-    }),
+        error: remoteErrorSchema,
+    })
+        .strict(),
 ]);
-/** Parse one complete Hopper NDJSON response line. */
-export const parseResponseLine = (line) => {
+const eventSchema = z
+    .object({
+    id: z.number().int().nonnegative(),
+    event: z.discriminatedUnion("type", [
+        z
+            .object({
+            type: z.literal("progress"),
+            phase: z.string().min(1).max(64),
+            completed: z.number().nonnegative().finite(),
+            total: z.number().nonnegative().finite().nullable(),
+            message: z.string().min(1).max(512),
+            terminal: z.boolean().optional(),
+        })
+            .strict(),
+        z
+            .object({
+            type: z.literal("diagnostic"),
+            error: remoteErrorSchema,
+        })
+            .strict(),
+    ]),
+})
+    .strict()
+    .superRefine((message, context) => {
+    if (message.event.type === "progress" &&
+        message.event.total !== null &&
+        message.event.completed > message.event.total) {
+        context.addIssue({
+            code: "custom",
+            message: "Progress total cannot be less than completed",
+            path: ["event", "total"],
+        });
+    }
+});
+const messageSchema = z.union([responseSchema, eventSchema]);
+/** Parse one complete Hopper NDJSON response or event line. */
+export const parseBridgeMessageLine = (line) => {
     let decoded;
     try {
         decoded = JSON.parse(line);
@@ -32,10 +75,10 @@ export const parseResponseLine = (line) => {
     catch (cause) {
         return err(new HopperProtocolError("Hopper returned malformed JSON", { cause }));
     }
-    const parsed = responseSchema.safeParse(decoded);
+    const parsed = messageSchema.safeParse(decoded);
     return parsed.success
         ? ok(parsed.data)
-        : err(new HopperProtocolError("Hopper returned a response outside the bridge contract", { cause: parsed.error }));
+        : err(new HopperProtocolError("Hopper returned a message outside the bridge contract", { cause: parsed.error }));
 };
 /** Project a parsed response into its result or expected remote failure. */
 export const responseResult = (response) => "error" in response

package/dist/main/transport.js

@@ -1,4 +1,4 @@
-import { createServer } from "../server/createServer.js";
+import { createServer, } from "../server/createServer.js";
 import { MCP_CONNECTION_LOST, MCP_CONNECTION_START_FAILED, } from "./messages.js";
 export const startMcpTransport = async (dependencies, session, serverContext) => {
     const liveServers = new Set();
@@ -13,36 +13,12 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
                 investigationInputRoots: serverContext.runtimeState.investigationRoots,
                 analysisSnapshotFilePolicy: serverContext.runtimeState.snapshotPolicy,
                 permissionAuthority: serverContext.permissionAuthority,
-                browserObservation: serverContext.browserObservation,
-                electronObservation: serverContext.electronObservation,
+                loadOptionalProviders: serverContext.loadOptionalProviders,
                 artifactIntegrityContinueEnabled: () => serverContext.runtimeState.currentConfig
                     .artifactIntegrityContinueEnabled,
                 javascriptReplayPolicy: serverContext.runtimeState.javascriptReplayPolicy,
                 managedRuntimePolicy: serverContext.runtimeState.managedRuntimePolicy,
-                availabilityPolicy: () => ({
-                    processCaptureEnabled: serverContext.runtimeState.currentConfig.processExecutionPolicy
-                        .enabled,
-                    evidenceFileRoots: serverContext.runtimeState.currentConfig.evidenceFilePolicy
-                        .roots.length,
-                    investigationInputRoots: serverContext.runtimeState.currentConfig.investigationInputRoots
-                        .length,
-                    browserObservationEnabled: serverContext.runtimeState.currentConfig
-                        .browserObservationEnabled &&
-                        serverContext.runtimeState.currentConfig.browserCdpEndpoints
-                            .length > 0 &&
-                        serverContext.runtimeState.currentConfig.browserAllowedOrigins
-                            .length > 0,
-                    electronObservationEnabled: serverContext.runtimeState.currentConfig
-                        .electronObservationEnabled &&
-                        serverContext.runtimeState.currentConfig.electronCdpEndpoints
-                            .length > 0 &&
-                        serverContext.runtimeState.currentConfig.electronFileRoots
-                            .length > 0,
-                    javascriptReplayEnabled: serverContext.runtimeState.currentConfig.javascriptReplayPolicy
-                        .enabled,
-                    managedRuntimeEnabled: serverContext.runtimeState.currentConfig.managedRuntimePolicy
-                        .enabled,
-                }),
+                availabilityPolicy: () => runtimeAvailability(serverContext.runtimeState),
             });
             liveServers.add(server);
             return server;
@@ -61,3 +37,24 @@ export const startMcpTransport = async (dependencies, session, serverContext) =>
     }
     return { ok: true, handle, liveServers };
 };
+const runtimeAvailability = (state) => ({
+    processCaptureEnabled: state.currentConfig.processExecutionPolicy.enabled,
+    evidenceFileRoots: state.currentConfig.evidenceFilePolicy.roots.length,
+    investigationInputRoots: state.currentConfig.investigationInputRoots.length,
+    browserObservationEnabled: state.currentConfig.browserObservationEnabled &&
+        state.currentConfig.browserCdpEndpoints.length > 0 &&
+        state.currentConfig.browserAllowedOrigins.length > 0,
+    browserScenarioEnabled: state.currentConfig.browserScenarioPolicy.enabled &&
+        state.currentConfig.browserScenarioPolicy.allowedOrigins.length > 0 &&
+        (state.currentConfig.browserScenarioPolicy.executableRoots.length > 0 ||
+            state.currentConfig.browserScenarioPolicy.cdpEndpoints.length > 0),
+    electronObservationEnabled: state.currentConfig.electronObservationEnabled &&
+        state.currentConfig.electronCdpEndpoints.length > 0 &&
+        state.currentConfig.electronFileRoots.length > 0,
+    v8InspectorObservationEnabled: state.currentConfig.v8InspectorObservationEnabled &&
+        state.currentConfig.v8InspectorEndpoints.length > 0 &&
+        (state.currentConfig.v8InspectorFileRoots.length > 0 ||
+            state.currentConfig.v8InspectorAllowedOrigins.length > 0),
+    javascriptReplayEnabled: state.currentConfig.javascriptReplayPolicy.enabled,
+    managedRuntimeEnabled: state.currentConfig.managedRuntimePolicy.enabled,
+});

package/dist/main.js

@@ -7,8 +7,6 @@ import { createBinarySession } from "./application/runtime.js";
 import { createLogger } from "./logger.js";
 import { projectAnalysisError } from "./domain/errors.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
-import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
-import { CdpElectronProvider } from "./browser/CdpElectronProvider.js";
 import { SERVER_START_FAILED } from "./main/messages.js";
 import { createRuntimeState } from "./main/state.js";
 import { openInitialTarget } from "./main/startup.js";
@@ -58,8 +56,6 @@ export const run = async (dependencies = runtimeDependencies()) => {
         return 1;
     }
     const session = createBinarySession(config.value, logger);
-    const browserObservation = new CdpBrowserProvider();
-    const electronObservation = new CdpElectronProvider();
     const opened = await openInitialTarget(session, config.value, serverLogger, dependencies.writeStderr);
     if (!opened.ok)
         return opened.exitCode;
@@ -67,8 +63,20 @@ export const run = async (dependencies = runtimeDependencies()) => {
     const transport = await startMcpTransport(dependencies, session, {
         logger,
         serverLogger,
-        browserObservation,
-        electronObservation,
+        loadOptionalProviders: async () => {
+            const [{ CdpBrowserProvider }, { PlaywrightBrowserScenarioProvider }, { CdpElectronProvider }, { V8InspectorProvider },] = await Promise.all([
+                import("./browser/CdpBrowserProvider.js"),
+                import("./browser/PlaywrightBrowserScenarioProvider.js"),
+                import("./browser/CdpElectronProvider.js"),
+                import("./browser/V8InspectorProvider.js"),
+            ]);
+            return {
+                browserObservation: new CdpBrowserProvider(),
+                browserScenarioCapture: new PlaywrightBrowserScenarioProvider(),
+                electronObservation: new CdpElectronProvider(),
+                javascriptRuntimeObservation: new V8InspectorProvider(),
+            };
+        },
         permissionAuthority: permissionAuthority.value,
         runtimeState,
     });

package/dist/mcpDoctor.js

@@ -5,12 +5,12 @@ import { resolve } from "node:path";
 import { CATALOG_IDENTITY, MCP_RESOURCE_CATALOG, MCP_RESOURCE_TEMPLATE_CATALOG, } from "./catalogIdentity.js";
 import { PROMPT_CONTRACTS } from "./contracts/promptContracts.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
-const DEFAULT_DEADLINE_MS = 20_000;
+import { MCP_STARTUP_POLICY } from "./mcpStartupPolicy.js";
 const STDERR_LIMIT_BYTES = 64 * 1_024;
 const OUTPUT_FORMATS = ["toon", "json", "yaml", "md", "jsonl"];
 /** Diagnose the actual production stdio adapter with one bounded SDK session. */
 export const runProductionMcpDoctor = async (options) => {
-    const deadline = Date.now() + (options.deadlineMs ?? DEFAULT_DEADLINE_MS);
+    const deadline = Date.now() + (options.deadlineMs ?? MCP_STARTUP_POLICY.doctorDeadlineMs);
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(new Error("Production MCP doctor deadline expired")), Math.max(1, deadline - Date.now()));
     const stderr = boundedStderr();
@@ -61,10 +61,11 @@ const inspectProductionMcpSession = async (client, deadline, signal) => {
         client.listResources(undefined, request),
         client.listResourceTemplates(undefined, request),
         client.readResource({ uri: "rea://server/identity" }, request),
-        client.callTool({ name: "binary_session", arguments: {} }, request),
+        client.callTool({ name: "binary_session", arguments: { detail: "full" } }, request),
     ]);
+    const expectedToolNames = availableToolNames(requestFlow.structuredContent) ?? [];
     const inventory = {
-        tools: compareInventory(CATALOG_IDENTITY.tools.map(({ name }) => name), tools.tools.map(({ name }) => name)),
+        tools: compareInventory(expectedToolNames, tools.tools.map(({ name }) => name)),
         prompts: compareInventory(PROMPT_CONTRACTS.map(({ name }) => name), prompts.prompts.map(({ name }) => name)),
         resources: compareInventory(MCP_RESOURCE_CATALOG.map(({ name }) => name), resources.resources.map(({ name }) => name)),
         resource_templates: compareInventory(MCP_RESOURCE_TEMPLATE_CATALOG.map(({ name }) => name), templates.resourceTemplates.map(({ name }) => name)),
@@ -116,6 +117,28 @@ const inspectProductionMcpSession = async (client, deadline, signal) => {
         checks,
     };
 };
+const availableToolNames = (structuredContent) => {
+    if (typeof structuredContent !== "object" || structuredContent === null)
+        return undefined;
+    const result = Reflect.get(structuredContent, "result");
+    if (typeof result !== "object" || result === null)
+        return undefined;
+    const availability = Reflect.get(result, "tool_availability");
+    if (!Array.isArray(availability))
+        return undefined;
+    const names = [];
+    for (const item of availability) {
+        if (typeof item !== "object" || item === null)
+            return undefined;
+        const name = Reflect.get(item, "name");
+        const available = Reflect.get(item, "available");
+        if (typeof name !== "string" || typeof available !== "boolean")
+            return undefined;
+        if (available)
+            names.push(name);
+    }
+    return names;
+};
 /**
  * Dispatcher entry for `rea mcp doctor`, kept separate from Incur MCP setup.
  * @public

package/dist/mcpStartupPolicy.js

@@ -0,0 +1,14 @@
+/**
+ * Supported MCP startup deadlines and regression budgets.
+ *
+ * The Codex timeout is caller-facing configuration. The smaller phase budgets
+ * preserve operational headroom, while the doctor deadline covers additional
+ * inventory requests after initialization.
+ */
+export const MCP_STARTUP_POLICY = {
+    codexStartupTimeoutSeconds: 30,
+    initializeBudgetMs: 15_000,
+    toolsListBudgetMs: 5_000,
+    firstCatalogBudgetMs: 20_000,
+    doctorDeadlineMs: 30_000,
+};

package/dist/process/ProcessCommandIdentity.js

@@ -0,0 +1,19 @@
+import { basename } from "node:path";
+/** Match process-table command text while handling macOS executable-name normalization. */
+export const matchesOwnedProcessCommand = (actual, expected, platform = process.platform) => {
+    const actualCommand = actual.trim();
+    const expectedCommand = expected.trim();
+    if (actualCommand === expectedCommand ||
+        actualCommand.startsWith(`${expectedCommand} `))
+        return true;
+    if (platform !== "darwin")
+        return false;
+    const actualExecutable = actualCommand.split(/\s+/u, 1)[0];
+    const expectedExecutable = expectedCommand.split(/\s+/u, 1)[0];
+    const normalizedActualExecutable = actualExecutable?.startsWith("(") === true && actualExecutable.endsWith(")")
+        ? actualExecutable.slice(1, -1)
+        : actualExecutable;
+    return (normalizedActualExecutable !== undefined &&
+        expectedExecutable !== undefined &&
+        basename(normalizedActualExecutable) === basename(expectedExecutable));
+};

package/dist/process/ProcessOwnership.js

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
+import { matchesOwnedProcessCommand } from "./ProcessCommandIdentity.js";
 const execFileAsync = promisify(execFile);
 /**
  * Terminate one Windows process tree through the platform utility.
@@ -168,8 +169,8 @@ const launcherIdentityFailure = (launcher, ownership) => {
         launcher.parentPid !== ownership.expectedParentPid)
         return "owned launcher parent identity did not match";
     if (ownership.expectedCommand !== undefined &&
-        !commandMatches(launcher.command, ownership.expectedCommand))
-        return "owned launcher command identity did not match";
+        !matchesOwnedProcessCommand(launcher.command, ownership.expectedCommand))
+        return `owned launcher command identity did not match (observed=${launcher.command}; expected=${ownership.expectedCommand})`;
     return null;
 };
 const revalidateOwnedProcessGroup = async (processGroupId, ownership, host) => {
@@ -218,6 +219,12 @@ const processOwnershipFailures = async (members, runId, host) => {
                 failures.push({ pid: member.pid, reason: "run-token-mismatch" });
         }
         catch {
+            try {
+                const live = liveProcesses(await host.listProcesses());
+                if (!live.some(({ pid }) => pid === member.pid))
+                    continue;
+            }
+            catch { }
             failures.push({ pid: member.pid, reason: "environment-unreadable" });
         }
     }
@@ -280,8 +287,8 @@ export const observeOwnedProcessLineage = async (ownership, host = systemHost) =
         launcher.parentPid !== ownership.expectedParentPid)
         return unavailableLineage(ownership, "owned launcher parent identity did not match");
     if (ownership.expectedCommand !== undefined &&
-        !commandMatches(launcher.command, ownership.expectedCommand))
-        return unavailableLineage(ownership, "owned launcher command identity did not match");
+        !matchesOwnedProcessCommand(launcher.command, ownership.expectedCommand))
+        return unavailableLineage(ownership, `owned launcher command identity did not match (observed=${launcher.command}; expected=${ownership.expectedCommand})`);
     const descendants = descendantsOf(launcher.pid, processes);
     for (const member of [launcher, ...descendants]) {
         try {
@@ -340,7 +347,3 @@ const unavailableLineage = (ownership, reason) => ({
     reason,
 });
 const liveProcesses = (members) => members.filter(({ state }) => !state.startsWith("Z"));
-const commandMatches = (actual, expected) => {
-    return (actual.trim() === expected.trim() ||
-        actual.trim().startsWith(`${expected.trim()} `));
-};

package/dist/server/DynamicToolAvailability.js

@@ -0,0 +1,70 @@
+import { buildCapabilityInventory, } from "../application/CapabilityInventory.js";
+/**
+ * Track public SDK tool handles and keep their visible state synchronized with
+ * the same availability projection returned by `binary_session`.
+ */
+export const installDynamicToolAvailability = (server, session, policy) => {
+    const tools = new Map();
+    const originalRegisterTool = server.registerTool.bind(server);
+    const originalSendToolListChanged = server.sendToolListChanged.bind(server);
+    let synchronizing = false;
+    const controller = {
+        synchronize: () => {
+            if (synchronizing)
+                return false;
+            synchronizing = true;
+            try {
+                const availability = new Map(buildCapabilityInventory(session.status(), policy(), clientFeatures(server)).map((item) => [item.name, item.available]));
+                let changed = false;
+                for (const [name, tool] of tools) {
+                    const enabled = availability.get(name) === true;
+                    if (tool.enabled === enabled)
+                        continue;
+                    changed = true;
+                    if (enabled)
+                        tool.enable();
+                    else
+                        tool.disable();
+                }
+                return changed;
+            }
+            finally {
+                synchronizing = false;
+            }
+        },
+    };
+    const wrappedRegisterTool = (...args) => {
+        const name = args[0];
+        if (typeof name !== "string")
+            throw new TypeError("MCP tool registration requires a string name");
+        const registered = Reflect.apply(originalRegisterTool, server, args);
+        if (!isRegisteredTool(registered))
+            throw new TypeError(`MCP SDK did not return a tool handle for ${name}`);
+        tools.set(name, registered);
+        return registered;
+    };
+    if (!Reflect.set(server, "registerTool", wrappedRegisterTool))
+        throw new TypeError("Unable to install dynamic MCP tool registration");
+    if (!Reflect.set(server, "sendToolListChanged", () => {
+        if (controller.synchronize())
+            originalSendToolListChanged();
+    }))
+        throw new TypeError("Unable to install dynamic MCP tool notifications");
+    return controller;
+};
+const clientFeatures = (server) => {
+    const capabilities = server.server.getClientCapabilities();
+    return {
+        elicitation_form: capabilities?.elicitation?.form !== undefined,
+        elicitation_url: capabilities?.elicitation?.url !== undefined,
+        roots: capabilities?.roots !== undefined,
+        sampling: capabilities?.sampling !== undefined,
+    };
+};
+const isRegisteredTool = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return (typeof Reflect.get(value, "enabled") === "boolean" &&
+        typeof Reflect.get(value, "enable") === "function" &&
+        typeof Reflect.get(value, "disable") === "function");
+};

package/dist/server/LazyToolCatalog.js

@@ -0,0 +1,134 @@
+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);