rea-agents 1.7.0 → 2.0.0

package/dist/server/registerOfficialTools.js

@@ -5,6 +5,8 @@ import { logToolExecution } from "./toolLogging.js";
 import { createEvidence } from "../domain/evidence.js";
 import { AnalysisCapabilityUnavailableError, UnknownRegistryError, } from "../domain/errors.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
 /** Register direct bridge proxies, preserving MCP cancellation and typed errors. */
 export const registerOfficialTools = (server, analysis, options) => {
     for (const contract of OFFICIAL_TOOL_CONTRACTS) {
@@ -17,13 +19,11 @@ export const registerOfficialTools = (server, analysis, options) => {
     }
 };
 const registerOfficialTool = (server, analysis, contract, registration) => {
-    server.registerTool(contract.name, {
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, async (input, context) => {
-        const arguments_ = projectOfficialArguments(contract, input);
+    server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
+        const parsedInput = safeParseToolInput(contract.inputSchema, input, contract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, contract);
+        const arguments_ = projectOfficialArguments(contract, parsedInput.value);
         const progress = mcpProgressReporter(context);
         await progress.report({
             phase: contract.name,
@@ -91,7 +91,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
     });
 };
 const projectOfficialArguments = (contract, input) => {
-    const parsed = jsonObjectSchema.parse(contract.inputSchema.parse(input));
+    const parsed = jsonObjectSchema.parse(input);
     const projected = {};
     for (const key of Object.keys(contract.inputSchema.shape)) {
         if (key === "unknown_registry_approved")

package/dist/server/registerProcessComparisonTool.js

@@ -1,35 +1,40 @@
-import canonicalize from "canonicalize";
-import { z } from "zod";
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { processComparisonInputSchema, SESSION_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
 import { createEvidence } from "../domain/evidence.js";
 import { EvidenceIntegrityError } from "../domain/errors.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, processCaptureSchema, parseProcessCapture, } from "../domain/processCapture.js";
+import { compareProcessCaptures, parseProcessCapture, } from "../domain/processCapture.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { err } from "../domain/result.js";
 import { PROCESS_PROVIDER } from "./sessionToolPolicies.js";
 import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
+import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
 /** Register deterministic process-capture comparison and contradiction tracking. */
 export const registerProcessComparisonTool = (server, session, contract, now = Date.now) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsed = z
-            .object({
-            left_evidence_id: z.string(),
-            left: processCaptureSchema,
-            right_evidence_id: z.string(),
-            right: processCaptureSchema,
-            max_capture_age_ms: z.number().int().nonnegative().optional(),
-            unknown_registry_approved: z.literal(true).optional(),
-        })
-            .parse(input);
-        const validated = validateCaptureSources(session, parsed);
-        if (!validated.ok)
-            return toCallToolResult(validated, contract);
+        const parsedInput = safeParseToolInput(processComparisonInputSchema, input, contract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, contract);
+        const parsed = parsedInput.value;
+        const expected = {
+            operation: "capture_process_scenario",
+            predicate: "rea.process-capture/v4",
+        };
+        const leftRecord = resolveSessionEvidenceIds(session, [parsed.left_evidence_id], expected);
+        if (!leftRecord.ok)
+            return toCallToolResult(leftRecord, contract);
+        const rightRecord = resolveSessionEvidenceIds(session, [parsed.right_evidence_id], expected);
+        if (!rightRecord.ok)
+            return toCallToolResult(rightRecord, contract);
         let comparison;
+        let leftCapture;
+        let rightCapture;
         try {
-            const computed = await runDerivedOperation(context, contract.name, () => compareProcessCaptures(parsed.left, parsed.right, {
+            leftCapture = parseProcessCapture(leftRecord.value[0]?.normalized_result);
+            rightCapture = parseProcessCapture(rightRecord.value[0]?.normalized_result);
+            const computed = await runDerivedOperation(context, contract.name, () => compareProcessCaptures(leftCapture, rightCapture, {
                 ...(parsed.max_capture_age_ms === undefined
                     ? {}
                     : { maxCaptureAgeMs: parsed.max_capture_age_ms }),
@@ -50,8 +55,8 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
             parameters: {
                 left_evidence_id: parsed.left_evidence_id,
                 right_evidence_id: parsed.right_evidence_id,
-                left_normalization: parsed.left.normalization,
-                right_normalization: parsed.right.normalization,
+                left_normalization: leftCapture.normalization,
+                right_normalization: rightCapture.normalization,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -62,33 +67,6 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
         return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput(parsed, comparison)), contract);
     });
 };
-const validateCaptureSources = (session, parsed) => {
-    for (const [evidenceId, capture] of [
-        [parsed.left_evidence_id, parsed.left],
-        [parsed.right_evidence_id, parsed.right],
-    ]) {
-        const evidence = session.evidenceById(evidenceId);
-        let evidenceCapture;
-        try {
-            evidenceCapture = parseProcessCapture(evidence?.normalized_result);
-        }
-        catch {
-            evidenceCapture = undefined;
-        }
-        if (evidence === undefined ||
-            evidence.operation !== "capture_process_scenario" ||
-            evidence.predicate_type !== "rea.process-capture/v4" ||
-            evidence.provider.id !== PROCESS_PROVIDER.id ||
-            evidence.provider.name !== PROCESS_PROVIDER.name ||
-            evidence.provider.version !== PROCESS_PROVIDER.version ||
-            evidence.confidence !== "observed" ||
-            evidence.authority !== "controlled-replay" ||
-            evidenceCapture === undefined ||
-            canonicalize(evidenceCapture) !== canonicalize(capture))
-            return err(new EvidenceIntegrityError("Process comparison payload does not match its source Evidence"));
-    }
-    return { ok: true, value: null };
-};
 const comparisonUnknownInput = (parsed, comparison) => {
     if (parsed.unknown_registry_approved !== true ||
         comparison.status === "unchanged")

package/dist/server/registerSessionStatusTool.js

@@ -3,15 +3,15 @@ import { toCallToolResult } from "./toolResult.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
 /** Register the read-only provider and target status operation. */
 export const registerSessionStatusTool = (server, session, contract, startedAt, availabilityPolicy) => {
-    server.registerTool(contract.name, {
-        description: contract.description,
-        inputSchema: contract.inputSchema,
-        outputSchema: contract.outputSchema,
-        annotations: contract.annotations,
-    }, (input) => {
-        const parsed = binarySessionInputSchema.parse(input);
+    server.registerTool(contract.name, toolRegistrationOptions(contract), (input) => {
+        const parsedInput = safeParseToolInput(binarySessionInputSchema, input, contract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, contract);
+        const parsed = parsedInput.value;
         const client = server.server.getClientVersion();
         const clientCapabilities = server.server.getClientCapabilities();
         const status = session.status();

package/dist/server/registerSessionTools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { exportEvidenceBundleInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, SESSION_TOOL_CONTRACTS, verifyUnknownResolutionInputSchema, } from "../contracts/toolContracts.js";
 import { toCallToolResult } from "./toolResult.js";
 import { logToolExecution } from "./toolLogging.js";
 import { err, ok } from "../domain/result.js";
@@ -14,6 +14,8 @@ import { createProcessCaptureEvidence } from "../application/ProcessEvidence.js"
 import { registerProcessComparisonTool } from "./registerProcessComparisonTool.js";
 import { registerArtifactComparisonTool } from "./registerArtifactComparisonTool.js";
 import { registerFunctionComparisonTool } from "./registerFunctionComparisonTool.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { safeParseToolInput } from "./toolInputValidation.js";
 import { registerBundleComparisonTool } from "./registerBundleComparisonTool.js";
 import { registerInvestigationTools } from "./registerInvestigationTools.js";
 import { closeBinaryInputSchema, openBinaryInputSchema, } from "../contracts/sessionLifecycleInputs.js";
@@ -58,13 +60,11 @@ const recordProcessResidualUnknowns = (session, scenario, evidence, residuals) =
     return ok(null);
 };
 const registerProcessTools = ({ server, session, logger, processPolicy, captureContract, permissionAuthority, }) => {
-    server.registerTool(captureContract.name, {
-        description: captureContract.description,
-        inputSchema: captureContract.inputSchema,
-        outputSchema: captureContract.outputSchema,
-        annotations: captureContract.annotations,
-    }, async (input, context) => {
-        const scenario = processScenarioSchema.parse(input);
+    server.registerTool(captureContract.name, toolRegistrationOptions(captureContract), async (input, context) => {
+        const parsedInput = safeParseToolInput(processScenarioSchema, input, captureContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, captureContract);
+        const scenario = parsedInput.value;
         if (permissionAuthority !== undefined) {
             const authorized = await permissionAuthority.authorize({
                 capability: "process_capture",
@@ -109,18 +109,11 @@ const registerProcessTools = ({ server, session, logger, processPolicy, captureC
     });
 };
 const registerEvidenceTools = ({ server, session, exportContract, importContract, filePolicy, permissionAuthority, }) => {
-    server.registerTool(exportContract.name, {
-        description: exportContract.description,
-        inputSchema: exportContract.inputSchema,
-        outputSchema: exportContract.outputSchema,
-        annotations: exportContract.annotations,
-    }, async (input) => {
-        const parsed = z
-            .object({
-            path: z.string().min(1).optional(),
-            overwrite: z.boolean().default(false),
-        })
-            .parse(input);
+    server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
+        const parsedInput = safeParseToolInput(exportEvidenceBundleInputSchema, input, exportContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, exportContract);
+        const parsed = parsedInput.value;
         const bundle = session.exportEvidenceBundle();
         if (parsed.path === undefined)
             return toCallToolResult(ok(bundle), exportContract);
@@ -146,13 +139,11 @@ const registerEvidenceTools = ({ server, session, exportContract, importContract
             }), exportContract)
             : toCallToolResult(written, exportContract);
     });
-    server.registerTool(importContract.name, {
-        description: importContract.description,
-        inputSchema: importContract.inputSchema,
-        outputSchema: importContract.outputSchema,
-        annotations: importContract.annotations,
-    }, async (input) => {
-        const path = z.object({ path: z.string().min(1) }).parse(input).path;
+    server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
+        const parsedInput = safeParseToolInput(importEvidenceBundleInputSchema, input, importContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, importContract);
+        const path = parsedInput.value.path;
         if (permissionAuthority !== undefined) {
             const authorized = await permissionAuthority.authorize({
                 capability: "evidence_read",
@@ -181,27 +172,11 @@ const registerEvidenceTools = ({ server, session, exportContract, importContract
     });
 };
 const registerUnknownTools = ({ server, session, contracts: [listContract, recordContract, updateContract, verifyContract], }) => {
-    server.registerTool(listContract.name, {
-        description: listContract.description,
-        inputSchema: listContract.inputSchema,
-        outputSchema: listContract.outputSchema,
-        annotations: listContract.annotations,
-    }, (input) => {
-        const filters = z
-            .object({
-            status: z
-                .enum([
-                "open",
-                "investigating",
-                "blocked",
-                "contradicted",
-                "resolved",
-            ])
-                .optional(),
-            severity: z.enum(["low", "medium", "high", "critical"]).optional(),
-            domain: z.string().trim().min(1).max(100).optional(),
-        })
-            .parse(input);
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
+        const parsedInput = safeParseToolInput(listUnknownsInputSchema, input, listContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, listContract);
+        const filters = parsedInput.value;
         return toCallToolResult(ok(session.listUnknowns({
             ...(filters.status === undefined ? {} : { status: filters.status }),
             ...(filters.severity === undefined
@@ -210,49 +185,39 @@ const registerUnknownTools = ({ server, session, contracts: [listContract, recor
             ...(filters.domain === undefined ? {} : { domain: filters.domain }),
         })), listContract);
     });
-    server.registerTool(recordContract.name, {
-        description: recordContract.description,
-        inputSchema: recordContract.inputSchema,
-        outputSchema: recordContract.outputSchema,
-        annotations: recordContract.annotations,
-    }, (input) => {
-        const recorded = session.recordUnknown(recordUnknownInputSchema.parse(input));
+    server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
+        const parsedInput = safeParseToolInput(recordUnknownInputSchema, input, recordContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, recordContract);
+        const recorded = session.recordUnknown(parsedInput.value);
         if (recorded.ok)
             server.sendResourceListChanged();
         return toCallToolResult(recorded, recordContract);
     });
-    server.registerTool(updateContract.name, {
-        description: updateContract.description,
-        inputSchema: updateContract.inputSchema,
-        outputSchema: updateContract.outputSchema,
-        annotations: updateContract.annotations,
-    }, (input) => {
-        const updated = session.updateUnknown(updateUnknownInputSchema.parse(input));
+    server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
+        const parsedInput = safeParseToolInput(updateUnknownInputSchema, input, updateContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, updateContract);
+        const updated = session.updateUnknown(parsedInput.value);
         if (updated.ok)
             server.sendResourceListChanged();
         return toCallToolResult(updated, updateContract);
     });
-    server.registerTool(verifyContract.name, {
-        description: verifyContract.description,
-        inputSchema: verifyContract.inputSchema,
-        outputSchema: verifyContract.outputSchema,
-        annotations: verifyContract.annotations,
-    }, (input) => {
-        const unknownId = z
-            .object({ unknown_id: z.string().regex(/^unk_[a-f0-9]{64}$/u) })
-            .parse(input).unknown_id;
+    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => {
+        const parsedInput = safeParseToolInput(verifyUnknownResolutionInputSchema, input, verifyContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, verifyContract);
+        const unknownId = parsedInput.value.unknown_id;
         return toCallToolResult(session.verifyUnknownResolution(unknownId), verifyContract);
     });
 };
 const registerLifecycleTools = ({ server, session, logger, contracts, snapshotFilePolicy, startedAt, availabilityPolicy, permissionAuthority, }) => {
     const [openContract, closeContract, statusContract] = contracts;
-    server.registerTool(openContract.name, {
-        description: openContract.description,
-        inputSchema: openContract.inputSchema,
-        outputSchema: openContract.outputSchema,
-        annotations: openContract.annotations,
-    }, async (input, context) => {
-        const parsed = openBinaryInputSchema.parse(input);
+    server.registerTool(openContract.name, toolRegistrationOptions(openContract), async (input, context) => {
+        const parsedInput = safeParseToolInput(openBinaryInputSchema, input, openContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, openContract);
+        const parsed = parsedInput.value;
         let snapshot;
         if (parsed.snapshot_path !== undefined) {
             if (permissionAuthority !== undefined) {
@@ -298,13 +263,11 @@ const registerLifecycleTools = ({ server, session, logger, contracts, snapshotFi
             }, openContract)
             : toCallToolResult(opened, openContract);
     });
-    server.registerTool(closeContract.name, {
-        description: closeContract.description,
-        inputSchema: closeContract.inputSchema,
-        outputSchema: closeContract.outputSchema,
-        annotations: closeContract.annotations,
-    }, async (input) => {
-        const parsed = closeBinaryInputSchema.parse(input);
+    server.registerTool(closeContract.name, toolRegistrationOptions(closeContract), async (input) => {
+        const parsedInput = safeParseToolInput(closeBinaryInputSchema, input, closeContract.name);
+        if (!parsedInput.ok)
+            return toCallToolResult(parsedInput, closeContract);
+        const parsed = parsedInput.value;
         if (parsed.snapshot_path !== undefined) {
             if (permissionAuthority !== undefined) {
                 const authorized = await permissionAuthority.authorize({
@@ -361,6 +324,8 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
                 evidenceFileRoots: evidenceFilePolicy.roots.length,
                 browserObservationEnabled: false,
                 electronObservationEnabled: false,
+                javascriptReplayEnabled: false,
+                managedRuntimeEnabled: false,
             })),
         ...(options.permissionAuthority === undefined
             ? {}
@@ -389,7 +354,7 @@ export const registerSessionTools = (server, session, logger, options = {}) => {
     registerProcessComparisonTool(server, session, compareContract);
     registerArtifactComparisonTool(server, session, compareArtifactsContract);
     registerFunctionComparisonTool(server, session, compareFunctionsContract);
-    registerBundleComparisonTool(server, session, compareBundlesContract);
+    registerBundleComparisonTool(server, session, compareBundlesContract, evidenceFilePolicy);
     const investigationContracts = [
         changedBehaviorContract,
         callPathContract,

package/dist/server/sessionEvidence.js

@@ -1,22 +1,17 @@
-import canonicalize from "canonicalize";
-import { EvidenceIntegrityError } from "../domain/errors.js";
-import { parseEvidence } from "../domain/evidence.js";
+import { EvidenceIntegrityError, EvidenceReferenceError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-/** Resolve caller-supplied records to their immutable session-owned values. */
-export const resolveSessionEvidence = (session, input) => {
-    const supplied = Array.isArray(input) ? input : [input];
-    const authoritative = [];
-    for (const item of supplied) {
-        const parsed = parseEvidence(item);
-        const owned = session.evidenceById(parsed.evidence_id);
-        if (owned === undefined || canonicalize(owned) !== canonicalize(parsed))
-            return err(new EvidenceIntegrityError("Comparison input does not match its session-owned Evidence"));
-        authoritative.push(owned);
+/** Resolve bounded IDs to authoritative records with exact semantic identity. */
+export const resolveSessionEvidenceIds = (session, evidenceIds, expected) => {
+    const records = [];
+    for (const evidenceId of evidenceIds) {
+        const record = session.evidenceById(evidenceId);
+        if (record === undefined)
+            return err(new EvidenceReferenceError(evidenceId, "missing", expected.operation, null));
+        if (record.operation !== expected.operation)
+            return err(new EvidenceReferenceError(evidenceId, "wrong_operation", expected.operation, record.operation));
+        if (record.predicate_type !== expected.predicate)
+            return err(new EvidenceReferenceError(evidenceId, "wrong_predicate", expected.predicate, record.predicate_type));
+        records.push(record);
     }
-    return ok(authoritative);
-};
-/** Check exact ownership for a single Evidence record. */
-export const isSessionEvidence = (session, input) => {
-    const owned = session.evidenceById(input.evidence_id);
-    return owned !== undefined && canonicalize(owned) === canonicalize(input);
+    return ok(records);
 };

package/dist/server/toolInputValidation.js

@@ -0,0 +1,77 @@
+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/dist/server/toolRegistrationOptions.js

@@ -1,7 +1,84 @@
+import { z } from "zod";
 /** Project the public contract fields accepted by MCP tool registration. */
 export const toolRegistrationOptions = (contract) => ({
+    title: contract.title,
     description: contract.description,
-    inputSchema: contract.inputSchema,
-    outputSchema: contract.outputSchema,
+    inputSchema: advertisedInputSchema(contract.inputSchema),
+    outputSchema: advertisedOutputSchema(contract.outputSchema),
     annotations: contract.annotations,
 });
+/**
+ * Advertise the exact Zod contract while leaving validation to REA's adapter.
+ * The SDK otherwise converts validation failures to text-only JSON-RPC errors
+ * before REA can return its stable structured error envelope.
+ */
+const advertisedInputSchema = (schema) => ({
+    "~standard": {
+        version: 1,
+        vendor: "rea",
+        validate: (input) => ({ value: input }),
+        jsonSchema: {
+            input: () => describeProperties(closeObjectSchemas(inputJsonSchema(schema))),
+            output: () => describeProperties(closeObjectSchemas(inputJsonSchema(schema))),
+        },
+    },
+});
+const advertisedOutputSchema = (schema) => {
+    const standard = schema["~standard"];
+    const converter = standard.jsonSchema?.output;
+    if (converter === undefined)
+        throw new TypeError("Tool output schema does not expose Standard JSON Schema");
+    return {
+        "~standard": {
+            ...standard,
+            jsonSchema: {
+                input: () => closeObjectSchemas(converter({ target: "draft-2020-12" })),
+                output: () => closeObjectSchemas(converter({ target: "draft-2020-12" })),
+            },
+        },
+    };
+};
+const inputJsonSchema = (schema) => {
+    const converter = schema["~standard"].jsonSchema?.input;
+    if (converter === undefined)
+        throw new TypeError("Tool input schema does not expose Standard JSON Schema");
+    return converter({ target: "draft-2020-12" });
+};
+/** Close fixed-shape JSON Schema objects while preserving explicit maps. */
+export const closeObjectSchemas = (value) => {
+    const closed = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, closeSchemaValue(child)]));
+    return value.type === "object" &&
+        isObject(value.properties) &&
+        value.additionalProperties === undefined
+        ? { ...closed, additionalProperties: false }
+        : closed;
+};
+const closeSchemaValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(closeSchemaValue);
+    if (!isObject(value))
+        return value;
+    return closeObjectSchemas(value);
+};
+const describeProperties = (value) => Object.fromEntries(Object.entries(value).map(([key, child]) => {
+    if (key !== "properties" || typeof child !== "object" || child === null)
+        return [key, describeValue(child)];
+    return [
+        key,
+        Object.fromEntries(Object.entries(child).map(([property, schema]) => [
+            property,
+            isObject(schema) && typeof schema.description !== "string"
+                ? {
+                    ...describeProperties(schema),
+                    description: property.replaceAll("_", " "),
+                }
+                : describeValue(schema),
+        ])),
+    ];
+}));
+const describeValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(describeValue);
+    return isObject(value) ? describeProperties(value) : value;
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);