rea-agents 3.0.0 → 3.2.0

package/dist/server/registerManagedWorkflowTools/projectManagedApplicationGraph.js

@@ -1,37 +1,30 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 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";
+import { 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 === undefined
             ? undefined
-            : resolveManagedArtifactEvidence(options.session, parsedInput.value.managed_artifact_evidence_id);
+            : resolveManagedArtifactEvidence(input.managed_artifact);
         if (managedArtifact !== undefined && !managedArtifact.ok)
             return toCallToolResult(managedArtifact, graphContract);
-        const managedMembers = parsedInput.value.managed_members_evidence_id === undefined
+        const managedMembers = input.managed_members === undefined
             ? undefined
-            : resolveManagedEvidence(options.session, [
-                parsedInput.value.managed_members_evidence_id,
-            ]);
+            : resolveManagedEvidence(input.managed_members);
         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 === undefined
             ? undefined
-            : resolveManagedBoundaryEvidence(options.session, parsedInput.value.managed_native_boundaries_evidence_id);
+            : resolveManagedBoundaryEvidence(input.managed_native_boundaries);
         if (managedBoundaries !== undefined && !managedBoundaries.ok)
             return toCallToolResult(managedBoundaries, graphContract);
         const parsed = {
-            limits: parsedInput.value.limits,
             managed_artifact: managedArtifact?.value[0],
             managed_members: managedMembers?.value[0],
             managed_native_boundaries: managedBoundaries?.value[0],
@@ -39,14 +32,12 @@ export const registerProjectManagedApplicationGraph = (server, options) => {
         const result = await logToolExecution(options.logger, graphContract.name, () => Promise.resolve(projectManagedApplicationGraphEvidence(parsed)));
         if (!result.ok)
             return toCallToolResult(result, graphContract);
-        const recordedSources = recordManagedSources(options.recordEvidence, sourceEvidence(parsed));
+        const recordedSources = recordSessionEvidenceSources(options.recordEvidence, sourceEvidence(parsed));
         if (!recordedSources.ok)
             return toCallToolResult(recordedSources, graphContract);
         const recorded = options.recordEvidence?.(result.value);
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, graphContract);
-        return toCallToolResult(result, graphContract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult(result, graphContract);
     });
 };

package/dist/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.js

@@ -1,50 +1,41 @@
+import { recordSessionEvidenceSources } from "../sessionEvidence.js";
 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";
+import { 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(input.managed_boundaries);
         if (!managedBoundaries.ok)
             return toCallToolResult(managedBoundaries, nativeVerificationContract);
-        const nativeObservations = resolveNativeEvidence(options.session, parsedInput.value.native_observation_evidence_ids);
+        const nativeObservations = resolveNativeEvidence(input.native_observations);
         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 parsed = {
-            ...referencedInput,
+            ...input,
             managed_boundaries: managedBoundary,
             native_observations: nativeObservations.value,
         };
         const result = await logToolExecution(options.logger, nativeVerificationContract.name, () => Promise.resolve(verifyManagedNativeBoundariesEvidence(parsed)));
         if (!result.ok)
             return toCallToolResult(result, nativeVerificationContract);
-        const recordedSources = recordManagedSources(options.recordEvidence, [
-            parsed.managed_boundaries,
-            ...parsed.native_observations,
-        ]);
+        const recordedSources = recordSessionEvidenceSources(options.recordEvidence, [parsed.managed_boundaries, ...parsed.native_observations]);
         if (!recordedSources.ok)
             return toCallToolResult(recordedSources, nativeVerificationContract);
         const verification = managedNativeVerificationResultSchema.parse(result.value.normalized_result);
         const unknown = verification.summary.unresolved > 0 ||
             verification.summary.contradicted > 0 ||
             verification.summary.native_body_unresolved > 0;
-        const output = parsed.unknown_registry_approved === true && unknown
+        const output = unknown
             ? options.recordEvidenceWithUnknown?.(result.value, {
-                approved: true,
                 question: "Which managed/native boundaries remain unresolved or contradicted by the supplied native Evidence?",
                 severity: "medium",
                 domain: "managed-native-verification",
@@ -56,7 +47,7 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
                 recommended_probes: [
                     {
                         operation: "inspect_managed_native_boundaries",
-                        rationale: "Repeat managed boundary inspection with complete ModuleRef, ImplMap, and native implementation pages.",
+                        rationale: "Review the inspection Evidence coverage and limit diagnostics; this operation has no page override, so unresolved declarations must remain unknown.",
                     },
                     {
                         operation: "analyze_function",
@@ -68,8 +59,6 @@ export const registerVerifyManagedNativeBoundaries = (server, options) => {
             : options.recordEvidence?.(result.value);
         if (output !== undefined && !output.ok)
             return toCallToolResult(output, nativeVerificationContract);
-        return toCallToolResult(result, nativeVerificationContract, {
-            evidenceResourcesAvailable: output !== undefined,
-        });
+        return toCallToolResult(result, nativeVerificationContract);
     });
 };

package/dist/server/registerOfficialTools.js

@@ -1,12 +1,11 @@
+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 { 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) {
@@ -14,16 +13,12 @@ export const registerOfficialTools = (server, analysis, options) => {
             logger: options.logger,
             activeTarget: options.activeTarget,
             recordEvidence: options.recordEvidence,
-            recordUnknown: options.recordUnknown,
         });
     }
 };
 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,
@@ -31,9 +26,6 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
             progress,
         });
         if (!result.ok) {
-            const unknownError = recordOfficialUnknown(input, result.error, contract, registration.recordUnknown);
-            if (unknownError !== undefined)
-                return toCallToolResult(unknownError, contract);
             return toCallToolResult(result, contract);
         }
         const evidence = createEvidence(result.value.subject ?? registration.activeTarget?.(), result.value.provider, {
@@ -50,9 +42,7 @@ const registerOfficialTool = (server, analysis, contract, registration) => {
         const recorded = registration.recordEvidence?.(evidence);
         if (recorded !== undefined && !recorded.ok)
             return toCallToolResult(recorded, contract);
-        return toCallToolResult({ ok: true, value: evidence }, contract, {
-            evidenceResourcesAvailable: recorded !== undefined,
-        });
+        return toCallToolResult({ ok: true, value: evidence }, contract);
     });
 };
 const runOfficialOperation = async (analysis, contract, arguments_, execution) => {
@@ -75,46 +65,13 @@ const runOfficialOperation = async (analysis, contract, arguments_, execution) =
     });
     return result;
 };
-const recordOfficialUnknown = (input, error, contract, recordUnknown) => {
-    if (!(error instanceof AnalysisCapabilityUnavailableError) ||
-        !approvedUnknownTracking(input) ||
-        recordUnknown === undefined)
-        return undefined;
-    const unknown = recordUnknown({
-        approved: true,
-        question: "The requested analysis is unavailable for the current target.",
-        severity: "medium",
-        domain: "analysis-capability",
-        supporting_evidence_ids: [],
-        contradicting_evidence_ids: [],
-        required_authority: "shipped-artifact",
-        required_confidence: "observed",
-        required_environment: null,
-        recommended_probes: [
-            {
-                operation: contract.name,
-                rationale: "Choose another analysis or target that can answer this question.",
-            },
-        ],
-        relationships: [],
-    });
-    if (!unknown.ok &&
-        !(unknown.error instanceof UnknownRegistryError &&
-            unknown.error.reason === "already-exists"))
-        return unknown;
-    return undefined;
-};
 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")
-            continue;
         projected[key] = jsonValueSchema.parse(parsed[key] ?? null);
     }
     return projected;
 };
-const approvedUnknownTracking = (input) => typeof input === "object" &&
-    input !== null &&
-    "unknown_registry_approved" in input &&
-    input.unknown_registry_approved === true;

package/dist/server/registerProcessComparisonTool.js

@@ -1,47 +1,50 @@
-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, parseEvidence, } 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 { recordDerivedEvidence } from "./recordDerivedEvidence.js";
+import { recordSessionEvidenceSources } from "./sessionEvidence.js";
+import { runDerivedOperation } from "./runDerivedOperation.js";
 import { PROCESS_PROVIDER } from "./sessionToolPolicies.js";
-import { toCallToolResult } from "./toolResult.js";
 import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
-import { runDerivedOperation } from "./runDerivedOperation.js";
-import { safeParseToolInput } from "./toolInputValidation.js";
-import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
+import { toCallToolResult } from "./toolResult.js";
 const PROCESS_CAPTURE_EVIDENCE = {
     operation: "capture_process_scenario",
-    predicate: "rea.process-capture/v4",
+    predicate: "rea.process-capture",
 };
 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);
-        if (!leftRecord.ok)
-            return toCallToolResult(leftRecord, contract);
-        const rightRecord = resolveSessionEvidenceIds(session, [parsed.right_evidence_id], PROCESS_CAPTURE_EVIDENCE);
-        if (!rightRecord.ok)
-            return toCallToolResult(rightRecord, contract);
+        let leftRecord;
+        let rightRecord;
+        try {
+            leftRecord = parseEvidence(input.left);
+            rightRecord = parseEvidence(input.right);
+            if (leftRecord.operation !== PROCESS_CAPTURE_EVIDENCE.operation ||
+                rightRecord.operation !== PROCESS_CAPTURE_EVIDENCE.operation ||
+                leftRecord.predicate_type !== PROCESS_CAPTURE_EVIDENCE.predicate ||
+                rightRecord.predicate_type !== PROCESS_CAPTURE_EVIDENCE.predicate)
+                throw new TypeError("Expected process capture Evidence");
+        }
+        catch (cause) {
+            return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error ? cause.message : "Invalid Evidence")), contract);
+        }
         let comparison;
         let leftCapture;
         let rightCapture;
         try {
-            leftCapture = parseProcessCapture(leftRecord.value[0]?.normalized_result);
-            rightCapture = parseProcessCapture(rightRecord.value[0]?.normalized_result);
+            leftCapture = parseProcessCapture(leftRecord.normalized_result);
+            rightCapture = parseProcessCapture(rightRecord.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)
@@ -51,35 +54,38 @@ export const registerProcessComparisonTool = (server, session, contract, now = D
         catch (cause) {
             return toCallToolResult(err(new EvidenceIntegrityError(cause instanceof Error
                 ? cause.message
-                : "Invalid Process Capture v4")), contract);
+                : "Invalid process capture")), contract);
         }
         const evidence = createEvidence(undefined, PROCESS_PROVIDER, {
-            predicateType: parsed.trace_spec === undefined
-                ? "rea.process-comparison/v3"
-                : "rea.process-comparison/v4",
+            predicateType: "rea.process-comparison",
             operation: contract.name,
             parameters: {
-                left_evidence_id: parsed.left_evidence_id,
-                right_evidence_id: parsed.right_evidence_id,
+                left_evidence_id: leftRecord.evidence_id,
+                right_evidence_id: rightRecord.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],
+            locations: sourceLocations(leftRecord.locations, rightRecord.locations),
+            evidenceLinks: [leftRecord.evidence_id, rightRecord.evidence_id],
         });
-        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput(parsed, comparison)), contract);
+        const recordedSources = recordSessionEvidenceSources((evidence) => session.recordEvidence(evidence), [leftRecord, rightRecord]);
+        if (!recordedSources.ok)
+            return toCallToolResult(recordedSources, contract);
+        return toCallToolResult(recordDerivedEvidence(session, evidence, comparisonUnknownInput({
+            left_evidence_id: leftRecord.evidence_id,
+            right_evidence_id: rightRecord.evidence_id,
+        }, comparison)), contract);
     });
 };
 const comparisonUnknownInput = (parsed, comparison) => {
-    if (parsed.unknown_registry_approved !== true ||
-        comparison.status === "unchanged")
+    if (comparison.status === "unchanged")
         return undefined;
     const differingScopes = [
         ["terminal", comparison.terminal],
@@ -94,7 +100,6 @@ const comparisonUnknownInput = (parsed, comparison) => {
         .map(([scope]) => scope)
         .join(", ");
     return {
-        approved: true,
         question: `Process captures disagree across: ${differingScopes}`,
         severity: "high",
         domain: "process-comparison",

package/dist/server/registerPrompts.js

@@ -39,12 +39,7 @@ const promptArgumentsSchema = (contract, completion) => {
     return z.object(shape);
 };
 const argumentSchema = (argument, completion) => {
-    const value = z
-        .string()
-        .trim()
-        .min(1)
-        .max(4_096)
-        .describe(argument.description);
+    const value = z.string().trim().min(1).describe(argument.description);
     const kind = argument.completion;
     const completed = kind === undefined
         ? value
@@ -53,15 +48,22 @@ const argumentSchema = (argument, completion) => {
         ]);
     return argument.required ? completed : completed.optional();
 };
-const promptResult = (contract, arguments_) => ({
-    description: contract.description,
-    messages: [
-        {
-            role: "user",
-            content: {
-                type: "text",
-                text: renderGuidedPrompt(contract, promptValuesSchema.parse(arguments_)),
+const promptResult = (contract, arguments_) => {
+    const values = promptValuesSchema.parse(arguments_);
+    for (const [name, argument] of Object.entries(contract.arguments))
+        if (argument.required &&
+            (values[name] === undefined || values[name]?.trim().length === 0))
+            throw new TypeError(`Invalid arguments: ${name} must not be empty`);
+    return {
+        description: contract.description,
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: renderGuidedPrompt(contract, values),
+                },
             },
-        },
-    ],
-});
+        ],
+    };
+};

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);
     });
 };