105 lines
3.7 KiB
TypeScript
105 lines
3.7 KiB
TypeScript
import type { McpServer } from "@modelcontextprotocol/server";
|
|
|
|
import type { BinarySessionPort } from "../application/BinarySession.js";
|
|
import { SESSION_TOOL_CONTRACTS } from "../contracts/toolContracts.js";
|
|
import { compareArtifacts } from "../domain/artifactComparison.js";
|
|
import { createEvidence } from "../domain/evidence.js";
|
|
import { jsonValueSchema } from "../domain/jsonValue.js";
|
|
import type { RecordUnknownInput } from "../domain/residualUnknown.js";
|
|
import { recordDerivedEvidence } from "./recordDerivedEvidence.js";
|
|
import { runDerivedOperation } from "./runDerivedOperation.js";
|
|
import { resolveSessionEvidenceIds } from "./sessionEvidence.js";
|
|
import { ARTIFACT_COMPARISON_PROVIDER } from "./sessionToolPolicies.js";
|
|
import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
|
|
import { toCallToolResult } from "./toolResult.js";
|
|
|
|
/** Register Evidence-backed deterministic artifact comparison. */
|
|
export const registerArtifactComparisonTool = (
|
|
server: McpServer,
|
|
session: BinarySessionPort,
|
|
contract: (typeof SESSION_TOOL_CONTRACTS)[7],
|
|
): void => {
|
|
server.registerTool(
|
|
contract.name,
|
|
toolRegistrationOptions(contract),
|
|
async (input, context) => {
|
|
const expected = {
|
|
operation: ["inspect_artifact", "inventory_artifact"],
|
|
predicate: "rea.analysis/v2",
|
|
};
|
|
const left = resolveSessionEvidenceIds(
|
|
session,
|
|
[input.left_evidence_id],
|
|
expected,
|
|
);
|
|
if (!left.ok) return toCallToolResult(left, contract);
|
|
const right = resolveSessionEvidenceIds(
|
|
session,
|
|
[input.right_evidence_id],
|
|
expected,
|
|
);
|
|
if (!right.ok) return toCallToolResult(right, contract);
|
|
const computed = await runDerivedOperation(context, contract.name, () =>
|
|
compareArtifacts(left.value, right.value),
|
|
);
|
|
if (!computed.ok) return toCallToolResult(computed, contract);
|
|
const comparison = computed.value;
|
|
const leftEvidenceIds = [input.left_evidence_id];
|
|
const rightEvidenceIds = [input.right_evidence_id];
|
|
const evidence = createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
|
|
predicateType: "rea.artifact-comparison/v1",
|
|
operation: contract.name,
|
|
parameters: {
|
|
left_evidence_ids: leftEvidenceIds,
|
|
right_evidence_ids: rightEvidenceIds,
|
|
},
|
|
result: jsonValueSchema.parse(comparison),
|
|
confidence: "derived",
|
|
authority: "analyst-inference",
|
|
limitations: comparison.limitations,
|
|
evidenceLinks: [...leftEvidenceIds, ...rightEvidenceIds],
|
|
});
|
|
return toCallToolResult(
|
|
recordDerivedEvidence(
|
|
session,
|
|
evidence,
|
|
artifactUnknownInput(input, comparison.status),
|
|
),
|
|
contract,
|
|
);
|
|
},
|
|
);
|
|
};
|
|
|
|
const artifactUnknownInput = (
|
|
input: {
|
|
readonly left_evidence_id: string;
|
|
readonly right_evidence_id: string;
|
|
},
|
|
status: ReturnType<typeof compareArtifacts>["status"],
|
|
): RecordUnknownInput | undefined => {
|
|
if (
|
|
status === "unchanged" ||
|
|
input.left_evidence_id === input.right_evidence_id
|
|
)
|
|
return undefined;
|
|
return {
|
|
question: `Artifact comparison is ${status}`,
|
|
severity:
|
|
status === "unknown" || status === "truncated" ? "high" : "medium",
|
|
domain: "artifact-comparison",
|
|
supporting_evidence_ids: [input.left_evidence_id],
|
|
contradicting_evidence_ids: [input.right_evidence_id],
|
|
required_authority: "shipped-artifact",
|
|
required_confidence: "observed",
|
|
required_environment: null,
|
|
recommended_probes: [
|
|
{
|
|
operation: "inspect_artifact",
|
|
rationale: "Inspect both artifacts and compare their complete graphs.",
|
|
},
|
|
],
|
|
relationships: [],
|
|
};
|
|
};
|