rea-agents 3.0.0 → 3.1.0

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) => {

package/dist/server/registerReplayMachineTool.js

@@ -1,20 +1,14 @@
 import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
-import { replayMachineRunInputSchema, runReplayMachine, } from "../domain/replayMachineRun.js";
+import { runReplayMachine } from "../domain/replayMachineRun.js";
 import { ok } from "../domain/result.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { logToolExecution } from "./toolLogging.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-const contract = SESSION_TOOL_CONTRACTS.find(({ name }) => name === "run_replay_machine");
-if (contract === undefined)
-    throw new TypeError("Missing run_replay_machine tool contract");
+import { toCallToolResult } from "./toolResult.js";
+const contract = SESSION_TOOL_CONTRACTS[18];
 /** Register direct execution-free finite replay-machine evaluation. */
 export const registerReplayMachineTool = (server, logger) => {
     server.registerTool(contract.name, toolRegistrationOptions(contract), async (input) => {
-        const parsed = safeParseToolInput(replayMachineRunInputSchema, input, contract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, contract);
-        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(ok(runReplayMachine(parsed.value))));
+        const result = await logToolExecution(logger, contract.name, () => Promise.resolve(ok(runReplayMachine(input))));
         return toCallToolResult(result, contract);
     });
 };

package/dist/server/registerSessionRecordTools.js

@@ -1,9 +1,7 @@
 import { readEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js";
-import { exportEvidenceBundleInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, snapshotEvidenceBundleInputSchema, SESSION_TOOL_CONTRACTS, verifyUnknownResolutionInputSchema, } from "../contracts/toolContracts.js";
+import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
 import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
-import { recordUnknownInputSchema, updateUnknownInputSchema, } from "../domain/residualUnknown.js";
 import { err, ok } from "../domain/result.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
 import { toCallToolResult } from "./toolResult.js";
 /** Register evidence bundle import and export tools. */
@@ -11,24 +9,56 @@ export const registerEvidenceTools = (registration) => {
     registerExportEvidenceTool(registration);
     registerImportEvidenceTool(registration);
     registerSnapshotEvidenceTool(registration);
+    registerReleaseEvidenceTool(registration);
+};
+const registerReleaseEvidenceTool = ({ server, session, releaseContract, permissionAuthority, }) => {
+    server.registerTool(releaseContract.name, toolRegistrationOptions(releaseContract), async (input) => {
+        const denied = await authorizeEvidenceWrite({
+            authority: permissionAuthority,
+            operationIdentity: `release_evidence:${input.bundle_digest}`,
+        });
+        if (denied !== undefined)
+            return toCallToolResult(denied, releaseContract);
+        const released = session.releaseEvidenceBundle(input.bundle_digest);
+        if (released)
+            void server.server
+                .sendResourceUpdated({
+                uri: `rea://evidence-bundle/${input.bundle_digest}`,
+            })
+                .catch(() => undefined);
+        return toCallToolResult(ok({
+            bundle_digest: input.bundle_digest,
+            released,
+        }), releaseContract);
+    });
+};
+const authorizeEvidenceWrite = async ({ authority, operationIdentity, }) => {
+    if (authority === undefined)
+        return undefined;
+    const authorized = await authority.authorize({
+        capability: "evidence_write",
+        roots: [],
+        executables: [],
+        environment_names: [],
+        network: "none",
+        mount: false,
+        operation_identity: operationIdentity,
+    }, "write");
+    return authorized.ok ? undefined : permissionFailure(authorized);
 };
 const registerExportEvidenceTool = ({ server, session, exportContract, filePolicy, permissionAuthority, }) => {
     server.registerTool(exportContract.name, toolRegistrationOptions(exportContract), async (input) => {
-        const parsedInput = safeParseToolInput(exportEvidenceBundleInputSchema, input, exportContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, exportContract);
-        const parsed = parsedInput.value;
         const bundle = session.exportEvidenceBundle();
         const denied = await authorizeEvidencePath({
             authority: permissionAuthority,
             capability: "evidence_write",
-            path: parsed.path,
+            path: input.path,
             access: "write",
-            operationIdentity: `export_evidence:${parsed.path}`,
+            operationIdentity: `export_evidence:${input.path}`,
         });
         if (denied !== undefined)
             return toCallToolResult(denied, exportContract);
-        const written = await writeEvidenceBundle(bundle, parsed.path, parsed.overwrite, filePolicy);
+        const written = await writeEvidenceBundle(bundle, input.path, input.overwrite, filePolicy);
         return written.ok
             ? toCallToolResult(ok({
                 path: written.value.path,
@@ -40,10 +70,7 @@ const registerExportEvidenceTool = ({ server, session, exportContract, filePolic
     });
 };
 const registerSnapshotEvidenceTool = ({ server, session, snapshotContract, }) => {
-    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), (input) => {
-        const parsed = safeParseToolInput(snapshotEvidenceBundleInputSchema, input, snapshotContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, snapshotContract);
+    server.registerTool(snapshotContract.name, toolRegistrationOptions(snapshotContract), () => {
         const snapshot = session.snapshotEvidenceBundle();
         if (!snapshot.ok)
             return toCallToolResult(snapshot, snapshotContract);
@@ -53,6 +80,8 @@ const registerSnapshotEvidenceTool = ({ server, session, snapshotContract, }) =>
             bytes: snapshot.value.bytes,
             records: snapshot.value.records,
             unknowns: snapshot.value.unknowns,
+            scope: snapshot.value.scope,
+            survives_session: snapshot.value.survivesSession,
             bundle_uri: snapshot.value.uri,
         };
         return toCallToolResult(ok(value), snapshotContract, {
@@ -68,10 +97,7 @@ const registerSnapshotEvidenceTool = ({ server, session, snapshotContract, }) =>
 };
 const registerImportEvidenceTool = ({ server, session, importContract, filePolicy, permissionAuthority, }) => {
     server.registerTool(importContract.name, toolRegistrationOptions(importContract), async (input) => {
-        const parsedInput = safeParseToolInput(importEvidenceBundleInputSchema, input, importContract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, importContract);
-        const path = parsedInput.value.path;
+        const path = input.path;
         const denied = await authorizeEvidencePath({
             authority: permissionAuthority,
             capability: "evidence_read",
@@ -84,15 +110,20 @@ const registerImportEvidenceTool = ({ server, session, importContract, filePolic
         const loaded = await readEvidenceBundle(path, filePolicy);
         if (!loaded.ok)
             return toCallToolResult(loaded, importContract);
+        const retainedUnknownRevisions = new Set(session
+            .exportEvidenceBundle()
+            .unknowns.map((unknown) => unknownRevisionKey(unknown)));
         const imported = session.importEvidenceBundle(loaded.value);
         return imported.ok
             ? toCallToolResult(ok({
                 imported: imported.value,
+                unknowns_added: loaded.value.unknowns.filter((unknown) => !retainedUnknownRevisions.has(unknownRevisionKey(unknown))).length,
                 total: session.exportEvidenceBundle().records.length,
             }), importContract)
             : toCallToolResult(imported, importContract);
     });
 };
+const unknownRevisionKey = (unknown) => `${unknown.unknown_id}:${String(unknown.revision)}`;
 const authorizeEvidencePath = async (input) => {
     if (input.authority === undefined)
         return undefined;
@@ -108,16 +139,10 @@ const authorizeEvidencePath = async (input) => {
     return authorized.ok ? undefined : permissionFailure(authorized);
 };
 /** Register residual-unknown query and mutation tools. */
-export const registerUnknownTools = ({ server, session, contracts, }) => {
+const registerListUnknownsTool = ({ server, session, contracts, }) => {
     const listContract = contracts[14];
-    const recordContract = contracts[15];
-    const updateContract = contracts[16];
-    const verifyContract = contracts[17];
     server.registerTool(listContract.name, toolRegistrationOptions(listContract), (input) => {
-        const parsed = safeParseToolInput(listUnknownsInputSchema, input, listContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, listContract);
-        const filters = parsed.value;
+        const filters = input;
         const all = session.listUnknowns({
             ...(filters.status === undefined ? {} : { status: filters.status }),
             ...(filters.severity === undefined
@@ -149,11 +174,11 @@ export const registerUnknownTools = ({ server, session, contracts, }) => {
             })),
         });
     });
+};
+const registerRecordUnknownTool = ({ server, session, contracts, }) => {
+    const recordContract = contracts[15];
     server.registerTool(recordContract.name, toolRegistrationOptions(recordContract), (input) => {
-        const parsed = safeParseToolInput(recordUnknownInputSchema, input, recordContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, recordContract);
-        const result = session.recordUnknown(parsed.value);
+        const result = session.recordUnknown(input);
         return result.ok
             ? toCallToolResult(result, recordContract, {
                 resourceLinks: [
@@ -166,11 +191,11 @@ export const registerUnknownTools = ({ server, session, contracts, }) => {
             })
             : toCallToolResult(result, recordContract);
     });
+};
+const registerUpdateUnknownTool = ({ server, session, contracts, }) => {
+    const updateContract = contracts[16];
     server.registerTool(updateContract.name, toolRegistrationOptions(updateContract), (input) => {
-        const parsed = safeParseToolInput(updateUnknownInputSchema, input, updateContract.name);
-        if (!parsed.ok)
-            return toCallToolResult(parsed, updateContract);
-        const result = session.updateUnknown(parsed.value);
+        const result = session.updateUnknown(input);
         if (result.ok)
             void server.server
                 .sendResourceUpdated({
@@ -189,12 +214,16 @@ export const registerUnknownTools = ({ server, session, contracts, }) => {
             })
             : toCallToolResult(result, updateContract);
     });
-    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => {
-        const parsed = safeParseToolInput(verifyUnknownResolutionInputSchema, input, verifyContract.name);
-        return parsed.ok
-            ? toCallToolResult(session.verifyUnknownResolution(parsed.value.unknown_id), verifyContract)
-            : toCallToolResult(parsed, verifyContract);
-    });
+};
+const registerVerifyUnknownTool = ({ server, session, contracts, }) => {
+    const verifyContract = contracts[17];
+    server.registerTool(verifyContract.name, toolRegistrationOptions(verifyContract), (input) => toCallToolResult(session.verifyUnknownResolution(input.unknown_id), verifyContract));
+};
+export const registerUnknownTools = (registration) => {
+    registerListUnknownsTool(registration);
+    registerRecordUnknownTool(registration);
+    registerUpdateUnknownTool(registration);
+    registerVerifyUnknownTool(registration);
 };
 const permissionFailure = (failure) => {
     if (failure.ok)

package/dist/server/registerSessionStatusTool.js

@@ -1,53 +1,38 @@
+import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
 import { binarySessionInputSchema, SESSION_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
-import { toCallToolResult } from "./toolResult.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
-import { buildCapabilityInventory } from "../application/CapabilityInventory.js";
+import { mcpClientMetadata } from "./mcpClientMetadata.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
+import { toCallToolResult } from "./toolResult.js";
 /** Register the read-only provider and target status operation. */
 export const registerSessionStatusTool = (options) => {
     const { server, session, contract, startedAt, availabilityPolicy } = options;
-    server.registerTool(contract.name, toolRegistrationOptions(contract), (input) => {
-        const parsedInput = safeParseToolInput(binarySessionInputSchema, input, contract.name);
-        if (!parsedInput.ok)
-            return toCallToolResult(parsedInput, contract);
-        const parsed = parsedInput.value;
-        const client = server.server.getClientVersion();
-        const clientCapabilities = server.server.getClientCapabilities();
-        const clientFeatures = {
-            elicitation_form: clientCapabilities?.elicitation?.form !== undefined,
-            elicitation_url: clientCapabilities?.elicitation?.url !== undefined,
-            roots: clientCapabilities?.roots !== undefined,
-            sampling: clientCapabilities?.sampling !== undefined,
-        };
+    server.registerTool(contract.name, toolRegistrationOptions(contract), (input, context) => {
+        const { client, clientFeatures, protocolVersion } = mcpClientMetadata(context);
         const status = session.status();
         const statusObject = jsonObjectSchema.parse(status);
         const toolAvailability = buildCapabilityInventory(status, availabilityPolicy(), clientFeatures);
         const serverIdentity = createServerIdentity({
             startedAt,
             expected: {
-                ...(parsed.expected_package_version === undefined
+                ...(input.expected_package_version === undefined
                     ? {}
-                    : { package_version: parsed.expected_package_version }),
-                ...(parsed.expected_catalog_digest === undefined
+                    : { package_version: input.expected_package_version }),
+                ...(input.expected_catalog_digest === undefined
                     ? {}
-                    : { catalog_digest: parsed.expected_catalog_digest }),
-                ...(parsed.expected_server_path === undefined
+                    : { catalog_digest: input.expected_catalog_digest }),
+                ...(input.expected_server_path === undefined
                     ? {}
-                    : { server_path: parsed.expected_server_path }),
+                    : { server_path: input.expected_server_path }),
             },
             ...(client === undefined ? {} : { client }),
-            ...(server.server.getNegotiatedProtocolVersion() === undefined
-                ? {}
-                : {
-                    protocolVersion: server.server.getNegotiatedProtocolVersion(),
-                }),
+            ...(protocolVersion === undefined ? {} : { protocolVersion }),
         });
         return toCallToolResult({
             ok: true,
             value: projectSessionStatus({
-                input: parsed,
+                input: input,
                 status: statusObject,
                 toolAvailability,
                 serverIdentity,