echelongraph-mcp 2.6.8 → 2.7.0

package/dist/tools/scan_manifest.js

@@ -0,0 +1,257 @@
+import * as z from "zod";
+import { TEXT_BUDGET_DESCRIPTION } from "../textBudget.js";
+import { sbomText } from "./check_sbom.js";
+import { FORMAT_NAMES, FORMATS, NOT_CHECKED_REASONS, detect, readFile } from "./manifests/index.js";
+import { CLEAN_NOTE, DISTRO_NOTE, FRESHNESS_NOTE, MAX_PURLS, MEASURED_AT_NOTE, METHOD, batchDataShape, dedupe, field, plural, purlsRefusal, sendBatches, sendingCoverage, sendingCoverageShape, sendingSentences, verdictSentences, } from "./match_batch.js";
+export const SCAN_MANIFEST = "scan_manifest";
+// At most this many files per call, and this many characters of content in all: check_sbom's
+// document cap, so the hosted endpoint's 6 MiB body cap holds a call at this size (httpPolicy.ts).
+export const MAX_FILES = 20;
+export const MAX_MANIFEST_CHARS = 5_000_000;
+// How many files the note names one by one.
+const NOTE_FILES_MAX = 20;
+// How many entries of data.not_checked the text keeps once it must be cut.
+const TEXT_NOT_CHECKED = 20;
+// The order the distinct purls are counted in, for the position of those not sent (#2799).
+const READ_ORDER = "counted in the order this tool read them (the files in the order given, each file's entries in the order the file lists them, each purl at its first place)";
+const NOT_CHECKED_NOTE = "not_checked entries are not clean: each names a dependency this tool did not send to the API (its version is a range or unresolved, or it comes from a local path, a VCS checkout or a line this tool does not read), so no verdict was looked up for it.";
+export const SCAN_MANIFEST_TITLE = "Check a lockfile against the advisory corpus";
+export const SCAN_MANIFEST_DESCRIPTION = "Check a project's lockfile or pinned manifest against EchelonGraph's advisory corpus, one verdict per dependency. Pass files: 1 to 20 of filename and content (its text), up to 5,000,000 characters in all; the filename gives the format, or format sets it. Read: requirements.txt (== and === pins only), go.mod (require, with replace and exclude applied), package-lock.json and npm-shrinkwrap.json (v1 to v3), Cargo.lock, Gemfile.lock, composer.lock, poetry.lock and gradle.lockfile. package.json, pyproject.toml, Pipfile, Gemfile, Cargo.toml, composer.json and build.gradle hold ranges and are refused, each naming the lockfile to pass; go.sum is refused, as it lists versions the build does not select. The files are read into purls by this MCP server and only the purls are sent to the API, in POST bodies of at most 200 each, never in a URL; filenames and file contents are not sent on. Run from npm, this server is on your machine; over the hosted endpoint (mcp.echelongraph.io) it is EchelonGraph's, and the files are the request body, accepted up to 6 MiB. data.results holds one row per distinct purl, with verdict (affected, not_affected, undetermined or not_assessed), not_assessed_reason, cve_ids and matched_via; each match carries kev_listed, epss_score and fixed_in, or null with fixed_in_reason. not_affected is the only clean verdict. data.not_checked lists each entry not sent, with its file, line and reason: version_unpinned (a range: django>=4), version_unresolved, local_path, vcs_source or unsupported_line; not_checked entries are not clean. At most 2,000 distinct purls per call, within 50 seconds; data.not_sent_purls lists any not sent, which are not checked and not clean." +
+    " " +
+    TEXT_BUDGET_DESCRIPTION +
+    " Cut, each row keeps index, purl, verdict, not_assessed_reason and cve_ids at least; not_checked keeps its first 20.";
+// The text's cut: check_sbom's rows and levels, and data.not_checked beside them, cut to its
+// first TEXT_NOT_CHECKED once the first level does not fit (structuredContent.data keeps it whole).
+export function manifestText(sent) {
+    const sbom = sbomText(sent);
+    return {
+        ...sbom,
+        sides: [
+            ...(sbom.sides ?? []),
+            {
+                list: "not_checked",
+                cap: TEXT_NOT_CHECKED,
+                said: (inText, total) => `coverage.not_checked_by_reason counts all ${total} entries not checked, ${inText} of them in the text.`,
+            },
+        ],
+        page: (shown) => `To read every row in the text, pass files that hold ${shown} or fewer distinct purls per call.`,
+    };
+}
+export function readFiles(a) {
+    if (!Array.isArray(a.files))
+        return "files must be a list of {filename, content}";
+    if (a.files.length === 0)
+        return "files holds no file";
+    if (a.files.length > MAX_FILES)
+        return `${a.files.length} files; at most ${MAX_FILES} are read per call`;
+    let total = 0;
+    for (const [n, f] of a.files.entries()) {
+        if (f === null || typeof f !== "object" || typeof f.filename !== "string" || typeof f.content !== "string")
+            return `files[${n}] must be {filename, content}, both strings`;
+        if (f.format !== undefined && f.format !== null && !FORMAT_NAMES.includes(f.format)) {
+            return `files[${n}].format ${JSON.stringify(f.format)} is not one of ${FORMAT_NAMES.join(", ")}`;
+        }
+        total += f.content.length;
+    }
+    if (total > MAX_MANIFEST_CHARS)
+        return `the files are ${total} characters in all; at most ${MAX_MANIFEST_CHARS} are read per call`;
+    const files = [];
+    const all = [];
+    const notChecked = [];
+    for (const f of a.files) {
+        const out = { filename: f.filename, format: null, ecosystem: null, read: false, refused: null, purls: 0, not_checked: 0, skipped: 0, notes: [], replaced: [] };
+        files.push(out);
+        const d = f.format ? { format: f.format } : detect(f.filename);
+        if ("refused" in d) {
+            out.refused = d.refused;
+            continue;
+        }
+        out.format = d.format;
+        out.ecosystem = FORMATS[d.format].ecosystem;
+        const r = readFile(d.format, f.content);
+        if ("unreadable" in r) {
+            out.refused = `read as ${d.format}, ${r.unreadable}`;
+            continue;
+        }
+        out.read = true;
+        out.purls = r.pinned.length;
+        out.not_checked = r.not_checked.length;
+        out.skipped = r.skipped;
+        out.notes = r.notes;
+        out.replaced = r.replaced ?? [];
+        all.push(...r.pinned.map((x) => x.purl));
+        notChecked.push(...r.not_checked.map((x) => ({ file: f.filename, ...x })));
+    }
+    if (files.every((f) => !f.read))
+        return `no file could be read: ${files.map((f) => `${f.filename}: ${f.refused}`).join("; ")}`;
+    const { purls, removed } = dedupe(all);
+    return { files, purls, read_purls: all.length, duplicates_removed: removed, not_checked: notChecked };
+}
+// ── The answer ──
+const byReason = (rows) => {
+    const by = Object.fromEntries(NOT_CHECKED_REASONS.map((r) => [r, 0]));
+    for (const r of rows)
+        by[r.reason]++;
+    return by;
+};
+function noteFor(head, x, d, g) {
+    const out = [head];
+    const read = x.files.filter((f) => f.read);
+    const shown = read.slice(0, NOTE_FILES_MAX).map((f) => `${f.filename} as ${f.format}: ${plural(f.purls, "entry", "entries")} pinned to one version${f.not_checked ? `, ${f.not_checked} not checked` : ""}${f.skipped ? `, ${f.skipped} skipped (the project's own entry)` : ""}`);
+    out.push(`Read ${plural(read.length, "file", "files")}: ${shown.join("; ")}${read.length > NOTE_FILES_MAX ? `; and ${read.length - NOTE_FILES_MAX} more in data.manifest.files` : ""}.`);
+    for (const f of x.files.filter((f) => !f.read))
+        out.push(`NOT READ, so nothing in it is checked: ${f.filename}: ${f.refused}.`);
+    for (const f of read)
+        for (const n of f.notes)
+            out.push(`${f.filename}: ${n}`);
+    const replaced = read.flatMap((f) => f.replaced);
+    if (replaced.length)
+        out.push(`${plural(replaced.length, "go.mod replace was", "go.mod replaces were")} applied, each module checked at its replacement (data.manifest.files lists them).`);
+    out.push(`${plural(x.purls.length, "distinct purl", "distinct purls")}${x.duplicates_removed ? ` (${plural(x.duplicates_removed, "duplicate was", "duplicates were")} sent once)` : ""}; sent ${g.sent}.`);
+    const by = byReason(x.not_checked);
+    const nc = x.not_checked.length;
+    if (nc) {
+        const parts = NOT_CHECKED_REASONS.filter((r) => by[r] > 0).map((r) => `${r} ${by[r]}`);
+        out.push(`${plural(nc, "entry was", "entries were")} NOT checked and ${nc === 1 ? "is" : "are"} not clean (${parts.join(", ")}): data.not_checked lists each with its file, line and reason, and none was sent to the API.`);
+    }
+    out.push(...sendingSentences(g, x.purls.length, READ_ORDER, "check_sbom with purls set to"));
+    if (d === null)
+        return { note: out.join(" "), assessed: 0 };
+    const v = verdictSentences(d, g);
+    out.push(...v.sentences);
+    return { note: out.join(" "), assessed: v.assessed };
+}
+// What data.manifest.files and data.not_checked carry, beside the API's answer.
+const manifestData = (x) => ({
+    manifest: {
+        files: x.files.map((f) => ({ ...f })),
+    },
+    not_checked: x.not_checked,
+});
+export async function scanManifest(deps, a) {
+    const tool = SCAN_MANIFEST;
+    try {
+        const x = readFiles(a);
+        if (typeof x === "string")
+            return deps.badInput(tool, x);
+        const refused = purlsRefusal(x.purls, `pass fewer files per call (${x.files.filter((f) => f.read).map((f) => `${f.filename}: ${f.purls}`).join(", ")}), or pass a lockfile's purls to check_sbom in parts of ${MAX_PURLS} or fewer`);
+        if (refused)
+            return deps.badInput(tool, refused);
+        const by = byReason(x.not_checked);
+        const fileCoverage = {
+            files: x.files.length,
+            files_read: x.files.filter((f) => f.read).length,
+            files_not_read: x.files.filter((f) => !f.read).length,
+            entries_pinned: x.read_purls,
+            duplicates_removed: x.duplicates_removed,
+            not_checked: x.not_checked.length,
+            not_checked_by_reason: by,
+        };
+        const notes = [NOT_CHECKED_NOTE, CLEAN_NOTE, DISTRO_NOTE, MEASURED_AT_NOTE, FRESHNESS_NOTE];
+        // Nothing to send: every entry is a range, a local path, a VCS checkout or unread. The answer
+        // says so, entry by entry; no request is made, and nothing is measured.
+        if (x.purls.length === 0) {
+            const g = { batches: 0, batches_sent: 0, sent: 0, not_sent_purls: [], not_sent_reason: null, not_sent_detail: null, waits: 0, waited_ms: 0 };
+            const head = `${tool} OK: nothing was sent to EchelonGraph, as no entry in the files names one registry version this tool can check, so nothing is measured and nothing is clean.`;
+            const { note } = noteFor(head, x, null, g);
+            return deps.succeeded({ ...manifestData(x), results: [] }, note, {
+                state: "not_assessed",
+                measured_at: null,
+                method: METHOD,
+                coverage: { ...fileCoverage, ...sendingCoverage(g, 0, undefined) },
+                freshness: null,
+                notes,
+            }, manifestText(0));
+        }
+        // match_batch.ts: one batch at a time, Retry-After waited out within the budget, stopped on
+        // cancellation (#2775), exactly as check_sbom sends its purls.
+        const run = await sendBatches(deps, tool, x.purls);
+        if (!run.ok)
+            return run.result;
+        const { data, status, sending: g } = run;
+        Object.assign(data, manifestData(x));
+        const { note, assessed } = noteFor(deps.okHead(tool, status), x, data, g);
+        return deps.succeeded(data, note, {
+            state: assessed > 0 ? "measured" : "not_assessed",
+            measured_at: null,
+            method: METHOD,
+            coverage: { ...fileCoverage, ...sendingCoverage(g, x.purls.length, field(data, "summary")) },
+            freshness: null,
+            notes,
+        }, manifestText(g.sent));
+    }
+    catch (e) {
+        return deps.crashed(tool, e);
+    }
+}
+// ── Schemas ──
+const reasonEnum = z.enum(NOT_CHECKED_REASONS);
+const formatEnum = z.enum(FORMAT_NAMES);
+export function scanManifestOutput(envelopeSchema) {
+    return envelopeSchema({
+        data: z.looseObject({
+            ...batchDataShape,
+            manifest: z
+                .object({
+                files: z.array(z.object({
+                    filename: z.string(),
+                    format: formatEnum.nullable().describe("The format the file was read as: set by format, or read from the filename; null when it was not read."),
+                    ecosystem: z.string().nullable().describe("The OSV ecosystem of the purls read from it."),
+                    read: z.boolean().describe("false: the file was refused or could not be read, and nothing in it is checked (not clean)."),
+                    refused: z.string().nullable().describe("Why the file was not read, and the file to pass instead where there is one; null when it was read."),
+                    purls: z.number().int().describe("Entries pinned to one version, read as purls (duplicates included)."),
+                    not_checked: z.number().int().describe("Entries not sent, listed in data.not_checked: not clean."),
+                    skipped: z.number().int().describe("Entries that are not dependencies (a package-lock's root entry, the project itself)."),
+                    notes: z.array(z.string()).describe("How this file was read where that limits what its verdicts cover (a go.mod below go 1.17)."),
+                    replaced: z.array(z.object({ from: z.string(), to: z.string() })).describe("go.mod replace directives applied: the module required, and the module and version checked instead."),
+                })),
+            })
+                .describe("Each file passed, in order, and how it was read. Filenames and contents are not sent to the API."),
+            not_checked: z
+                .array(z.object({
+                file: z.string(),
+                name: z.string().nullable(),
+                spec: z.string().describe("What the file says for the entry: its line, or its lockfile key and version (at most 200 characters)."),
+                reason: reasonEnum.describe("version_unpinned: a range or wildcard, not one version; version_unresolved: no single registry version (none given, a branch, or an excluded go.mod version); local_path: a directory, file or workspace member; vcs_source: a VCS checkout; unsupported_line: a line or entry this tool does not read (another file named by -r or -c, a direct URL, another registry)."),
+                line: z.number().int().nullable().describe("1-based line; null in a JSON lockfile, whose entries spec names by key."),
+                detail: z.string(),
+            }))
+                .describe("Each entry not sent to the API, with its file, line and reason: not checked, and not clean."),
+        }),
+        coverage: z.strictObject({
+            files: z.number().int().describe("Files passed."),
+            files_read: z.number().int().describe("Of those, the ones read."),
+            files_not_read: z.number().int().describe("The ones refused or unreadable: nothing in them is checked, and none is clean."),
+            entries_pinned: z.number().int().describe("Entries pinned to one version across the files, duplicates included."),
+            duplicates_removed: z.number().int().describe("Purls read more than once (the same package and version in two places) and sent once."),
+            not_checked: z.number().int().describe("Entries not sent (data.not_checked): not clean."),
+            not_checked_by_reason: z.strictObject(Object.fromEntries(NOT_CHECKED_REASONS.map((r) => [r, z.number().int()]))).describe("not_checked, counted by reason."),
+            ...sendingCoverageShape,
+        }),
+        freshness: null,
+    });
+}
+// A literal server.registerTool(name, { title, description, … }) call with constant strings:
+// marketing-site lib/mcpToolClaims.test.ts reads it here (it follows index.ts's call to this
+// function) and holds the /pulse/mcp row to this title and description.
+export function registerScanManifest(server, deps) {
+    const output = scanManifestOutput(deps.envelopeSchema);
+    server.registerTool(SCAN_MANIFEST, {
+        title: SCAN_MANIFEST_TITLE,
+        description: SCAN_MANIFEST_DESCRIPTION,
+        inputSchema: z.object({
+            files: z
+                .array(z.object({
+                filename: z.string().describe("the file's name, e.g. package-lock.json or services/api/go.mod; it picks the format unless format is set"),
+                content: z.string().describe("the file's text, as it is on disk"),
+                format: formatEnum.optional().describe("the format to read the file as, when its name does not say"),
+            }))
+                .describe("1 to 20 files, up to 5,000,000 characters of content in all; read by this MCP server into purls, and only the purls are sent to the API; over the hosted endpoint (mcp.echelongraph.io) the files are the request body"),
+        }),
+        outputSchema: output,
+        annotations: deps.annotations,
+    }, async (a, ctx) => {
+        const run = scanManifest({ ...deps, signal: ctx.mcpReq.signal }, a);
+        return deps.checked(SCAN_MANIFEST, output, await (deps.hold ? deps.hold(run) : run));
+    });
+}

package/dist/tools/vendor_advisories.js

@@ -8,8 +8,10 @@
 // vendor_published_at is the date the vendor gives, our_first_seen_at is when EchelonGraph
 // first recorded the advisory. withdrawn is the vendor rescinding its own advisory; the list
 // and the search leave such advisories out, the per-CVE lookup and the detail keep them, and
-// the note names each one. Advisories of a vendor feed EchelonGraph has disabled are left out
-// of all three. None of the answers carries a time at which the pollers last completed a poll,
+// the note names each one. rejected_cve_ids (#2865) is separate from it: the CVE IDs a row names
+// whose CVE record was rejected by its numbering authority, while the vendor's own document may
+// still read as live; the note names those rows and the by-cve answer's cve_rejected. Advisories
+// of a vendor feed EchelonGraph has disabled are left out of all three. None of the answers carries a time at which the pollers last completed a poll,
 // so freshness is null.
 //
 // The search term never travels in a URL (#1983). search_vendor_advisories sends it in the
@@ -102,6 +104,31 @@ function withdrawnNote(rows) {
         return "";
     return ` WITHDRAWN: ${w.length} of these ${rows.length} ${plural(rows.length, "advisory", "advisories")} ${plural(w.length, "was", "were")} withdrawn (rescinded) by ${plural(w.length, "its", "their")} vendor (withdrawn true): ${w.join(", ")}. Report ${plural(w.length, "it", "them")} as withdrawn, not as a current advisory.`;
 }
+// #2865: a vendor advisory can name a CVE ID its numbering authority rejected while the vendor's own
+// text still reads as a live advisory (CVE-2026-7936's MSRC entry). core-backend serves
+// rejected_cve_ids, the CVE IDs of the row whose CVE record was rejected, beside the vendor's own
+// withdrawn, which it leaves as the vendor set it. A row the vendor withdrew is named by
+// withdrawnNote already, so this names the live ones.
+const rejectedIDs = (r) => {
+    const v = field(r, "rejected_cve_ids");
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : [];
+};
+function rejectedCVENote(rows) {
+    const hit = rows.flatMap((r, i) => field(r, "withdrawn") !== true && rejectedIDs(r).length
+        ? [`${str(r, "vendor") ?? "?"}/${str(r, "vendor_advisory_id") ?? `advisories[${i}]`} (${rejectedIDs(r).join(", ")})`]
+        : []);
+    if (!hit.length)
+        return "";
+    const k = hit.length;
+    return ` CVE REJECTED: ${k} of these ${rows.length} ${plural(rows.length, "advisory", "advisories")}, not withdrawn by ${plural(k, "its", "their")} vendor, ${plural(k, "names", "name")} a CVE ID whose CVE record was rejected (withdrawn) by its numbering authority (rejected_cve_ids): ${hit.join("; ")}. Report each such CVE ID as a rejected record, not as an active vulnerability, even where the vendor's text reads as a current advisory.`;
+}
+// The rows' rejected_cve_ids could not be checked (null on every row that names a CVE).
+function rejectedUnknownNote(rows) {
+    const unknown = rows.filter((r) => Array.isArray(field(r, "cve_ids")) && field(r, "cve_ids").length > 0 && field(r, "rejected_cve_ids") === null);
+    if (!unknown.length)
+        return "";
+    return ` For ${unknown.length} of these advisories rejected_cve_ids is null: whether a CVE ID they name was rejected could not be checked, which is not a finding that none was.`;
+}
 const instantOrNull = (o, k) => {
     const v = field(o, k);
     return realInstant(v) ? v : null;
@@ -182,13 +209,41 @@ function backfillingNote(windows) {
     const k = b.length;
     return ` The older advisories of ${plural(k, "1 vendor", `${k} vendors`)} are still being read (history_backfill in_progress or not_started): ${b.map((w) => windowItem(w, false)).join("; ")}. EchelonGraph does not yet hold all of ${plural(k, "its", "their")} older advisories, so none found from ${plural(k, "it", "them")} is not a finding that ${plural(k, "it", "they")} published none.`;
 }
+// #2840: what the rows say of their remediation, where the API sends remediation_state.
+function remediationNote(cve, rows) {
+    const states = rows.map((r) => field(r, "remediation_state")).filter((x) => typeof x === "string");
+    if (!states.length)
+        return "";
+    const count = (st) => states.filter((x) => x === st).length;
+    const kinds = new Map();
+    for (const r of rows) {
+        const ks = field(r, "remediation_kinds");
+        if (Array.isArray(ks))
+            for (const k of ks)
+                if (typeof k === "string")
+                    kinds.set(k, (kinds.get(k) ?? 0) + 1);
+    }
+    const listedKinds = [...kinds].map(([k, n]) => `${k} (${n})`).join(", ");
+    const parts = [
+        listedKinds ? ` By the vendors' own categories, the advisories list for ${cve}: ${listedKinds}; each is the vendor's text, untested by EchelonGraph, and cve_remediation or get_vendor_advisory returns it.` : "",
+        count("none_in_source") ? ` ${count("none_in_source")} ${plural(count("none_in_source"), "lists", "list")} no remediation for ${cve} (none_in_source), which is not a finding that no fix exists.` : "",
+        count("not_parsed") ? ` EchelonGraph does not read the remediation of ${count("not_parsed")} (remediation_state not_parsed), which is not a finding that ${plural(count("not_parsed"), "it lists", "they list")} none.` : "",
+    ];
+    return parts.join("");
+}
 // ── Output schemas ──
 const opt = (t) => t.nullable().optional();
 const DATE_FIELDS = {
     vendor_published_at: opt(z.string()).describe("The date the vendor gives for the advisory."),
     our_first_seen_at: opt(z.string()).describe("When EchelonGraph first recorded the advisory; not the vendor's date."),
     withdrawn: opt(z.boolean()).describe("true: the vendor withdrew (rescinded) this advisory, so it is a withdrawn advisory, not a current one."),
+    rejected_cve_ids: opt(z.array(z.string())).describe("The CVE IDs this advisory names whose CVE record was rejected (withdrawn) by its numbering authority: each is a rejected record, not an active vulnerability, whatever the advisory's text says. The vendor's withdrawn is separate and unchanged by it. [] when none is; null when that could not be checked."),
 };
+// #2840: what remediation_kinds and remediation_state are, on a by-cve row and on the detail.
+const REMEDIATION_STATE_FIELD = "parsed; none_in_source (EchelonGraph read the vendor's remediation, and it lists none for this CVE, which is not a finding that no fix exists); not_parsed (EchelonGraph does not read this vendor's remediation, or has not yet read this advisory: not a finding of none); withdrawn (the vendor rescinded the advisory).";
+const REMEDIATION_KINDS_FIELD = "The kinds of remediation the advisory lists (for the CVE asked about, on a by-cve row), each the vendor's own category, never read from the text: vendor_fix, workaround, mitigation, no_fix_planned, none_available or other. [] with remediation_state not_parsed is not a finding that it lists none.";
+const REMEDIATION_KINDS = ["vendor_fix", "workaround", "mitigation", "no_fix_planned", "none_available", "other"];
+const REMEDIATION_STATES = ["parsed", "none_in_source", "not_parsed", "withdrawn"];
 const AdvisoryRow = z.looseObject({
     advisory_id: opt(z.string()),
     vendor: opt(z.string()),
@@ -201,18 +256,34 @@ const AdvisoryRow = z.looseObject({
     summary: opt(z.string()),
     affected_products: opt(z.array(z.string())),
     ...DATE_FIELDS,
+    remediation_kinds: opt(z.array(z.union([z.enum(REMEDIATION_KINDS), z.string()]))).describe(REMEDIATION_KINDS_FIELD),
+    remediation_state: opt(z.union([z.enum(REMEDIATION_STATES), z.string()])).describe(REMEDIATION_STATE_FIELD),
 });
 // Shared by the three descriptions. Top-level consts, so the site's tool-claims check
 // (marketing-site/lib/mcpToolClaims.test.ts) can fold the descriptions to their text.
-const DATES_DESCRIPTION = "Each advisory carries vendor_published_at (the vendor's date), our_first_seen_at (when EchelonGraph first recorded it) and withdrawn (true: the vendor rescinded it; the note names each such advisory).";
-const ENVELOPE_DESCRIPTION = "Its structured result carries state (measured), measured_at, method, coverage, freshness (null: the answer carries no poll-completion time) and notes, with data equal to the API's JSON; the result's last text block repeats it without data (the first text block) and without the note's sentences (the text block before it), with which notes ends.";
+const DATES_DESCRIPTION = "Each advisory carries vendor_published_at (the vendor's date), our_first_seen_at (when EchelonGraph first recorded it) and withdrawn (true: the vendor rescinded it).";
+// #2865: the CVE-state flag beside the vendor's own withdrawn. #2842: the head the descriptions
+// carry; rejected_cve_ids' and cve_rejected's outputSchema descriptions say the rest (null: not checked).
+const REJECTED_CVE_DESCRIPTION = "Each advisory also carries rejected_cve_ids: the CVE IDs it names whose CVE record was rejected (withdrawn) by its numbering authority, which are not active vulnerabilities.";
+// #2842: the generic rule for the result's last text block is in the README and the methodology
+// resource, not in each description.
+const ENVELOPE_DESCRIPTION = "Its freshness is null: the answer carries no poll-completion time.";
 // #2729: what a vendor's window is.
 const HISTORY_BACKFILL_DESCRIPTION = "history_backfill: complete (the vendor's published history has been read back as far as its source goes), in_progress or not_started (it is still being read, so the vendor's older advisories are not all held yet), or not_supported (EchelonGraph has no history read for that vendor, so what it holds is what the vendor's feed has carried)";
 // #2803: where a vendor's window begins.
 const HELD_SINCE_DESCRIPTION = "held_since (the start of the window EchelonGraph has read that vendor's advisories from, before which an advisory may not be held; null when none is held or the API does not say; for a vendor with no history read it is when its feed was first read from, and can be years after earliest_vendor_published_at, since an older advisory is held when the vendor revised it later, not the ones published beside it)";
 const WINDOW_DESCRIPTION = `vendor, advisories (how many EchelonGraph holds from that vendor), earliest_vendor_published_at and latest_vendor_published_at (the earliest and latest vendor_published_at among them, null when none is held), ${HELD_SINCE_DESCRIPTION} and ${HISTORY_BACKFILL_DESCRIPTION}`;
+// #2842: what the descriptions say of a window, within the client cut (requiredText.ts);
+// WINDOW_DESCRIPTION in full is the outputSchema's description of a window.
+const WINDOW_HEAD = "vendor, advisories, earliest_vendor_published_at, latest_vendor_published_at, held_since (where that window begins) and history_backfill (in_progress or not_started: older advisories not all held yet)";
 const NOT_HELD_DESCRIPTION = "An advisory a vendor published before its held_since may not be held, even when its earliest_vendor_published_at is older, so no advisory from a vendor is not a finding that it published none.";
+// #2842: the same rule within the client cut; NOT_HELD_DESCRIPTION whole is the windows' outputSchema description.
+const NOT_HELD_HEAD = "An advisory published before its vendor's held_since may not be held, so no advisory from a vendor is not a finding that it published none.";
 // #2728: how a search matches, and its capped total.
+// #2842: what search_vendor_advisories' description says; SEARCH_MATCH_DESCRIPTION and
+// TOTAL_CAPPED_DESCRIPTION in full are the outputSchema's descriptions of search_match and total_capped.
+const SEARCH_MATCH_HEAD = "A query of 3 or more characters is matched case-insensitively as a substring of each advisory's title, description, vendor name, IDs and affected_products (search_match substring). A query of 1 or 2 characters matches whole words only (search_match word).";
+const TOTAL_CAPPED_HEAD = "A search counts at most 1,000 matches: past that, total is 1000 and total_capped is true, which means 1,000 or more (the note writes 1,000+), never exactly 1,000.";
 const SEARCH_MATCH_DESCRIPTION = "A query of 3 or more characters is matched case-insensitively as a substring of each advisory's title, description, vendor name, vendor_advisory_id, affected_products and cve_ids (search_match substring). A query of 1 or 2 characters matches whole words only (search_match word): it must equal, ignoring case, a whole word (a run of letters and digits) of one of those, so xz finds xz-utils but not xzibit, and a 1- or 2-character query with any other character, such as c#, matches nothing.";
 const TOTAL_CAPPED_DESCRIPTION = "A search counts at most 1,000 matches: past that, total is 1000 and total_capped is true, which means 1,000 or more (the note writes 1,000+), never exactly 1,000; paging past it still works. Without a query, total is the exact count and total_capped is false.";
 const VendorWindowSchema = z.strictObject({
@@ -234,7 +305,7 @@ const VendorWindowSchema = z.strictObject({
         .union([z.enum(["complete", "in_progress", "not_started", "not_supported"]), z.string()])
         .nullable()
         .describe(`${HISTORY_BACKFILL_DESCRIPTION}.`),
-});
+}).describe(`A vendor's window in what EchelonGraph holds: ${WINDOW_DESCRIPTION}.`);
 const WINDOWS = z.array(VendorWindowSchema).nullable().describe(`Each vendor's window in what EchelonGraph holds; null when the windows could not be read. ${NOT_HELD_DESCRIPTION}`);
 // #2783: a production row is up to about 2,000 characters as pretty JSON (its summary, its
 // affected_products and, for a library like log4j, dozens of cve_ids), so search_vendor_advisories
@@ -242,8 +313,8 @@ const WINDOWS = z.array(VendorWindowSchema).nullable().describe(`Each vendor's w
 // text block keeps what identifies and rates the advisory, every string cut to 200 characters and
 // every list to 20 entries; then fewer fields, strings to 100 and lists to 10.
 const ROW_CUT_LEVELS = [
-    { keep: ["vendor", "vendor_display_name", "vendor_advisory_id", "title", "severity", "cvss_v3_score", "cve_ids", "summary", "affected_products", "vendor_published_at", "withdrawn"], clip: 200, cap: 20 },
-    { keep: ["vendor", "vendor_advisory_id", "title", "severity", "cve_ids", "vendor_published_at", "withdrawn"], clip: 100, cap: 10 },
+    { keep: ["vendor", "vendor_display_name", "vendor_advisory_id", "title", "severity", "cvss_v3_score", "cve_ids", "summary", "affected_products", "vendor_published_at", "withdrawn", "rejected_cve_ids", "remediation_kinds", "remediation_state"], clip: 200, cap: 20 },
+    { keep: ["vendor", "vendor_advisory_id", "title", "severity", "cve_ids", "vendor_published_at", "withdrawn", "rejected_cve_ids", "remediation_kinds", "remediation_state"], clip: 100, cap: 10 },
 ];
 // get_vendor_advisory's own first text block is cut too past the budget (#2802): only its
 // structuredContent.data is one advisory whole.
@@ -258,7 +329,12 @@ const searchText = (a) => ({
 const ROW_CUT_DESCRIPTION = " Cut, each row keeps vendor, vendor_advisory_id, title, severity and cve_ids at least, its strings and lists shortened";
 export function registerVendorAdvisoryTools(server, kit) {
     const FOR_CVE_OUTPUT = kit.envelopeSchema({
-        data: z.looseObject({ cve_id: opt(z.string()), advisories: opt(z.array(AdvisoryRow)), total: opt(z.number()) }),
+        data: z.looseObject({
+            cve_id: opt(z.string()),
+            advisories: opt(z.array(AdvisoryRow)),
+            total: opt(z.number()),
+            cve_rejected: opt(z.boolean()).describe("true: the CVE record of cve_id was rejected (withdrawn) by its numbering authority, so these advisories name a rejected record, not an active vulnerability; null when that could not be checked."),
+        }),
         coverage: z.strictObject({
             returned: z.number().nullable().describe("The advisories in this answer."),
             cap: z.number().describe("The most the API returns for one CVE, newest first."),
@@ -276,7 +352,21 @@ export function registerVendorAdvisoryTools(server, kit) {
         data: AdvisoryRow.extend({
             description: opt(z.string()),
             known_cve_ids: opt(z.array(z.string())).describe("The CVE IDs of cve_ids that have a record in EchelonGraph's CVE feed."),
-            remediation: opt(z.string()),
+            remediation: opt(z.string()).describe("The vendor's remediation as one text (the legacy field), beside remediations."),
+            remediations: opt(z.array(z.looseObject({
+                kind: opt(z.union([z.enum(REMEDIATION_KINDS), z.string()])),
+                source_category: opt(z.string()).describe("The vendor's own name for the category."),
+                source_subcategory: opt(z.string()),
+                text: opt(z.string()).describe("The vendor's text, verbatim but for HTML markup removed, untested by EchelonGraph; at most 2,000 characters (text_truncated, text_chars)."),
+                text_truncated: opt(z.boolean()),
+                text_chars: opt(z.number()),
+                url: opt(z.string()),
+                fixed_build: opt(z.string()),
+                cve_ids: opt(z.array(z.string())).describe("The CVEs the item covers; [] for the whole advisory."),
+                product_ids: opt(z.array(z.string())),
+                product_count: opt(z.number()),
+            }))).describe("Each remediation the vendor lists, with its kind, the vendor's own category."),
+            remediation_items_not_stored: opt(z.number()).describe("Items past the 64 stored per advisory."),
             references: z.unknown().optional(),
             vendor_modified_at: opt(z.string()),
             withdrawn_at: opt(z.string()),
@@ -294,8 +384,8 @@ export function registerVendorAdvisoryTools(server, kit) {
             limit: opt(z.number()),
             offset: opt(z.number()),
             search_applied: opt(z.boolean()).describe("Whether a free-text search filtered this answer."),
-            search_match: opt(z.string()).describe("How the query was matched: word (a query of 1 or 2 characters, whole words only) or substring; null without a query."),
-            total_capped: opt(z.boolean()).describe("true: the search stopped counting at total, so total is a lower bound (1,000+), not the count."),
+            search_match: opt(z.string()).describe(`How the query was matched: word (a query of 1 or 2 characters, whole words only) or substring; null without a query. ${SEARCH_MATCH_DESCRIPTION}`),
+            total_capped: opt(z.boolean()).describe(`true: the search stopped counting at total, so total is a lower bound (1,000+), not the count. ${TOTAL_CAPPED_DESCRIPTION}`),
         }),
         coverage: z.strictObject({
             total: z.number().nullable().describe("The API's total; when total_capped is true, a lower bound, not the count."),
@@ -305,7 +395,7 @@ export function registerVendorAdvisoryTools(server, kit) {
             offset: z.number().nullable(),
             search_applied: z.boolean().nullable(),
             search_match: z.enum(["word", "substring"]).nullable().describe("word: a query of 1 or 2 characters, matched as a whole word only; substring: a longer query; null without a query."),
-            vendor_windows: WINDOWS,
+            vendor_windows: WINDOWS.describe(`Each vendor's window in what EchelonGraph holds, only that vendor's when vendor is given; null when the windows could not be read. ${NOT_HELD_DESCRIPTION}`),
         }),
         freshness: null,
     });
@@ -354,13 +444,23 @@ export function registerVendorAdvisoryTools(server, kit) {
             };
             const head = kit.okHead(tool, r.status);
             const held = w.ok ? notFullyHeldNote(cve, year, missing ?? []) : windowsUnknown(w.why);
+            // #2865: the queried CVE's own state, first, so no advisory below reads as a live CVE's.
+            const cveState = field(r.data, "cve_rejected");
+            const rejectedHead = cveState === true
+                ? ` CVE REJECTED: the CVE record of ${cve} was rejected (withdrawn) by its numbering authority (cve_rejected true). It is a rejected record, not an active vulnerability: report it that way, even where a vendor advisory below reads as a current one.`
+                : cveState === null
+                    ? ` Whether the CVE record of ${cve} was rejected could not be checked (cve_rejected null), which is not a finding that it was not.`
+                    : "";
             if (returned === 0) {
-                return kit.succeeded(r.data, `${head} No vendor advisory on record names ${cve}: a measured empty result, EchelonGraph was queried successfully and found nothing (we looked and found nothing). This is not a lookup failure. ${ONLY_POLLED}${held}`, env, FOR_CVE_TEXT);
+                return kit.succeeded(r.data, `${head}${rejectedHead} No vendor advisory on record names ${cve}: a measured empty result, EchelonGraph was queried successfully and found nothing (we looked and found nothing). This is not a lookup failure. ${ONLY_POLLED}${held}`, env, FOR_CVE_TEXT);
             }
             if (rows === undefined)
-                return kit.succeeded(r.data, `${head}${held}`, env, FOR_CVE_TEXT);
+                return kit.succeeded(r.data, `${head}${rejectedHead}${held}`, env, FOR_CVE_TEXT);
             const cap = atCap ? ` The API returns at most ${BY_CVE_CAP} advisories for one CVE, newest first, and this answer is full (at_cap true), so there may be more.` : "";
-            return kit.succeeded(r.data, `${head} ${rows.length} vendor ${plural(rows.length, "advisory names", "advisories name")} ${cve}.${cap}${withdrawnNote(rows)} ${ONLY_POLLED}${held}`, env, FOR_CVE_TEXT);
+            // With cve_rejected true the head has said it of the one CVE every row names; the per-row
+            // note then only adds the other rejected IDs a multi-CVE advisory names.
+            const perRow = cveState === true ? rejectedCVENote(rows.map((x) => ({ ...x, rejected_cve_ids: rejectedIDs(x).filter((id) => id.toUpperCase() !== cve) }))) : rejectedCVENote(rows);
+            return kit.succeeded(r.data, `${head}${rejectedHead} ${rows.length} vendor ${plural(rows.length, "advisory names", "advisories name")} ${cve}.${cap}${withdrawnNote(rows)}${perRow}${rejectedUnknownNote(rows)}${remediationNote(cve, rows)} ${ONLY_POLLED}${held}`, env, FOR_CVE_TEXT);
         }
         catch (e) {
             return kit.crashed(tool, e);
@@ -412,7 +512,14 @@ export function registerVendorAdvisoryTools(server, kit) {
                 ? ` Of the ${cveIDs.length} CVE IDs it lists (cve_ids), ${known.length} ${plural(known.length, "has", "have")} a record in EchelonGraph's CVE feed (known_cve_ids); the others have no record there yet, which does not mean they are not CVEs.`
                 : "";
             const held = !w.ok ? windowsUnknown(w.why) : window ? backfillingNote([window]) : "";
-            return kit.succeeded(r.data, `${kit.okHead(tool, r.status)} Returned the advisory ${shown}.${withdrawn}${cves}${held}`, env);
+            // #2865: the CVE IDs it names that were rejected, said whether or not the vendor withdrew it.
+            const rej = rejectedIDs(r.data);
+            const rejectedCVEs = rej.length
+                ? ` CVE REJECTED: ${rej.length} of the CVE IDs it lists ${plural(rej.length, "was", "were")} rejected (withdrawn) by ${plural(rej.length, "its", "their")} numbering authority (rejected_cve_ids): ${rej.join(", ")}. Report ${plural(rej.length, "it", "each")} as a rejected record, not as an active vulnerability${field(r.data, "withdrawn") === true ? "" : ", even though the vendor has not withdrawn this advisory and its text reads as a current one"}.`
+                : field(r.data, "rejected_cve_ids") === null && Array.isArray(cveIDs) && cveIDs.length > 0
+                    ? " Whether a CVE ID it lists was rejected could not be checked (rejected_cve_ids null), which is not a finding that none was."
+                    : "";
+            return kit.succeeded(r.data, `${kit.okHead(tool, r.status)} Returned the advisory ${shown}.${withdrawn}${rejectedCVEs}${cves}${held}`, env);
         }
         catch (e) {
             return kit.crashed(tool, e);
@@ -500,7 +607,8 @@ export function registerVendorAdvisoryTools(server, kit) {
             const counted = isCapped
                 ? `${total.toLocaleString("en-US")}+ vendor advisories (total_capped true: the API stops counting a search's matches at ${total.toLocaleString("en-US")}, so total is a lower bound, not the count; paging past it still works)`
                 : `${total} vendor ${plural(total, "advisory", "advisories")}`;
-            return kit.succeeded(r.data, `${head} ${what} ${counted}${page}.${wordOnly}${held}`, env, searchText(a));
+            const rejected = rows === undefined ? "" : `${rejectedCVENote(rows)}${rejectedUnknownNote(rows)}`;
+            return kit.succeeded(r.data, `${head} ${what} ${counted}${page}.${rejected}${wordOnly}${held}`, env, searchText(a));
         }
         catch (e) {
             return kit.crashed(tool, e);
@@ -508,14 +616,14 @@ export function registerVendorAdvisoryTools(server, kit) {
     }
     server.registerTool("vendor_advisories_for_cve", {
         title: "Vendor advisories for one CVE",
-        description: `The vendor-published advisories that name one CVE, newest first, at most 20: for each, vendor, vendor_display_name, vendor_advisory_id, title, severity and cvss_v3_score where the vendor gives them. Covers the vendor feeds EchelonGraph polls, for example Microsoft MSRC, Red Hat, Cisco, Palo Alto Networks and GitHub GHSA; an empty answer means that none of the advisories EchelonGraph holds from those feeds names the CVE, not that no vendor published one (see vendor_windows and vendors_not_fully_held). ${DATES_DESCRIPTION} Pass a CVE ID like CVE-2024-21412. coverage gives returned, cap and at_cap (true: the answer is full, so there may be more); cve_year, the year in the CVE ID; vendor_windows, each vendor's window in what EchelonGraph holds: ${WINDOW_DESCRIPTION}; and vendors_not_fully_held, the vendors with no advisory in the answer of which EchelonGraph holds none, whose held_since is after 1 January of cve_year or not known, or whose history is still being read, which the note names. ${NOT_HELD_DESCRIPTION} vendor_windows and vendors_not_fully_held are null when the windows could not be read, and the note says so. measured_at is null. ${ENVELOPE_DESCRIPTION} ${TEXT_BUDGET_DESCRIPTION}${ROW_CUT_DESCRIPTION}.`,
+        description: `The vendor-published advisories that name one CVE, newest first, at most 20: for each, vendor, vendor_display_name, vendor_advisory_id, title, severity and cvss_v3_score where the vendor gives them. Covers the vendor feeds EchelonGraph polls, for example Microsoft MSRC, Red Hat, Cisco, Palo Alto Networks and GitHub GHSA; an empty answer means that none of the advisories EchelonGraph holds from those feeds names the CVE, not that no vendor published one. ${DATES_DESCRIPTION} ${REJECTED_CVE_DESCRIPTION} The answer's cve_rejected is true when the CVE record of the CVE asked for was rejected (withdrawn) by its numbering authority. Each row has remediation_kinds and remediation_state (not_parsed is not none). coverage gives returned, cap, at_cap (true: there may be more) and cve_year; vendor_windows, each vendor's window in what EchelonGraph holds: ${WINDOW_HEAD}; and vendors_not_fully_held, the vendors with no advisory in the answer of which EchelonGraph holds none, whose held_since is after 1 January of cve_year or not known, or whose history is still being read, which the note names. ${NOT_HELD_HEAD} ${TEXT_BUDGET_DESCRIPTION}${ROW_CUT_DESCRIPTION}.`,
         inputSchema: z.object({ cve_id: z.string().describe("a CVE ID, e.g. CVE-2024-21412") }),
         outputSchema: FOR_CVE_OUTPUT,
         annotations: kit.annotations,
     }, async ({ cve_id }) => kit.checked("vendor_advisories_for_cve", FOR_CVE_OUTPUT, await forCVE(cve_id)));
     server.registerTool("get_vendor_advisory", {
         title: "Vendor advisory detail",
-        description: `One vendor advisory in full, by vendor and the vendor's advisory ID (the vendor and vendor_advisory_id of a vendor advisory row): title, description, severity, cvss_v3_score, cve_ids and known_cve_ids (those with a record in EchelonGraph's CVE feed), affected_products, remediation, references, vendor_modified_at, and withdrawn_at and withdrawn_reason when the vendor withdrew it. ${DATES_DESCRIPTION} coverage.vendor_window is that vendor's window in what EchelonGraph holds: ${WINDOW_DESCRIPTION}; null when the windows could not be read or carry none for that vendor. measured_at is our_first_seen_at. ${ENVELOPE_DESCRIPTION} ${TEXT_BUDGET_DESCRIPTION}`,
+        description: `One vendor advisory in full, by vendor and the vendor's advisory ID (the vendor and vendor_advisory_id of a vendor advisory row): title, description, severity, cvss_v3_score, cve_ids and known_cve_ids (those with a record in EchelonGraph's CVE feed), affected_products, remediation, references, vendor_modified_at, and withdrawn_at and withdrawn_reason when the vendor withdrew it. remediations lists each remediation the vendor lists, with kind (the vendor's own category, never read from the text: vendor_fix, workaround, mitigation, no_fix_planned, none_available or other), source_category, text, url and the cve_ids and product_ids it covers; each text is the vendor's, verbatim, untested by EchelonGraph. remediation_state is parsed, none_in_source, not_parsed or withdrawn: none_in_source and not_parsed are not a finding that no fix exists. ${DATES_DESCRIPTION} ${REJECTED_CVE_DESCRIPTION} coverage.vendor_window is that vendor's window in what EchelonGraph holds: ${WINDOW_HEAD}; null when the windows could not be read or carry none for that vendor. measured_at is our_first_seen_at. ${ENVELOPE_DESCRIPTION} ${TEXT_BUDGET_DESCRIPTION}`,
         inputSchema: z.object({
             vendor: z.string().describe("the vendor slug, e.g. microsoft, redhat, github"),
             advisory_id: z.string().describe("the vendor's advisory ID, e.g. RHSA-2024:1234 or GHSA-xxxx-xxxx-xxxx"),
@@ -525,7 +633,7 @@ export function registerVendorAdvisoryTools(server, kit) {
     }, async ({ vendor, advisory_id }) => kit.checked("get_vendor_advisory", DETAIL_OUTPUT, await detail(vendor, advisory_id)));
     server.registerTool("search_vendor_advisories", {
         title: "Search vendor advisories",
-        description: `Search or list vendor-published advisories, newest first. ${SEARCH_MATCH_DESCRIPTION} Filter by vendor (slug), by severity band, and by whether the advisory names any CVE ID. Advisories their vendor withdrew are left out. Returns advisories, each with vendor, vendor_advisory_id, title, severity, cvss_v3_score, cve_ids, summary and affected_products where present, and the answer's total, total_capped, limit, offset, search_applied and search_match. ${TOTAL_CAPPED_DESCRIPTION} ${DATES_DESCRIPTION} The query is sent in a request header, never in the URL. coverage repeats total, total_capped, limit, offset, search_applied and search_match, and gives returned, the rows in this page, and vendor_windows, each vendor's window in what EchelonGraph holds (only that vendor's when vendor is given): ${WINDOW_DESCRIPTION}. ${NOT_HELD_DESCRIPTION} measured_at is null. ${ENVELOPE_DESCRIPTION} ${TEXT_BUDGET_DESCRIPTION}${ROW_CUT_DESCRIPTION}, or rows are left out and the note gives the offset to call next.`,
+        description: `Search or list vendor-published advisories, newest first. ${SEARCH_MATCH_HEAD} Filter by vendor (slug), severity band and whether the advisory names any CVE ID. Advisories their vendor withdrew are left out. Returns advisories, each with vendor, vendor_advisory_id, title, severity, cvss_v3_score, cve_ids, summary and affected_products where present, and total, total_capped, limit, offset, search_applied and search_match. ${TOTAL_CAPPED_HEAD} ${REJECTED_CVE_DESCRIPTION} The query is sent in a request header, never in the URL. coverage repeats those beside returned, and gives vendor_windows, each vendor's window in what EchelonGraph holds: ${WINDOW_HEAD}. ${NOT_HELD_HEAD} ${TEXT_BUDGET_DESCRIPTION}${ROW_CUT_DESCRIPTION}, or rows are left out and the note gives the offset to call next.`,
         inputSchema: z.object({
             query: z.string().optional().describe("free text, at most 100 bytes: a product, an advisory ID, a CVE ID or a keyword, e.g. 'exchange server'; 1 or 2 characters match whole words only"),
             vendor: z.string().optional().describe("a vendor slug, e.g. microsoft, redhat, github"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "echelongraph-mcp",
-  "version": "2.6.8",
+  "version": "2.7.0",
   "mcpName": "io.echelongraph/echelongraph-mcp",
   "description": "MCP server for CVE lookups: EchelonGraph scores, CISA KEV, EPSS, CWE, exploits, version and SBOM checks, vendor advisories, and per-CVE exposure derived from Shodan data. Shodan data is owned by Shodan, which holds its copyright (© Shodan). Keyless.",
   "type": "module",
@@ -39,6 +39,8 @@
     "cwe",
     "cvss",
     "sbom",
+    "lockfile",
+    "sca",
     "security-advisories",
     "threat-intelligence",
     "exposure",

package/server.json

@@ -17,7 +17,7 @@
       ]
     }
   ],
-  "version": "2.6.8",
+  "version": "2.7.0",
   "remotes": [
     {
       "type": "streamable-http",
@@ -28,7 +28,7 @@
     {
       "registryType": "npm",
       "identifier": "echelongraph-mcp",
-      "version": "2.6.8",
+      "version": "2.7.0",
       "transport": {
         "type": "stdio"
       },