rea-agents 2.5.0 → 3.1.0

package/dist/server/registerInvestigationTools.js

@@ -1,19 +1,19 @@
 import { runCrossVersionInvestigationValidated } from "../application/CrossVersionInvestigation.js";
-import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
-import { buildCallPath, callPathInputSchema } from "../domain/callPath.js";
-import { correlateStaticAndRuntime, staticRuntimeCorrelationInputSchema, } from "../domain/staticRuntimeCorrelation.js";
-import { reconstructionVerificationInputSchema, verifyReconstruction, } from "../domain/reconstructionVerification.js";
-import { changedBehaviorResultSchema, changedBehaviorInputSchema, findChangedBehavior, } from "../domain/changedBehavior.js";
-import { createEvidence } from "../domain/evidence.js";
+import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../application/DeferredFileAuthorization.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
+import { buildCallPath } from "../domain/callPath.js";
+import { changedBehaviorInputSchema, changedBehaviorResultSchema, findChangedBehavior, } from "../domain/changedBehavior.js";
 import {} from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "./sessionToolPolicies.js";
-import { toCallToolResult } from "./toolResult.js";
+import { verifyReconstruction } from "../domain/reconstructionVerification.js";
+import { correlateStaticAndRuntime } from "../domain/staticRuntimeCorrelation.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { runDerivedOperation, } from "./runDerivedOperation.js";
-import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "../application/DeferredFileAuthorization.js";
 import { comparisonClosure, evidenceClosure, functionEvidenceIds, investigationContext, isIncomplete, recordWorkflowEvidence, verifyCoverageReadiness, } from "./registerInvestigationTools/helpers.js";
+import { runDerivedOperation, } from "./runDerivedOperation.js";
+import { CALL_PATH_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, RECONSTRUCTION_PROVIDER, STATIC_RUNTIME_PROVIDER, } from "./sessionToolPolicies.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register Evidence-composed differential investigation workflows. */
 export const registerInvestigationTools = (server, session, contracts, policies) => {
     registerChangedBehavior(server, session, contracts[0], policies);
@@ -23,11 +23,7 @@ export const registerInvestigationTools = (server, session, contracts, policies)
 };
 const registerChangedBehavior = (server, session, contract, policies) => {
     server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(changedBehaviorInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const investigationRun = parsed.investigation_run;
+        const investigationRun = input.investigation_run;
         if (investigationRun !== undefined)
             return runAutomaticInvestigation({
                 server,
@@ -35,14 +31,14 @@ const registerChangedBehavior = (server, session, contract, policies) => {
                 contract,
                 policies,
                 investigationRun,
-                unknownRegistryApproved: parsed.unknown_registry_approved,
+                unknownRegistryApproved: input.unknown_registry_approved,
                 context,
             });
-        const closure = evidenceClosure(session, comparisonClosure(parsed.comparisons));
+        const closure = evidenceClosure(session, comparisonClosure(input.comparisons));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(parsed.comparisons, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => findChangedBehavior(input.comparisons, input.offset, input.limit));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
@@ -50,9 +46,9 @@ const registerChangedBehavior = (server, session, contract, policies) => {
             predicateType: "rea.changed-behavior/v1",
             operation: contract.name,
             parameters: {
-                comparison_evidence_ids: parsed.comparisons.map(({ evidence_id: id }) => id),
-                offset: parsed.offset,
-                limit: parsed.limit,
+                comparison_evidence_ids: input.comparisons.map(({ evidence_id: id }) => id),
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -60,7 +56,7 @@ const registerChangedBehavior = (server, session, contract, policies) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        const recorded = recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, isIncomplete(result.behavior_status), {
+        const recorded = recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, isIncomplete(result.behavior_status), {
             question: "Did both versions behave the same under a complete controlled replay?",
             domain: "changed-behavior",
             requiredAuthority: "controlled-replay",
@@ -114,8 +110,7 @@ const runAutomaticInvestigation = async (input) => {
     if (!investigated.ok)
         return toCallToolResult(investigated, contract);
     const workspace = investigated.value.workspace;
-    if (session.retainInvestigationWorkspace(workspace) === "added")
-        input.server.sendResourceListChanged();
+    session.retainInvestigationWorkspace(workspace);
     const result = changedBehaviorResultSchema.parse(investigated.value.evidence.normalized_result);
     const toolResult = toCallToolResult(recordWorkflowEvidence(session, investigated.value.evidence, input.unknownRegistryApproved, isIncomplete(result.behavior_status), {
         question: `Automatic changed behavior run ${result.investigation_run?.run_id ?? "unknown"} remains ${result.behavior_status}`,
@@ -145,15 +140,11 @@ const runAutomaticInvestigation = async (input) => {
 };
 const registerCallPath = (server, session, contract) => {
     server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(callPathInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const closure = evidenceClosure(session, functionEvidenceIds(parsed.functions));
+        const closure = evidenceClosure(session, functionEvidenceIds(input.functions));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => buildCallPath(parsed));
+        const computed = await runDerivedOperation(context, contract.name, () => buildCallPath(input));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
@@ -161,12 +152,12 @@ const registerCallPath = (server, session, contract) => {
             predicateType: "rea.call-path/v1",
             operation: contract.name,
             parameters: {
-                start: parsed.start.address,
-                goal: parsed.goal.address,
-                max_depth: parsed.max_depth,
-                max_paths: parsed.max_paths,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                start: input.start.address,
+                goal: input.goal.address,
+                max_depth: input.max_depth,
+                max_paths: input.max_paths,
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -174,7 +165,7 @@ const registerCallPath = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        const recorded = recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
+        const recorded = recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
             question: "Can the requested call path be established from complete analysis?",
             domain: "call-path",
             requiredAuthority: "shipped-artifact",
@@ -191,18 +182,14 @@ const registerCallPath = (server, session, contract) => {
 };
 const registerStaticRuntime = (server, session, contract) => {
     server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(staticRuntimeCorrelationInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
         const closure = evidenceClosure(session, comparisonClosure([
-            ...parsed.static_comparisons,
-            ...parsed.runtime_comparisons,
+            ...input.static_comparisons,
+            ...input.runtime_comparisons,
         ]));
         if (!closure.ok)
             return toCallToolResult(closure, contract);
         const links = closure.value;
-        const computed = await runDerivedOperation(context, contract.name, () => correlateStaticAndRuntime(parsed));
+        const computed = await runDerivedOperation(context, contract.name, () => correlateStaticAndRuntime(input));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
@@ -210,9 +197,9 @@ const registerStaticRuntime = (server, session, contract) => {
             predicateType: "rea.static-runtime-correlation/v1",
             operation: contract.name,
             parameters: {
-                mapping_count: parsed.mappings.length,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                mapping_count: input.mappings.length,
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "inferred",
@@ -220,7 +207,7 @@ const registerStaticRuntime = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
+        return toCallToolResult(recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, result.status === "unknown" || result.status === "truncated", {
             question: "Does runtime behavior match the available static analysis?",
             domain: "static-runtime-correlation",
             requiredAuthority: null,
@@ -236,15 +223,11 @@ const registerStaticRuntime = (server, session, contract) => {
 };
 const registerReconstruction = (server, session, contract) => {
     server.registerTool(contract.name, contractOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(reconstructionVerificationInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const coverage = verifyCoverageReadiness(session, parsed.coverage);
+        const coverage = verifyCoverageReadiness(session, input.coverage);
         if (!coverage.ok)
             return toCallToolResult(coverage, contract);
         const owned = session.exportEvidenceBundle();
-        const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(parsed.specification, owned, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => verifyReconstruction(input.specification, owned, input.offset, input.limit));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const result = computed.value;
@@ -257,9 +240,9 @@ const registerReconstruction = (server, session, contract) => {
             operation: contract.name,
             parameters: {
                 specification_sha256: result.specification_sha256,
-                claim_ids: parsed.specification.claims.map(({ claim_id: id }) => id),
-                offset: parsed.offset,
-                limit: parsed.limit,
+                claim_ids: input.specification.claims.map(({ claim_id: id }) => id),
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(result),
             confidence: "derived",
@@ -267,7 +250,7 @@ const registerReconstruction = (server, session, contract) => {
             limitations: result.limitations,
             evidenceLinks: links,
         });
-        return toCallToolResult(recordWorkflowEvidence(session, evidence, parsed.unknown_registry_approved, result.status === "unknown", {
+        return toCallToolResult(recordWorkflowEvidence(session, evidence, input.unknown_registry_approved, result.status === "unknown", {
             question: "Does the reconstruction satisfy every declared claim?",
             domain: "reconstruction-verification",
             requiredAuthority: null,

package/dist/server/registerJavaScriptApplicationGraphResource.js

@@ -5,10 +5,6 @@ export const registerJavaScriptApplicationGraphResource = (server, session) => {
     server.registerResource("javascript-application-graph-page", new ResourceTemplate("rea://evidence/{evidenceId}/application-graph/{collection}/offset/{offset}/limit/{limit}", {
         list: undefined,
         complete: {
-            evidenceId: (prefix) => session
-                .exportEvidenceBundle()
-                .records.map(({ evidence_id }) => evidence_id)
-                .filter((evidenceId) => evidenceId.startsWith(prefix)),
             collection: (prefix) => ["nodes", "edges"].filter((name) => name.startsWith(prefix)),
         },
     }), {

package/dist/server/registerJavaScriptRuntimeObservationTools.js

@@ -1,37 +1,23 @@
 import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "../application/JavaScriptRuntimeObservationService.js";
 import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "../contracts/javascriptRuntimeObservationToolContracts.js";
-import { listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "../domain/javascriptRuntimeObservation.js";
 import { logToolExecution } from "./toolLogging.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register passive Inspector tools even when policy keeps them unavailable. */
 export const registerJavaScriptRuntimeObservationTools = (server, options) => {
     const [listContract, observeContract] = JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS;
-    registerRuntimeTool(server, options, {
-        contract: listContract,
-        schema: listJavaScriptRuntimeTargetsInputSchema,
-        execute: (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal }),
-    });
-    registerRuntimeTool(server, options, {
-        contract: observeContract,
-        schema: observeJavaScriptRuntimeInputSchema,
-        execute: (parsed, signal) => observeJavaScriptRuntime(options.runtime, options.permissionAuthority, parsed, { signal }),
-    });
+    server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input, context) => runRuntimeTool(options, listContract, { input, context }, (parsed, signal) => listJavaScriptRuntimeTargets(options.runtime, options.permissionAuthority, parsed, { signal })));
+    server.registerTool(observeContract.name, toolRegistrationOptions(observeContract), (input, context) => runRuntimeTool(options, observeContract, { input, context }, (parsed, signal) => observeJavaScriptRuntime(options.runtime, options.permissionAuthority, parsed, { signal })));
 };
-const registerRuntimeTool = (server, options, spec) => {
-    server.registerTool(spec.contract.name, toolRegistrationOptions(spec.contract), async (input, context) => {
-        const parsed = safeParseToolInput(spec.schema, input, spec.contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, spec.contract);
-        const result = await logToolExecution(options.logger, spec.contract.name, () => spec.execute(parsed.value, context.mcpReq.signal));
-        if (!result.ok)
-            return toCallToolResult(result, spec.contract);
-        const recorded = options.recordEvidence?.(result.value);
-        return recorded !== undefined && !recorded.ok
-            ? toCallToolResult(recorded, spec.contract)
-            : toCallToolResult({ ok: true, value: result.value }, spec.contract, {
-                evidenceResourcesAvailable: recorded !== undefined,
-            });
-    });
+const runRuntimeTool = async (options, contract, request, execute) => {
+    const { input, context } = request;
+    const result = await logToolExecution(options.logger, contract.name, () => execute(input, context.mcpReq.signal));
+    if (!result.ok)
+        return toCallToolResult(result, contract);
+    const recorded = options.recordEvidence?.(result.value);
+    return recorded !== undefined && !recorded.ok
+        ? toCallToolResult(recorded, contract)
+        : toCallToolResult({ ok: true, value: result.value }, contract, {
+            evidenceResourcesAvailable: recorded !== undefined,
+        });
 };

package/dist/server/registerManagedWorkflowTools/compareManagedMembers.js

@@ -1,29 +1,24 @@
 import { compareManagedMembersEvidenceValidated } from "../../application/ManagedMemberComparisonService.js";
-import { compareManagedMembersReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { managedMemberComparisonResultSchema } from "../../domain/managedMemberComparison.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { recordManagedSources, resolveManagedEvidence } from "./evidence.js";
 const compareContract = managedWorkflowContract("compare_managed_members");
 /** Register the managed member comparison workflow tool. */
 export const registerCompareManagedMembers = (server, options) => {
     server.registerTool(compareContract.name, toolRegistrationOptions(compareContract), async (input) => {
-        const parsedInput = safeParseToolInput(compareManagedMembersReferenceInputSchema, input, compareContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, compareContract);
         const resolved = resolveManagedEvidence(options.session, [
-            parsedInput.value.left_evidence_id,
-            parsedInput.value.right_evidence_id,
+            input.left_evidence_id,
+            input.right_evidence_id,
         ]);
         if (!resolved.ok)
             return toCallToolResult(resolved, compareContract);
         const [left, right] = resolved.value;
         if (left === undefined || right === undefined)
             throw new TypeError("Managed comparison Evidence resolution failed");
-        const { left_evidence_id: _leftEvidenceId, right_evidence_id: _rightEvidenceId, ...referencedInput } = parsedInput.value;
+        const { left_evidence_id: _leftEvidenceId, right_evidence_id: _rightEvidenceId, ...referencedInput } = input;
         const parsed = { ...referencedInput, left, right };
         const result = await logToolExecution(options.logger, compareContract.name, () => Promise.resolve(compareManagedMembersEvidenceValidated(parsed)));
         if (!result.ok)

package/dist/server/registerManagedWorkflowTools/contract.js

@@ -1,8 +1,7 @@
 import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "../../contracts/managedWorkflowToolContracts.js";
-/** Locate one managed workflow tool contract by exact name. */
-export const managedWorkflowContract = (name) => {
+export function managedWorkflowContract(name) {
     const found = MANAGED_WORKFLOW_TOOL_CONTRACTS.find((candidate) => candidate.name === name);
     if (found === undefined)
         throw new Error(`Missing ${name} contract`);
     return found;
-};
+}

package/dist/server/registerManagedWorkflowTools/importManagedReconstruction.js

@@ -1,27 +1,22 @@
 import { importManagedReconstructionEvidenceValidated } from "../../application/ManagedReconstructionService.js";
-import { managedReconstructionReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const reconstructionContract = managedWorkflowContract("import_managed_reconstruction");
 /** Register the managed reconstruction import workflow tool. */
 export const registerImportManagedReconstruction = (server, options) => {
     server.registerTool(reconstructionContract.name, toolRegistrationOptions(reconstructionContract), async (input) => {
-        const parsedInput = safeParseToolInput(managedReconstructionReferenceInputSchema, input, reconstructionContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, reconstructionContract);
         const resolved = resolveManagedEvidence(options.session, [
-            parsedInput.value.static_members_evidence_id,
+            input.static_members_evidence_id,
         ]);
         if (!resolved.ok)
             return toCallToolResult(resolved, reconstructionContract);
         const staticMembers = resolved.value[0];
         if (staticMembers === undefined)
             throw new TypeError("Managed reconstruction Evidence resolution failed");
-        const { static_members_evidence_id: _staticMembersEvidenceId, ...referencedInput } = parsedInput.value;
+        const { static_members_evidence_id: _staticMembersEvidenceId, ...referencedInput } = input;
         const parsed = { ...referencedInput, static_members: staticMembers };
         const result = await logToolExecution(options.logger, reconstructionContract.name, () => Promise.resolve(importManagedReconstructionEvidenceValidated(parsed)));
         if (!result.ok)

package/dist/server/registerManagedWorkflowTools/planManagedRuntimeCorrelation.js

@@ -1,27 +1,22 @@
 import { planManagedRuntimeCorrelationEvidenceValidated } from "../../application/ManagedRuntimeCorrelationService.js";
-import { managedRuntimeCorrelationReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { resolveManagedEvidence } from "./evidence.js";
 const runtimeContract = managedWorkflowContract("plan_managed_runtime_correlation");
 /** Register the managed runtime correlation planning workflow tool. */
 export const registerPlanManagedRuntimeCorrelation = (server, options) => {
     server.registerTool(runtimeContract.name, toolRegistrationOptions(runtimeContract), async (input) => {
-        const parsedInput = safeParseToolInput(managedRuntimeCorrelationReferenceInputSchema, input, runtimeContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, runtimeContract);
         const resolved = resolveManagedEvidence(options.session, [
-            parsedInput.value.static_members_evidence_id,
+            input.static_members_evidence_id,
         ]);
         if (!resolved.ok)
             return toCallToolResult(resolved, runtimeContract);
         const staticMembers = resolved.value[0];
         if (staticMembers === undefined)
             throw new TypeError("Managed runtime Evidence resolution failed");
-        const { static_members_evidence_id: _staticMembersEvidenceId, ...referencedInput } = parsedInput.value;
+        const { static_members_evidence_id: _staticMembersEvidenceId, ...referencedInput } = input;
         const parsed = { ...referencedInput, static_members: staticMembers };
         const result = await logToolExecution(options.logger, runtimeContract.name, () => Promise.resolve(planManagedRuntimeCorrelationEvidenceValidated(options.runtime, parsed)));
         if (!result.ok)

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -1,37 +1,32 @@
 import { projectManagedApplicationGraphEvidence } from "../../application/ManagedApplicationGraphService.js";
-import { managedApplicationGraphReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { recordManagedSources, resolveManagedArtifactEvidence, resolveManagedBoundaryEvidence, resolveManagedEvidence, sourceEvidence, } from "./evidence.js";
 const graphContract = managedWorkflowContract("project_managed_application_graph");
 /** Register the managed application graph projection workflow tool. */
 export const registerProjectManagedApplicationGraph = (server, options) => {
     server.registerTool(graphContract.name, toolRegistrationOptions(graphContract), async (input) => {
-        const parsedInput = safeParseToolInput(managedApplicationGraphReferenceInputSchema, input, graphContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, graphContract);
-        const managedArtifact = parsedInput.value.managed_artifact_evidence_id === undefined
+        const managedArtifact = input.managed_artifact_evidence_id === undefined
             ? undefined
-            : resolveManagedArtifactEvidence(options.session, parsedInput.value.managed_artifact_evidence_id);
+            : resolveManagedArtifactEvidence(options.session, input.managed_artifact_evidence_id);
         if (managedArtifact !== undefined && !managedArtifact.ok)
             return toCallToolResult(managedArtifact, graphContract);
-        const managedMembers = parsedInput.value.managed_members_evidence_id === undefined
+        const managedMembers = input.managed_members_evidence_id === undefined
             ? undefined
             : resolveManagedEvidence(options.session, [
-                parsedInput.value.managed_members_evidence_id,
+                input.managed_members_evidence_id,
             ]);
         if (managedMembers !== undefined && !managedMembers.ok)
             return toCallToolResult(managedMembers, graphContract);
-        const managedBoundaries = parsedInput.value.managed_native_boundaries_evidence_id === undefined
+        const managedBoundaries = input.managed_native_boundaries_evidence_id === undefined
             ? undefined
-            : resolveManagedBoundaryEvidence(options.session, parsedInput.value.managed_native_boundaries_evidence_id);
+            : resolveManagedBoundaryEvidence(options.session, input.managed_native_boundaries_evidence_id);
         if (managedBoundaries !== undefined && !managedBoundaries.ok)
             return toCallToolResult(managedBoundaries, graphContract);
         const parsed = {
-            limits: parsedInput.value.limits,
+            limits: input.limits,
             managed_artifact: managedArtifact?.value[0],
             managed_members: managedMembers?.value[0],
             managed_native_boundaries: managedBoundaries?.value[0],

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -1,29 +1,24 @@
 import { verifyManagedNativeBoundariesEvidence } from "../../application/ManagedNativeVerificationService.js";
-import { managedNativeVerificationReferenceInputSchema } from "../../contracts/managedWorkflowToolContracts.js";
 import { managedNativeVerificationResultSchema } from "../../domain/managedNativeVerification.js";
 import { logToolExecution } from "../toolLogging.js";
-import { toCallToolResult } from "../toolResult.js";
 import { toolRegistrationOptions } from "../toolRegistrationOptions.js";
-import { safeParseToolInput } from "../toolInputValidation.js";
+import { toCallToolResult } from "../toolResult.js";
 import { managedWorkflowContract } from "./contract.js";
 import { recordManagedSources, resolveManagedBoundaryEvidence, resolveNativeEvidence, } from "./evidence.js";
 const nativeVerificationContract = managedWorkflowContract("verify_managed_native_boundaries");
 /** Register the managed/native boundary verification workflow tool. */
 export const registerVerifyManagedNativeBoundaries = (server, options) => {
     server.registerTool(nativeVerificationContract.name, toolRegistrationOptions(nativeVerificationContract), async (input) => {
-        const parsedInput = safeParseToolInput(managedNativeVerificationReferenceInputSchema, input, nativeVerificationContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, nativeVerificationContract);
-        const managedBoundaries = resolveManagedBoundaryEvidence(options.session, parsedInput.value.managed_boundaries_evidence_id);
+        const managedBoundaries = resolveManagedBoundaryEvidence(options.session, input.managed_boundaries_evidence_id);
         if (!managedBoundaries.ok)
             return toCallToolResult(managedBoundaries, nativeVerificationContract);
-        const nativeObservations = resolveNativeEvidence(options.session, parsedInput.value.native_observation_evidence_ids);
+        const nativeObservations = resolveNativeEvidence(options.session, input.native_observation_evidence_ids);
         if (!nativeObservations.ok)
             return toCallToolResult(nativeObservations, nativeVerificationContract);
         const managedBoundary = managedBoundaries.value[0];
         if (managedBoundary === undefined)
             throw new TypeError("Managed boundary Evidence resolution failed");
-        const { managed_boundaries_evidence_id: _managedBoundariesEvidenceId, native_observation_evidence_ids: _nativeObservationEvidenceIds, ...referencedInput } = parsedInput.value;
+        const { managed_boundaries_evidence_id: _managedBoundariesEvidenceId, native_observation_evidence_ids: _nativeObservationEvidenceIds, ...referencedInput } = input;
         const parsed = {
             ...referencedInput,
             managed_boundaries: managedBoundary,

package/dist/server/registerOfficialTools.js

@@ -1,12 +1,12 @@
+import { z } from "zod";
 import { OFFICIAL_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
-import { toCallToolResult } from "./toolResult.js";
-import { logToolExecution } from "./toolLogging.js";
-import { createEvidence } from "../domain/evidence.js";
 import { AnalysisCapabilityUnavailableError, UnknownRegistryError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
+import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register direct bridge proxies, preserving MCP cancellation and typed errors. */
 export const registerOfficialTools = (server, analysis, options) => {
     for (const contract of OFFICIAL_TOOL_CONTRACTS) {
@@ -20,10 +20,7 @@ export const registerOfficialTools = (server, analysis, options) => {
 };
 const registerOfficialTool = (server, analysis, contract, registration) => {
     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 arguments_ = projectOfficialArguments(contract, input);
         const progress = mcpProgressReporter(context);
         const result = await runOfficialOperation(analysis, contract, arguments_, {
             logger: registration.logger,
@@ -106,6 +103,8 @@ const recordOfficialUnknown = (input, error, contract, recordUnknown) => {
 };
 const projectOfficialArguments = (contract, input) => {
     const parsed = jsonObjectSchema.parse(input);
+    if (!(contract.inputSchema instanceof z.ZodObject))
+        throw new TypeError("Official tool input contract must be an object schema");
     const projected = {};
     for (const key of Object.keys(contract.inputSchema.shape)) {
         if (key === "unknown_registry_approved")

package/dist/server/registerProcessComparisonTool.js

@@ -1,16 +1,15 @@
-import { processComparisonInputSchema, SESSION_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
-import { createEvidence } from "../domain/evidence.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { EvidenceIntegrityError } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.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 { recordDerivedEvidence } from "./recordDerivedEvidence.js";
 import { runDerivedOperation } from "./runDerivedOperation.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
+import { PROCESS_PROVIDER } from "./sessionToolPolicies.js";
+import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
+import { toCallToolResult } from "./toolResult.js";
 const PROCESS_CAPTURE_EVIDENCE = {
     operation: "capture_process_scenario",
     predicate: "rea.process-capture/v4",
@@ -19,14 +18,10 @@ const sourceLocations = (left, right) => [...(left ?? []), ...(right ?? [])];
 /** 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 parsedInput = safeParseToolInput(processComparisonInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const leftRecord = resolveSessionEvidenceIds(session, [parsed.left_evidence_id], PROCESS_CAPTURE_EVIDENCE);
+        const leftRecord = resolveSessionEvidenceIds(session, [input.left_evidence_id], PROCESS_CAPTURE_EVIDENCE);
         if (!leftRecord.ok)
             return toCallToolResult(leftRecord, contract);
-        const rightRecord = resolveSessionEvidenceIds(session, [parsed.right_evidence_id], PROCESS_CAPTURE_EVIDENCE);
+        const rightRecord = resolveSessionEvidenceIds(session, [input.right_evidence_id], PROCESS_CAPTURE_EVIDENCE);
         if (!rightRecord.ok)
             return toCallToolResult(rightRecord, contract);
         let comparison;
@@ -36,12 +31,12 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
             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
+                ...(input.max_capture_age_ms === undefined
                     ? {}
-                    : { maxCaptureAgeMs: parsed.max_capture_age_ms }),
-                ...(parsed.trace_spec === undefined
+                    : { maxCaptureAgeMs: input.max_capture_age_ms }),
+                ...(input.trace_spec === undefined
                     ? {}
-                    : { traceSpecification: parsed.trace_spec }),
+                    : { traceSpecification: input.trace_spec }),
                 now,
             }));
             if (!computed.ok)
@@ -54,27 +49,27 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
                 : "Invalid Process Capture v4")), contract);
         }
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
-            predicateType: parsed.trace_spec === undefined
+            predicateType: input.trace_spec === undefined
                 ? "rea.process-comparison/v3"
                 : "rea.process-comparison/v4",
             operation: contract.name,
             parameters: {
-                left_evidence_id: parsed.left_evidence_id,
-                right_evidence_id: parsed.right_evidence_id,
+                left_evidence_id: input.left_evidence_id,
+                right_evidence_id: input.right_evidence_id,
                 left_normalization: leftCapture.normalization,
                 right_normalization: rightCapture.normalization,
-                ...(parsed.trace_spec === undefined
+                ...(input.trace_spec === undefined
                     ? {}
-                    : { trace_spec: jsonValueSchema.parse(parsed.trace_spec) }),
+                    : { trace_spec: jsonValueSchema.parse(input.trace_spec) }),
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
             authority: "analyst-inference",
             limitations: comparison.limitations,
             locations: sourceLocations(leftRecord.value[0]?.locations, rightRecord.value[0]?.locations),
-            evidenceLinks: [parsed.left_evidence_id, parsed.right_evidence_id],
+            evidenceLinks: [input.left_evidence_id, input.right_evidence_id],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput(parsed, comparison)), contract);
+        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput(input, comparison)), contract);
     });
 };
 const comparisonUnknownInput = (parsed, comparison) => {