echelongraph-mcp 3.0.2 → 3.1.0

package/dist/runtime.js

@@ -20,7 +20,72 @@ export function isHttpEntrypoint() {
 }
 const clientStore = new AsyncLocalStorage();
 export function withClient(clientIp, fn, opts = {}) {
-    return clientStore.run({ clientIp, synthetic: opts.synthetic === true, signal: opts.signal, work: opts.work }, fn);
+    return clientStore.run({ clientIp, synthetic: opts.synthetic === true, signal: opts.signal, work: opts.work, rpcMethod: opts.rpcMethod, tool: opts.tool, protocolVersion: opts.protocolVersion }, fn);
+}
+/** #2923: the fixed labels of the request being served, for a line the SDK's onerror writes (it is handed only the
+ *  error): the JSON-RPC method (MCP_METHODS or "(other)") and the protocol-version label; "(none)" outside a request. */
+export function requestLabels() {
+    const scope = clientStore.getStore();
+    return { rpcMethod: scope?.rpcMethod ?? "(none)", protocolVersion: scope?.protocolVersion ?? "(none)" };
+}
+let upstreamSink;
+/** http.ts only: where each failed API call is reported. */
+export function onUpstreamFailure(sink) {
+    upstreamSink = sink;
+}
+/** Reports one failed API call: on the hosted endpoint to http.ts's line; on stdio, nowhere. */
+export function upstreamFailed(f) {
+    if (!httpEntrypoint || !upstreamSink)
+        return;
+    const scope = clientStore.getStore();
+    try {
+        upstreamSink({ ...f, tool: scope?.tool ?? "(none)", rpcMethod: scope?.rpcMethod ?? "(none)", synthetic: scope?.synthetic === true });
+    }
+    catch {
+        // A log line never fails the call it describes.
+    }
+}
+const DNS_CODES = new Set(["ENOTFOUND", "EAI_AGAIN", "EAI_FAIL", "EAI_NONAME", "EAI_NODATA"]);
+const RESET_CODES = new Set(["ECONNRESET", "EPIPE", "ECONNABORTED", "UND_ERR_SOCKET"]);
+const CONNECT_TIMEOUT_CODES = new Set(["UND_ERR_CONNECT_TIMEOUT", "ETIMEDOUT"]);
+const TIMEOUT_CODES = new Set(["UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT"]);
+const UNREACHABLE_CODES = new Set(["EHOSTUNREACH", "ENETUNREACH", "EHOSTDOWN", "ENETDOWN"]);
+const TLS_CODE = /^(?:ERR_TLS_|ERR_SSL_|ERR_OSSL_|CERT_|UNABLE_TO_|DEPTH_ZERO_SELF_SIGNED_CERT$|SELF_SIGNED_CERT_IN_CHAIN$|HOSTNAME_MISMATCH$)/;
+/** The class of a fetch that threw: from the first code in its cause chain this knows, else network. Codes only, never a message. */
+export function networkFailureClass(e) {
+    const codes = [];
+    let c = e;
+    for (let depth = 0; c instanceof Error && depth < 5; depth++) {
+        const x = c;
+        if (typeof x.code === "string")
+            codes.push(x.code);
+        // A connection tried on several addresses fails as an AggregateError of each one's error.
+        if (Array.isArray(x.errors)) {
+            for (const y of x.errors) {
+                const code = y?.code;
+                if (typeof code === "string")
+                    codes.push(code);
+            }
+        }
+        c = x.cause;
+    }
+    for (const code of codes) {
+        if (DNS_CODES.has(code))
+            return "dns";
+        if (code === "ECONNREFUSED")
+            return "refused";
+        if (RESET_CODES.has(code))
+            return "reset";
+        if (CONNECT_TIMEOUT_CODES.has(code))
+            return "connect_timeout";
+        if (TIMEOUT_CODES.has(code))
+            return "timeout";
+        if (UNREACHABLE_CODES.has(code))
+            return "unreachable";
+        if (TLS_CODE.test(code))
+            return "tls";
+    }
+    return "network";
 }
 // #2775: a hosted client can go before its answer is ready (its own timeout, a closed tab, a
 // retry). Nobody will read that answer, so the request's API calls are cancelled (index.ts api()

package/dist/schemaRefusal.js

@@ -0,0 +1,138 @@
+const REFUSED = Symbol("echelongraph-mcp.schema-refused");
+const isRefused = (v) => typeof v === "object" && v !== null && REFUSED in v;
+// How many issues the note names one by one; the rest are counted.
+const ISSUES_NAMED = 5;
+const keyOf = (p) => (typeof p === "object" && p !== null ? p.key : p);
+// files[0].filename, as a model reads an argument path.
+function pathText(path) {
+    let out = "";
+    for (const p of path ?? []) {
+        const k = keyOf(p);
+        out += typeof k === "number" ? `[${k}]` : out === "" ? String(k) : `.${String(k)}`;
+    }
+    return out;
+}
+// The value the caller sent at a path, to name its JSON type (never the value itself).
+function valueAt(input, path) {
+    let v = input;
+    for (const p of path ?? []) {
+        if (v === null || typeof v !== "object")
+            return undefined;
+        v = v[keyOf(p)];
+    }
+    return v;
+}
+function jsonType(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "an array";
+    if (typeof v === "number")
+        return Number.isInteger(v) ? "an integer" : "a number";
+    if (typeof v === "object")
+        return "an object";
+    return typeof v === "string" ? "a string" : typeof v === "boolean" ? "a boolean" : typeof v;
+}
+const TYPE_NAMES = {
+    string: "a string",
+    number: "a number",
+    int: "an integer",
+    boolean: "a boolean",
+    array: "an array",
+    object: "an object",
+    record: "an object",
+    bigint: "an integer",
+};
+const listOf = (items) => (items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} or ${items[items.length - 1]}`);
+const bound = (n) => (typeof n === "bigint" ? n.toString() : typeof n === "number" ? String(n) : "?");
+// One issue as "<argument> <rule>": the argument named by its path in the arguments, the rule in the
+// inputSchema's terms. An issue this does not know is given in the schema library's own words.
+export function issueText(issue, input) {
+    const at = pathText(issue.path);
+    const name = at === "" ? "the arguments" : at;
+    const sent = valueAt(input, issue.path);
+    switch (issue.code) {
+        case "invalid_type": {
+            const want = TYPE_NAMES[issue.expected ?? ""] ?? issue.expected ?? "another type";
+            if (sent === undefined)
+                return `${name} is required (${want})`;
+            if (issue.expected === "int" && typeof sent === "number")
+                return `${name} must be an integer`;
+            return `${name} must be ${want}, not ${jsonType(sent)}`;
+        }
+        case "too_big":
+        case "too_small": {
+            const big = issue.code === "too_big";
+            const n = bound(big ? issue.maximum : issue.minimum);
+            const cmp = issue.inclusive === false ? (big ? "less than" : "more than") : big ? "at most" : "at least";
+            if (issue.origin === "string")
+                return `${name} must be ${cmp} ${n} ${n === "1" ? "character" : "characters"} long`;
+            if (issue.origin === "array" || issue.origin === "set")
+                return `${name} must hold ${cmp} ${n} ${n === "1" ? "entry" : "entries"}`;
+            return `${name} must be ${cmp} ${n}`;
+        }
+        case "invalid_value":
+            return Array.isArray(issue.values) && issue.values.length
+                ? `${name} must be ${issue.values.length === 1 ? "" : "one of "}${listOf(issue.values.map((v) => JSON.stringify(v)))}`
+                : `${name}: ${issue.message}`;
+        case "unrecognized_keys": {
+            const keys = (issue.keys ?? []).map((k) => (at === "" ? k : `${at}.${k}`));
+            return keys.length ? `${listOf(keys)} ${keys.length === 1 ? "is not an argument" : "are not arguments"} this tool takes` : `${name}: ${issue.message}`;
+        }
+        case "invalid_format":
+            return `${name} must be ${issue.format ? `a valid ${issue.format}` : "in the format the inputSchema gives"}`;
+        case "invalid_union": {
+            // Each branch refused only the value's type: name the types the branches take.
+            const types = (issue.errors ?? []).map((b) => (b.length === 1 && b[0].code === "invalid_type" && !b[0].path?.length ? TYPE_NAMES[b[0].expected ?? ""] : undefined));
+            const named = types.length > 0 && types.every((t) => t !== undefined) ? [...new Set(types)] : undefined;
+            return named ? `${name} must be ${listOf(named)}, not ${jsonType(sent)}` : `${name} must take one of the forms the inputSchema allows, not ${jsonType(sent)}`;
+        }
+        default:
+            return `${name}: ${issue.message}`;
+    }
+}
+// The reason a refusal gives, as one clause: each issue in turn, then how many more there are.
+export function refusalReason(issues, input) {
+    const named = issues.slice(0, ISSUES_NAMED).map((i) => issueText(i, input));
+    const more = issues.length - named.length;
+    return `the arguments do not fit this tool's inputSchema (tools/list): ${named.join("; ")}${more > 0 ? `; and ${more} more ${more === 1 ? "issue" : "issues"}` : ""}`;
+}
+// The inputSchema a tool is registered with: `schema` itself for tools/list (its own jsonSchema,
+// so the published JSON is the original's), and a validate that answers what `schema` answers for
+// arguments it accepts, and a Refused marker, not the issues, for arguments it refuses.
+export function lenientSchema(schema) {
+    const std = schema["~standard"];
+    const settle = (value, r) => (r.issues && r.issues.length ? { value: { [REFUSED]: { issues: r.issues, input: value } } } : r);
+    return {
+        "~standard": {
+            version: std.version,
+            vendor: std.vendor,
+            jsonSchema: std.jsonSchema,
+            validate: (value) => {
+                const r = std.validate(value);
+                return r instanceof Promise ? r.then((x) => settle(value, x)) : settle(value, r);
+            },
+        },
+    };
+}
+const isStandardSchema = (s) => typeof s === "object" && s !== null && typeof s["~standard"]?.validate === "function";
+/**
+ * Makes every tool `server` registers from now on answer arguments that break its inputSchema with
+ * `refuse(tool, reason)` (index.ts badInput: the invalid_input envelope), not the SDK's bare error.
+ * Call it before the first registerTool. tools/list is unchanged.
+ */
+export function withSchemaRefusal(server, refuse) {
+    const register = server.registerTool.bind(server);
+    const wrapped = (name, config, cb) => {
+        if (!isStandardSchema(config.inputSchema))
+            return register(name, config, cb);
+        return register(name, { ...config, inputSchema: lenientSchema(config.inputSchema) }, (args, ctx) => {
+            if (!isRefused(args))
+                return cb(args, ctx);
+            const { issues, input } = args[REFUSED];
+            return refuse(name, refusalReason(issues, input));
+        });
+    };
+    server.registerTool = wrapped;
+    return server;
+}