rea-agents 2.5.0 → 3.1.0

package/dist/server/registerEnhancedTools.js

@@ -1,137 +1,137 @@
 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"),
-    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 "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", "find_code_for_string", "trace_call_path"].includes(name) ||
+    if (![
+        "trace_feature",
+        "find_code_for_string",
+        "trace_call_path",
+        "inspect_native_api",
+    ].includes(name) ||
         input.unknown_registry_approved !== true ||
         recordUnknown === undefined ||
         typeof result !== "object" ||
@@ -146,7 +146,7 @@ const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown
             approved: true,
             question,
             severity: "medium",
-            domain: "control-flow",
+            domain: name === "inspect_native_api" ? "native-api" : "control-flow",
             supporting_evidence_ids: [evidenceId],
             contradicting_evidence_ids: [],
             required_authority: "shipped-artifact",
@@ -155,7 +155,9 @@ const recordWorkflowUnknowns = ({ name, input, result, evidenceId, recordUnknown
             recommended_probes: [
                 {
                     operation: name,
-                    rationale: "Continue with a larger bounded budget.",
+                    rationale: name === "inspect_native_api"
+                        ? "Confirm the unsupported boundary with a capable provider or ABI probe."
+                        : "Continue with a larger bounded budget.",
                 },
             ],
             relationships: [],

package/dist/server/registerEvidenceResources.js

@@ -4,13 +4,12 @@ import canonicalize from "canonicalize";
 import { registerJavaScriptApplicationGraphResource } from "./registerJavaScriptApplicationGraphResource.js";
 import { registerReconstructionObligationLedgerResource } from "./registerReconstructionObligationLedgerResource.js";
 import { registerReconstructionReadinessResource } from "./registerReconstructionReadinessResource.js";
-const evidenceUri = (evidenceId) => `rea://evidence/${evidenceId}`;
 /** Expose immutable session-owned Evidence v2 records as MCP resources. */
 export const registerEvidenceResources = (server, session) => {
     registerReconstructionCoverageResource(server, session);
     registerInvestigationWorkspaceResource(server, session);
     registerSessionEvidenceResource(server, session);
-    registerActiveResidualUnknownsResource(server, session);
+    registerEvidenceBundleResource(server, session);
     registerAnalysisSnapshotResource(server, session);
     registerArtifactPageResource(server, session);
     registerFunctionDossierResource(server, session);
@@ -19,20 +18,15 @@ export const registerEvidenceResources = (server, session) => {
     registerReconstructionReadinessResource(server, session);
     registerJavaScriptApplicationGraphResource(server, session);
     registerResidualUnknownResource(server, session);
+    session.onAnalysisSnapshotChanged?.(() => {
+        void server.server
+            .sendResourceUpdated({ uri: "rea://snapshot/current" })
+            .catch(() => undefined);
+    });
 };
 const registerReconstructionCoverageResource = (server, session) => {
     server.registerResource("reconstruction-coverage-revision", new ResourceTemplate("rea://reconstruction-coverage/{workspaceId}/revision/{revision}", {
-        list: () => ({
-            resources: session
-                .reconstructionCoverageWorkspaces()
-                .map((workspace) => ({
-                uri: coverageWorkspaceUri(workspace.workspace_id, workspace.revision),
-                name: `${workspace.workspace_id} revision ${String(workspace.revision)}`,
-                title: `${workspace.name} coverage revision ${String(workspace.revision)}`,
-                description: "Immutable evidence-backed reconstruction coverage workspace revision.",
-                mimeType: "application/json",
-            })),
-        }),
+        list: undefined,
     }), {
         title: "Reconstruction coverage revision",
         description: "Canonical CAS-linked surfaces, owners, claims, verifiers, evidence, and completion boundaries.",
@@ -50,27 +44,7 @@ const registerReconstructionCoverageResource = (server, session) => {
 };
 const registerInvestigationWorkspaceResource = (server, session) => {
     server.registerResource("investigation-workspace-revision", new ResourceTemplate("rea://workspace/{workspaceId}/revision/{revision}", {
-        list: () => ({
-            resources: session.investigationWorkspaces().map((workspace) => ({
-                uri: workspaceUri(workspace.workspace_id, workspace.revision),
-                name: `${workspace.workspace_id} revision ${String(workspace.revision)}`,
-                title: `${workspace.name} revision ${String(workspace.revision)}`,
-                description: "Immutable CAS-linked investigation workspace revision.",
-                mimeType: "application/json",
-            })),
-        }),
-        complete: {
-            workspaceId: (prefix) => [
-                ...new Set(session
-                    .investigationWorkspaces()
-                    .map(({ workspace_id }) => workspace_id)),
-            ].filter((workspaceId) => workspaceId.startsWith(prefix)),
-            revision: (prefix, context) => session
-                .investigationWorkspaces()
-                .filter(({ workspace_id }) => context?.arguments?.workspaceId === workspace_id)
-                .map(({ revision }) => String(revision))
-                .filter((revision) => revision.startsWith(prefix)),
-        },
+        list: undefined,
     }), {
         title: "Investigation workspace revision",
         description: "Immutable session-retained workspace with CAS linkage.",
@@ -88,21 +62,7 @@ const registerInvestigationWorkspaceResource = (server, session) => {
 };
 const registerSessionEvidenceResource = (server, session) => {
     server.registerResource("session-evidence", new ResourceTemplate("rea://evidence/{evidenceId}", {
-        list: () => ({
-            resources: session.exportEvidenceBundle().records.map((evidence) => ({
-                uri: evidenceUri(evidence.evidence_id),
-                name: evidence.evidence_id,
-                title: `${evidence.operation} evidence`,
-                description: `Session-owned Evidence v2 record for ${evidence.operation}.`,
-                mimeType: "application/json",
-            })),
-        }),
-        complete: {
-            evidenceId: (prefix) => session
-                .exportEvidenceBundle()
-                .records.map(({ evidence_id }) => evidence_id)
-                .filter((evidenceId) => evidenceId.startsWith(prefix)),
-        },
+        list: undefined,
     }), {
         title: "Session evidence",
         description: "Immutable Evidence v2 records owned by this REA session.",
@@ -125,42 +85,52 @@ const registerSessionEvidenceResource = (server, session) => {
         };
     });
 };
-const registerActiveResidualUnknownsResource = (server, session) => {
-    server.registerResource("active-residual-unknowns", "rea://unknowns/active", {
-        title: "Active residual unknowns",
-        description: "Current unresolved session-owned residual unknown heads.",
+const registerEvidenceBundleResource = (server, session) => {
+    server.registerResource("evidence-bundle", new ResourceTemplate("rea://evidence-bundle/{bundleDigest}", {
+        list: undefined,
+    }), {
+        title: "Evidence bundle",
+        description: "Immutable session-retained canonical Evidence v2 bundle.",
         mimeType: "application/json",
-    }, (uri) => jsonResource(uri.href, session.listUnknowns().filter(({ status }) => status !== "resolved")));
+    }, (uri, variables) => {
+        const digest = stringVariable(variables.bundleDigest, uri.href);
+        if (!/^[a-f0-9]{64}$/u.test(digest))
+            throw new ResourceNotFoundError(uri.href);
+        const text = session.retainedEvidenceBundle(digest);
+        if (text === undefined)
+            throw new ResourceNotFoundError(uri.href);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text,
+                },
+            ],
+        };
+    });
 };
 const registerAnalysisSnapshotResource = (server, session) => {
-    server.registerResource("analysis-snapshot", new ResourceTemplate("rea://snapshot/{snapshotDigest}", {
-        list: () => {
-            const snapshot = session.exportAnalysisSnapshot();
-            if (!snapshot.ok)
-                return { resources: [] };
-            const digest = contentDigest(snapshot.value);
-            return {
-                resources: [
-                    {
-                        uri: `rea://snapshot/${digest}`,
-                        name: digest,
-                        title: "Current analysis snapshot",
-                        description: "Immutable projection of the current target cache.",
-                        mimeType: "application/json",
-                    },
-                ],
-            };
-        },
-    }), {
+    server.registerResource("analysis-snapshot", "rea://snapshot/current", {
         title: "Analysis snapshot",
-        description: "Current provider-neutral analysis snapshot by content digest.",
+        description: "Mutable provider-neutral analysis snapshot for the current native target.",
         mimeType: "application/json",
-    }, (uri, variables) => {
-        const requested = stringVariable(variables.snapshotDigest, uri.href);
+    }, (uri) => {
         const snapshot = session.exportAnalysisSnapshot();
-        if (!snapshot.ok || contentDigest(snapshot.value) !== requested)
-            throw new ResourceNotFoundError(uri.href);
-        return jsonResource(uri.href, snapshot.value);
+        if (!snapshot.ok)
+            return jsonResource(uri.href, {
+                state: "unavailable",
+                reason: snapshot.error.message,
+                remediation: "Open a native target with a concrete analysis profile. After metadata mutation, call open_binary again for the current target to begin a fresh cache.",
+            });
+        return jsonResource(uri.href, {
+            state: "available",
+            target: snapshot.value.target,
+            profile: snapshot.value.binding,
+            content_digest: contentDigest(snapshot.value),
+            entry_count: snapshot.value.entries.length,
+            snapshot: snapshot.value,
+        });
     });
 };
 const registerArtifactPageResource = (server, session) => {
@@ -221,7 +191,6 @@ const registerEvidenceSectionResource = (server, session) => {
     server.registerResource("evidence-section", new ResourceTemplate("rea://evidence/{evidenceId}/section/{section}", {
         list: undefined,
         complete: {
-            evidenceId: (prefix) => evidenceIds(session, prefix),
             section: (prefix) => EVIDENCE_SECTIONS.filter((section) => section.startsWith(prefix)),
         },
     }), {
@@ -251,21 +220,7 @@ const registerEvidenceSectionResource = (server, session) => {
 };
 const registerResidualUnknownResource = (server, session) => {
     server.registerResource("residual-unknown", new ResourceTemplate("rea://unknown/{unknownId}", {
-        list: () => ({
-            resources: session.listUnknowns().map((unknown) => ({
-                uri: `rea://unknown/${unknown.unknown_id}`,
-                name: unknown.unknown_id,
-                title: unknown.question,
-                description: `Current ${unknown.status} residual unknown revision.`,
-                mimeType: "application/json",
-            })),
-        }),
-        complete: {
-            unknownId: (prefix) => session
-                .listUnknowns()
-                .map(({ unknown_id }) => unknown_id)
-                .filter((unknownId) => unknownId.startsWith(prefix)),
-        },
+        list: undefined,
     }), {
         title: "Residual unknown",
         description: "Current session-owned residual unknown head.",
@@ -283,8 +238,6 @@ const registerResidualUnknownResource = (server, session) => {
         return jsonResource(uri.href, { current: unknown, history });
     });
 };
-const coverageWorkspaceUri = (workspaceId, revision) => `rea://reconstruction-coverage/${workspaceId}/revision/${String(revision)}`;
-const workspaceUri = (workspaceId, revision) => `rea://workspace/${workspaceId}/revision/${String(revision)}`;
 const EVIDENCE_SECTIONS = [
     "result",
     "terminal",
@@ -295,10 +248,6 @@ const EVIDENCE_SECTIONS = [
     "occurrences",
     "edges",
 ];
-const evidenceIds = (session, prefix) => session
-    .exportEvidenceBundle()
-    .records.map(({ evidence_id }) => evidence_id)
-    .filter((evidenceId) => evidenceId.startsWith(prefix));
 const stringVariable = (value, uri) => {
     if (typeof value !== "string")
         throw new ResourceNotFoundError(uri);

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,