import { fileSubjectTarget } from "../../fixtures/evidenceSubject.js"; import { unknownTarget } from "../../../src/domain/targetIdentity.js"; import { withCanonicalOutputSchema } from "../../fixtures/canonicalOutputSchema.js"; import { Client, InMemoryTransport } from "@modelcontextprotocol/client"; import { expect, it } from "vitest"; import { writeFile } from "node:fs/promises"; import { join } from "node:path"; import { FUNCTION_COMPARISON_EXAMPLE } from "../../../src/contracts/functionComparisonExample.js"; import { createEvidence, parseEvidence, type Evidence, } from "../../../src/domain/evidence.js"; import { createEvidenceBundle } from "../../../src/domain/evidenceBundle.js"; import { createServer } from "../../../src/server/createServer.js"; import { createTestBinarySession } from "../../fixtures/binarySession.js"; import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; import { createMcpSchemaValidation } from "../../fixtures/mcpSchemaValidation.js"; import { parseMcpToolError } from "../../fixtures/mcpToolError.js"; const fixture = FUNCTION_COMPARISON_EXAMPLE.left; const subject = fileSubjectTarget(fixture.subject); const selected = ( operation: string, result: Evidence["normalized_result"], predicateType: string, ) => createEvidence(subject, fixture.provider, { operation, parameters: {}, result, predicateType, confidence: "observed", authority: "shipped-artifact", }); const wrongMatchingPredicate = (matching: Evidence) => createEvidence(unknownTarget("not-observed"), matching.provider, { operation: matching.operation, parameters: matching.parameters, result: matching.normalized_result, predicateType: "rea.analysis", confidence: matching.confidence, authority: matching.authority, evidenceLinks: matching.evidence_links, }); const expectRetainedMatchingInputs = ( tool: Awaited>["tools"][number] | undefined, selected: { readonly kind: string; readonly evidence_id: string }, validation: ReturnType, ): void => { if (tool === undefined) throw new Error("Missing advertised matching schema"); expect(tool.inputSchema.properties).toMatchObject({ left: { description: expect.stringContaining("list_procedures Evidence") }, right: { description: expect.stringContaining("list_procedures Evidence") }, left_observations: { type: "array" }, }); const validate = validation.getValidator(tool.inputSchema); expect(validate({ left: selected, right: selected }).valid).toBe(true); expect(validate({ left: [], right: selected }).valid).toBe(false); expect(validate({ left: selected, right: [] }).valid).toBe(false); }; it.each(["compact"] as const)( "validates native parent predicates across public sources (%s schema)", async (profile) => { const session = createTestBinarySession(() => { throw new Error("No provider should start"); }); const server = createServer( { kind: "session", session }, { environment: { ...process.env, REA_MCP_OUTPUT_SCHEMA_PROFILE: profile }, }, ); const validation = createMcpSchemaValidation(); const client = new Client( { name: "native-view-identity", version: "1" }, { jsonSchemaValidator: validation }, ); const [ct, st] = InMemoryTransport.createLinkedPair(); const root = await createTestTempDirectory("rea-native-view-identity-"); try { await server.connect(st); await client.connect(ct); const definitions = new Map( (await client.listTools()).tools.map((tool) => [tool.name, tool]), ); const call = (name: string, args: Record) => { const toolDefinition = definitions.get(name); if (toolDefinition === undefined) throw new Error(`Missing ${name}`); return client.callTool( { name, arguments: args }, { toolDefinition: withCanonicalOutputSchema(toolDefinition) }, ); }; const inventory = selected( "list_procedures", [{ address: "0x1000", value: "main" }], "rea.analysis", ); expect(session.recordEvidence(inventory).ok).toBe(true); const retained = { kind: "retained-evidence", evidence_id: inventory.evidence_id, }; expectRetainedMatchingInputs( definitions.get("match_native_functions"), retained, validation, ); const matchingResult = await call("match_native_functions", { left: retained, right: retained, detail: "complete", }); expect( matchingResult.isError, JSON.stringify(matchingResult.content), ).not.toBe(true); const matching = parseEvidence(matchingResult.structuredContent); expect(matching.predicate_type).toBe("rea.native-function-matching"); const wrongMatching = wrongMatchingPredicate(matching); const graph = { graph: { "0": [ { address: "0x1000", status: "ok", calls: [], relationship_coverage: { status: "complete" }, }, ], }, limitations: [], }; const cases = [ { good: selected( "analyze_function", fixture.normalized_result, "rea.analysis", ), bad: selected( "analyze_function", fixture.normalized_result, "rea.unrelated", ), view: { kind: "summary" }, }, { good: inventory, bad: selected( "list_procedures", inventory.normalized_result, "rea.unrelated", ), view: { kind: "native-inventory", offset: 0, limit: 1 }, }, { good: selected("procedure_address", "0x1000", "rea.analysis"), bad: selected("procedure_address", "0x1000", "rea.unrelated"), view: { kind: "native-observation", offset: 0, limit: 1 }, }, { good: selected("get_call_graph", graph, "rea.analysis"), bad: selected("get_call_graph", graph, "rea.unrelated"), view: { kind: "native-observation", offset: 0, limit: 1 }, }, { good: matching, bad: wrongMatching, view: { kind: "summary" } }, ]; for (const [index, { good, bad, view }] of cases.entries()) { expect(session.recordEvidence(good).ok).toBe(true); expect(session.recordEvidence(bad).ok).toBe(true); const goodReply = await call("inspect_analysis_view", { source: { kind: "retained-evidence", evidence_id: good.evidence_id }, view, }); expect(goodReply.isError, JSON.stringify(goodReply.content)).not.toBe( true, ); const goodView = parseEvidence(goodReply.structuredContent); expect(goodView.evidence_links).toContain(good.evidence_id); const raw = join(root, `${index}.json`), bundle = join(root, `${index}-bundle.json`); await writeFile(raw, JSON.stringify(bad)); await writeFile(bundle, JSON.stringify(createEvidenceBundle([bad]))); for (const source of [ { kind: "inline", evidence: bad }, { kind: "retained-evidence", evidence_id: bad.evidence_id }, { kind: "evidence-file", path: raw }, { kind: "evidence-file", path: bundle }, ]) { const reply = await call("inspect_analysis_view", { source, view }); expect(parseMcpToolError(reply).error).toMatchObject({ code: "invalid_request", details: { issues: [ expect.objectContaining({ path: ["source", "predicate_type"], reason: "invalid_value", }), ], }, }); } } expect(session.activeTarget()).toBeUndefined(); } finally { await client.close(); await server.close(); await session.close(); validation.clear(); } }, );