rea-agents 3.0.0 → 3.1.0

package/dist/server/registerEnhancedTools.js

@@ -1,138 +1,130 @@
 import { EnhancedTools, } from "../application/EnhancedTools.js";
-import { enhancedInputSchemas, enhancedToolNameSchema, } from "../contracts/enhancedInputs.js";
+import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
 import { ENHANCED_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
-import { toCallToolResult } from "./toolResult.js";
-import { logToolExecution } from "./toolLogging.js";
+import { UnknownRegistryError } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
-import { AnalysisInputError, UnknownRegistryError } from "../domain/errors.js";
-import { ok } from "../domain/result.js";
 import { mcpProgressReporter } from "./mcpProgress.js";
-import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "../application/InvestigationProviders.js";
+import { logToolExecution } from "./toolLogging.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register composed workflows against the same port as direct bridge tools. */
+// oxlint-disable-next-line max-lines-per-function -- direct SDK calls retain each schema-handler type correlation.
 export const registerEnhancedTools = (server, analysis, options) => {
-    for (const contract of ENHANCED_TOOL_CONTRACTS) {
-        registerEnhancedTool(server, analysis, contract, {
-            logger: options.logger,
-            activeTarget: options.activeTarget,
-            analysisProfile: options.analysisProfile,
-            recordEvidence: options.recordEvidence,
-            recordUnknown: options.recordUnknown,
-        });
-    }
+    const [swiftClasses, objcClasses, objcProtocols, batchDecompile, callGraph, swiftTypes, xrefsToName, binaryOverview, analyzeFunction, inspectNativeApi, traceFeature, codeForString, traceCallPath,] = ENHANCED_TOOL_CONTRACTS;
+    server.registerTool(swiftClasses.name, toolRegistrationOptions(swiftClasses), (input, context) => executeEnhancedTool(analysis, options, swiftClasses, {
+        validatedCall: { name: "swift_classes", input },
+        context,
+    }));
+    server.registerTool(objcClasses.name, toolRegistrationOptions(objcClasses), (input, context) => executeEnhancedTool(analysis, options, objcClasses, {
+        validatedCall: { name: "get_objc_classes", input },
+        context,
+    }));
+    server.registerTool(objcProtocols.name, toolRegistrationOptions(objcProtocols), (input, context) => executeEnhancedTool(analysis, options, objcProtocols, {
+        validatedCall: { name: "get_objc_protocols", input },
+        context,
+    }));
+    server.registerTool(batchDecompile.name, toolRegistrationOptions(batchDecompile), (input, context) => executeEnhancedTool(analysis, options, batchDecompile, {
+        validatedCall: { name: "batch_decompile", input },
+        context,
+    }));
+    server.registerTool(callGraph.name, toolRegistrationOptions(callGraph), (input, context) => executeEnhancedTool(analysis, options, callGraph, {
+        validatedCall: { name: "get_call_graph", input },
+        context,
+    }));
+    server.registerTool(swiftTypes.name, toolRegistrationOptions(swiftTypes), (input, context) => executeEnhancedTool(analysis, options, swiftTypes, {
+        validatedCall: { name: "analyze_swift_types", input },
+        context,
+    }));
+    server.registerTool(xrefsToName.name, toolRegistrationOptions(xrefsToName), (input, context) => executeEnhancedTool(analysis, options, xrefsToName, {
+        validatedCall: { name: "find_xrefs_to_name", input },
+        context,
+    }));
+    server.registerTool(binaryOverview.name, toolRegistrationOptions(binaryOverview), (input, context) => executeEnhancedTool(analysis, options, binaryOverview, {
+        validatedCall: { name: "binary_overview", input },
+        context,
+    }));
+    server.registerTool(analyzeFunction.name, toolRegistrationOptions(analyzeFunction), (input, context) => executeEnhancedTool(analysis, options, analyzeFunction, {
+        validatedCall: { name: "analyze_function", input },
+        context,
+    }));
+    server.registerTool(inspectNativeApi.name, toolRegistrationOptions(inspectNativeApi), (input, context) => executeEnhancedTool(analysis, options, inspectNativeApi, {
+        validatedCall: { name: "inspect_native_api", input },
+        context,
+    }));
+    server.registerTool(traceFeature.name, toolRegistrationOptions(traceFeature), (input, context) => executeEnhancedTool(analysis, options, traceFeature, {
+        validatedCall: { name: "trace_feature", input },
+        context,
+    }));
+    server.registerTool(codeForString.name, toolRegistrationOptions(codeForString), (input, context) => executeEnhancedTool(analysis, options, codeForString, {
+        validatedCall: { name: "find_code_for_string", input },
+        context,
+    }));
+    server.registerTool(traceCallPath.name, toolRegistrationOptions(traceCallPath), (input, context) => executeEnhancedTool(analysis, options, traceCallPath, {
+        validatedCall: { name: "trace_call_path", input },
+        context,
+    }));
 };
-const registerEnhancedTool = (server, analysis, contract, registration) => {
-    const name = enhancedToolNameSchema.parse(contract.name);
-    server.registerTool(name, toolRegistrationOptions(contract), async (input, context) => {
-        const progress = mcpProgressReporter(context);
-        await progress.report({
-            phase: name,
-            completed: 0,
-            total: 1,
-            message: "started",
+const executeEnhancedTool = async (analysis, registration, contract, request) => {
+    const { validatedCall, context } = request;
+    const name = validatedCall.name;
+    const progress = mcpProgressReporter(context);
+    await progress.report({
+        phase: name,
+        completed: 0,
+        total: 1,
+        message: "started",
+    });
+    const parsedInput = validatedCall.input;
+    const parameters = jsonParameters(parsedInput);
+    const services = new EnhancedTools({
+        execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
+            ...executionOptions,
+            progress,
+        }),
+    });
+    const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall, context.mcpReq.signal));
+    await progress.report({
+        phase: name,
+        completed: 1,
+        total: 1,
+        message: result.ok ? "completed" : "failed",
+        terminal: true,
+    });
+    if (result.ok) {
+        const upstreamProfile = registration.analysisProfile?.();
+        const evidence = createEvidence(registration.activeTarget?.(), REA_WORKFLOW_PROVIDER, {
+            operation: name,
+            parameters,
+            result: result.value,
+            ...(upstreamProfile === undefined
+                ? {}
+                : {
+                    analysisProfile: workflowAnalysisProfile(upstreamProfile),
+                }),
+            confidence: "derived",
+            limitations: [
+                "Derived by an REA workflow from one or more provider observations.",
+            ],
         });
-        const validatedCall = parseEnhancedCall(name, input);
-        if (!validatedCall.ok)
-            return toCallToolResult(validatedCall, contract);
-        const parsedInput = validatedCall.value.input;
-        const parameters = jsonParameters(parsedInput);
-        const services = new EnhancedTools({
-            execute: (operation, operationParameters, executionOptions) => analysis.execute(operation, operationParameters, {
-                ...executionOptions,
-                progress,
-            }),
+        const recorded = registration.recordEvidence?.(evidence);
+        if (recorded !== undefined && !recorded.ok)
+            return toCallToolResult(recorded, contract);
+        const unknowns = recordWorkflowUnknowns({
+            name,
+            input: parameters,
+            result: result.value,
+            evidenceId: evidence.evidence_id,
+            recordUnknown: registration.recordUnknown,
         });
-        const result = await logToolExecution(registration.logger, name, () => services.executeValidated(validatedCall.value, context.mcpReq.signal));
-        await progress.report({
-            phase: name,
-            completed: 1,
-            total: 1,
-            message: result.ok ? "completed" : "failed",
-            terminal: true,
+        if (!unknowns.ok)
+            return toCallToolResult(unknowns, contract);
+        return toCallToolResult({ ok: true, value: evidence }, contract, {
+            evidenceResourcesAvailable: recorded !== undefined,
         });
-        if (result.ok) {
-            const upstreamProfile = registration.analysisProfile?.();
-            const evidence = createEvidence(registration.activeTarget?.(), REA_WORKFLOW_PROVIDER, {
-                operation: name,
-                parameters,
-                result: result.value,
-                ...(upstreamProfile === undefined
-                    ? {}
-                    : {
-                        analysisProfile: workflowAnalysisProfile(upstreamProfile),
-                    }),
-                confidence: "derived",
-                limitations: [
-                    "Derived by an REA workflow from one or more provider observations.",
-                ],
-            });
-            const recorded = registration.recordEvidence?.(evidence);
-            if (recorded !== undefined && !recorded.ok)
-                return toCallToolResult(recorded, contract);
-            const unknowns = recordWorkflowUnknowns({
-                name,
-                input: parameters,
-                result: result.value,
-                evidenceId: evidence.evidence_id,
-                recordUnknown: registration.recordUnknown,
-            });
-            if (!unknowns.ok)
-                return toCallToolResult(unknowns, contract);
-            return toCallToolResult({ ok: true, value: evidence }, contract, {
-                evidenceResourcesAvailable: recorded !== undefined,
-            });
-        }
-        return toCallToolResult(result, contract);
-    });
-};
-const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
-const ENHANCED_INPUT_PARSERS = {
-    swift_classes: (input) => safeParseToolInput(enhancedInputSchemas.swift_classes, input, "swift_classes"),
-    get_objc_classes: (input) => safeParseToolInput(enhancedInputSchemas.get_objc_classes, input, "get_objc_classes"),
-    get_objc_protocols: (input) => safeParseToolInput(enhancedInputSchemas.get_objc_protocols, input, "get_objc_protocols"),
-    batch_decompile: (input) => safeParseToolInput(enhancedInputSchemas.batch_decompile, input, "batch_decompile"),
-    get_call_graph: (input) => safeParseToolInput(enhancedInputSchemas.get_call_graph, input, "get_call_graph"),
-    analyze_swift_types: (input) => safeParseToolInput(enhancedInputSchemas.analyze_swift_types, input, "analyze_swift_types"),
-    find_xrefs_to_name: (input) => safeParseToolInput(enhancedInputSchemas.find_xrefs_to_name, input, "find_xrefs_to_name"),
-    binary_overview: (input) => safeParseToolInput(enhancedInputSchemas.binary_overview, input, "binary_overview"),
-    analyze_function: (input) => safeParseToolInput(enhancedInputSchemas.analyze_function, input, "analyze_function"),
-    inspect_native_api: (input) => safeParseToolInput(enhancedInputSchemas.inspect_native_api, input, "inspect_native_api"),
-    trace_feature: (input) => safeParseToolInput(enhancedInputSchemas.trace_feature, input, "trace_feature"),
-    find_code_for_string: (input) => safeParseToolInput(enhancedInputSchemas.find_code_for_string, input, "find_code_for_string"),
-    trace_call_path: (input) => safeParseToolInput(enhancedInputSchemas.trace_call_path, input, "trace_call_path"),
-};
-const parseEnhancedCall = (name, input) => {
-    switch (name) {
-        case "swift_classes":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.swift_classes(input), (value) => ({ name, input: value }));
-        case "get_objc_classes":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_objc_classes(input), (value) => ({ name, input: value }));
-        case "get_objc_protocols":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_objc_protocols(input), (value) => ({ name, input: value }));
-        case "batch_decompile":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.batch_decompile(input), (value) => ({ name, input: value }));
-        case "get_call_graph":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.get_call_graph(input), (value) => ({ name, input: value }));
-        case "analyze_swift_types":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_swift_types(input), (value) => ({ name, input: value }));
-        case "find_xrefs_to_name":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.find_xrefs_to_name(input), (value) => ({ name, input: value }));
-        case "binary_overview":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.binary_overview(input), (value) => ({ name, input: value }));
-        case "analyze_function":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.analyze_function(input), (value) => ({ name, input: value }));
-        case "inspect_native_api":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.inspect_native_api(input), (value) => ({ name, input: value }));
-        case "trace_feature":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_feature(input), (value) => ({ name, input: value }));
-        case "find_code_for_string":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.find_code_for_string(input), (value) => ({ name, input: value }));
-        case "trace_call_path":
-            return mapEnhancedCall(ENHANCED_INPUT_PARSERS.trace_call_path(input), (value) => ({ name, input: value }));
     }
+    return toCallToolResult(result, contract);
 };
-const mapEnhancedCall = (parsed, project) => parsed.ok ? ok(project(parsed.value)) : parsed;
+const jsonParameters = (input) => Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined));
 const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown, }) => {
     if (![
         "trace_feature",

package/dist/server/registerEvidenceTools.js

@@ -1,12 +1,11 @@
+import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { err } from "../domain/result.js";
+import { mcpProgressReporter } from "./mcpProgress.js";
 import { logToolExecution } from "./toolLogging.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { mcpProgressReporter } from "./mcpProgress.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
-import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
-import { err } from "../domain/result.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register provider-backed contracts that return atomic Evidence v2 observations. */
 export const registerEvidenceTools = (server, analysis, contracts, options) => {
     for (const contract of contracts) {
@@ -18,10 +17,7 @@ export const registerEvidenceTools = (server, analysis, contracts, options) => {
                 total: 1,
                 message: "started",
             });
-            const parsedInput = safeParseToolInput(contract.inputSchema, input, contract.name);
-            if (!parsedInput.ok)
-                return toCallToolResult(parsedInput, contract);
-            const parameters = jsonObjectSchema.parse(parsedInput.value);
+            const parameters = jsonObjectSchema.parse(input);
             if (options.permissionAuthority !== undefined) {
                 const request = permissionRequest(contract.name, parameters);
                 if (request !== undefined) {

package/dist/server/registerFunctionComparisonTool.js

@@ -1,33 +1,29 @@
-import { compareFunctions, functionComparisonInputSchema, } from "../domain/functionComparison.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { createEvidence } from "../domain/evidence.js";
+import { compareFunctions } from "../domain/functionComparison.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
-import { toCallToolResult } from "./toolResult.js";
 import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
+import { runDerivedOperation } from "./runDerivedOperation.js";
 import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
+import { FUNCTION_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { runDerivedOperation } from "./runDerivedOperation.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register explicit Evidence-backed function comparison. */
 export const registerFunctionComparisonTool = (server, session, contract) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input, context) => {
-        const parsedInput = safeParseToolInput(functionComparisonInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
         const expected = {
             operation: "analyze_function",
             predicate: "rea.analysis/v2",
         };
-        const left = resolveSessionEvidenceIds(session, parsed.left_evidence_ids, expected);
+        const left = resolveSessionEvidenceIds(session, input.left_evidence_ids, expected);
         if (!left.ok)
             return toCallToolResult(left, contract);
-        const right = resolveSessionEvidenceIds(session, parsed.right_evidence_ids, expected);
+        const right = resolveSessionEvidenceIds(session, input.right_evidence_ids, expected);
         if (!right.ok)
             return toCallToolResult(right, contract);
         const leftIds = left.value.map(({ evidence_id: id }) => id);
         const rightIds = right.value.map(({ evidence_id: id }) => id);
-        const computed = await runDerivedOperation(context, contract.name, () => compareFunctions(left.value, right.value, parsed.offset, parsed.limit));
+        const computed = await runDerivedOperation(context, contract.name, () => compareFunctions(left.value, right.value, input.offset, input.limit));
         if (!computed.ok)
             return toCallToolResult(computed, contract);
         const comparison = computed.value;
@@ -37,8 +33,8 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             parameters: {
                 left_evidence_ids: leftIds,
                 right_evidence_ids: rightIds,
-                offset: parsed.offset,
-                limit: parsed.limit,
+                offset: input.offset,
+                limit: input.limit,
             },
             result: jsonValueSchema.parse(comparison),
             confidence: "derived",
@@ -47,7 +43,7 @@ export const registerFunctionComparisonTool = (server, session, contract) => {
             evidenceLinks: [...leftIds, ...rightIds],
         });
         const recorded = recordDerivedEvidence(session, evidence, functionUnknownInput({
-            approved: parsed.unknown_registry_approved,
+            approved: input.unknown_registry_approved,
             status: comparison.status,
             leftIds,
             rightIds,

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",
@@ -144,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;
@@ -160,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",
@@ -173,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",
@@ -190,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;
@@ -209,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",
@@ -219,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,
@@ -235,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;
@@ -256,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",
@@ -266,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/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,
+        });
 };