@corbits/mcp 0.3.0 → 0.4.0

package/dist/protocol/extensions.d.ts

@@ -0,0 +1,34 @@
+import type { McpValidationContext, McpExtensionSettings } from "./types.js";
+export declare const MCP_EXT_TASKS = "io.modelcontextprotocol/tasks";
+export declare const MCP_EXT_SKILLS = "io.modelcontextprotocol/skills";
+export declare const MCP_EXT_UI = "io.modelcontextprotocol/ui";
+export declare const MCP_EXTENSIONS: {
+    readonly "io.modelcontextprotocol/tasks": {
+        readonly id: "io.modelcontextprotocol/tasks";
+        readonly coreRevision: "2026-07-28";
+        readonly extensionRevision: "2026-07-28";
+        readonly sourceCommit: "b3d28aceaa6d49f5f92258e3d06b61ad6f111e84";
+        readonly maturity: "stable";
+        readonly enabledByDefault: false;
+    };
+    readonly "io.modelcontextprotocol/skills": {
+        readonly id: "io.modelcontextprotocol/skills";
+        readonly coreRevision: "2026-07-28";
+        readonly extensionRevision: "stable";
+        readonly sourceCommit: "c1aa87e4c381c82b99aa37471d0eae4ab50f9985";
+        readonly maturity: "stable";
+        readonly enabledByDefault: false;
+    };
+    readonly "io.modelcontextprotocol/ui": {
+        readonly id: "io.modelcontextprotocol/ui";
+        readonly coreRevision: "2026-07-28";
+        readonly extensionRevision: "2026-01-26";
+        readonly sourceCommit: "266a9e3b70dbd4a4f0546dda95da2a2c1a8be4b7";
+        readonly maturity: "released";
+        readonly enabledByDefault: false;
+    };
+};
+export declare function extensionEnabled(context: McpValidationContext, id: string): boolean;
+export declare function validateExtensionSettings(settings: McpExtensionSettings): McpExtensionSettings;
+/** Negotiate only explicitly requested, known extensions advertised by the peer. */
+export declare function negotiateExtensions(requested: McpExtensionSettings, peer: McpExtensionSettings): McpExtensionSettings;

package/dist/protocol/extensions.js

@@ -0,0 +1,86 @@
+import { McpError } from "./errors.js";
+export const MCP_EXT_TASKS = "io.modelcontextprotocol/tasks";
+export const MCP_EXT_SKILLS = "io.modelcontextprotocol/skills";
+export const MCP_EXT_UI = "io.modelcontextprotocol/ui";
+export const MCP_EXTENSIONS = {
+    [MCP_EXT_TASKS]: {
+        id: MCP_EXT_TASKS,
+        coreRevision: "2026-07-28",
+        extensionRevision: "2026-07-28",
+        sourceCommit: "b3d28aceaa6d49f5f92258e3d06b61ad6f111e84",
+        maturity: "stable",
+        enabledByDefault: false,
+    },
+    [MCP_EXT_SKILLS]: {
+        id: MCP_EXT_SKILLS,
+        coreRevision: "2026-07-28",
+        extensionRevision: "stable",
+        sourceCommit: "c1aa87e4c381c82b99aa37471d0eae4ab50f9985",
+        maturity: "stable",
+        enabledByDefault: false,
+    },
+    [MCP_EXT_UI]: {
+        id: MCP_EXT_UI,
+        coreRevision: "2026-07-28",
+        extensionRevision: "2026-01-26",
+        sourceCommit: "266a9e3b70dbd4a4f0546dda95da2a2c1a8be4b7",
+        maturity: "released",
+        enabledByDefault: false,
+    },
+};
+export function extensionEnabled(context, id) {
+    const extensions = context.extensions;
+    if (extensions === undefined)
+        return false;
+    return Array.isArray(extensions)
+        ? extensions.includes(id)
+        : Object.hasOwn(extensions, id);
+}
+export function validateExtensionSettings(settings) {
+    for (const [id, value] of Object.entries(settings)) {
+        if (!Object.hasOwn(MCP_EXTENSIONS, id))
+            throw new McpError(`unsupported extension ${id}`);
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+            throw new McpError(`invalid settings for ${id}`);
+        const allowed = id === MCP_EXT_SKILLS
+            ? ["directoryRead"]
+            : id === MCP_EXT_UI
+                ? ["mimeTypes"]
+                : [];
+        if (Object.keys(value).some((key) => !allowed.includes(key)))
+            throw new McpError(`unsupported settings for ${id}`);
+        if (value.directoryRead !== undefined &&
+            typeof value.directoryRead !== "boolean")
+            throw new McpError("directoryRead must be boolean");
+        if (value.mimeTypes !== undefined &&
+            (!Array.isArray(value.mimeTypes) ||
+                !value.mimeTypes.every((v) => typeof v === "string")))
+            throw new McpError("mimeTypes must be strings");
+    }
+    return settings;
+}
+/** Negotiate only explicitly requested, known extensions advertised by the peer. */
+export function negotiateExtensions(requested, peer) {
+    validateExtensionSettings(requested);
+    const result = {};
+    for (const [id, settings] of Object.entries(requested)) {
+        if (!Object.hasOwn(peer, id))
+            continue;
+        const remote = peer[id];
+        if (remote === undefined)
+            continue;
+        validateExtensionSettings({ [id]: remote });
+        if (id === MCP_EXT_UI) {
+            const localTypes = settings.mimeTypes;
+            const remoteTypes = remote.mimeTypes;
+            result[id] = {
+                mimeTypes: (localTypes ?? ["text/html;profile=mcp-app"]).filter((mime) => (remoteTypes ?? ["text/html;profile=mcp-app"]).includes(mime)),
+            };
+        }
+        else if (id === MCP_EXT_SKILLS)
+            result[id] = { directoryRead: remote.directoryRead === true };
+        else
+            result[id] = {};
+    }
+    return result;
+}

package/dist/protocol/headers.d.ts

@@ -0,0 +1,12 @@
+import { type McpValidationContext } from "./types.js";
+export declare function encodeHeaderValue(value: string): string;
+export declare function decodeHeaderValue(value: string): string;
+export type HeaderSlot = {
+    path: string[];
+    header: string;
+    type: "string" | "integer" | "boolean";
+};
+/** Throws for annotations that cannot be statically resolved through properties. */
+export declare function collectHeaderSlots(schema: Record<string, unknown>): HeaderSlot[];
+export declare function paramHeaders(schema: Record<string, unknown> | undefined, args: unknown, _toolName?: string): Record<string, string>;
+export declare function validateRequestHeaders(headers: Headers, method: string, params: Record<string, unknown>, context?: McpValidationContext): void;

package/dist/protocol/headers.js

@@ -0,0 +1,128 @@
+import { McpError, McpErrorCode } from "./errors.js";
+import { mcpNameFor } from "./methods.js";
+import { MCP_PROTOCOL_VERSION } from "./types.js";
+export function encodeHeaderValue(value) {
+    const plain = [...value].every((character) => character === "\t" ||
+        (character.charCodeAt(0) >= 0x20 && character.charCodeAt(0) <= 0x7e)) &&
+        !/^[ \t]|[ \t]$/.test(value) &&
+        !(value.startsWith("=?base64?") && value.endsWith("?="));
+    return plain
+        ? value
+        : `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+export function decodeHeaderValue(value) {
+    if (!(value.startsWith("=?base64?") && value.endsWith("?=")))
+        return value;
+    const match = /^=\?base64\?([A-Za-z0-9+/]*={0,2})\?=$/.exec(value);
+    if (match?.[1] === undefined)
+        throw new McpError("invalid encoded MCP header", 400, McpErrorCode.HeaderMismatch);
+    const bytes = Buffer.from(match[1], "base64");
+    if (bytes.toString("base64") !== match[1])
+        throw new McpError("invalid base64 MCP header", 400, McpErrorCode.HeaderMismatch);
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new McpError("invalid UTF-8 MCP header", 400, McpErrorCode.HeaderMismatch);
+    }
+}
+/** Throws for annotations that cannot be statically resolved through properties. */
+export function collectHeaderSlots(schema) {
+    const slots = [];
+    const seen = new Set();
+    let nodes = 0;
+    const walk = (node, path, reachable, depth) => {
+        if (++nodes > 10_000 || depth > 64)
+            throw new McpError("header schema complexity limit exceeded");
+        if (typeof node !== "object" || node === null)
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                walk(item, path, false, depth + 1);
+            return;
+        }
+        const record = node;
+        if (Object.hasOwn(record, "x-mcp-header")) {
+            const header = record["x-mcp-header"];
+            const kind = record.type;
+            if (!reachable ||
+                path.length === 0 ||
+                typeof header !== "string" ||
+                !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(header) ||
+                (kind !== "string" && kind !== "integer" && kind !== "boolean"))
+                throw new McpError("invalid x-mcp-header annotation");
+            if (seen.has(header.toLowerCase()))
+                throw new McpError("duplicate x-mcp-header annotation");
+            seen.add(header.toLowerCase());
+            slots.push({ path, header, type: kind });
+        }
+        for (const [key, child] of Object.entries(record)) {
+            if (key === "properties" &&
+                typeof child === "object" &&
+                child !== null &&
+                !Array.isArray(child)) {
+                for (const [name, value] of Object.entries(child))
+                    walk(value, [...path, name], reachable, depth + 1);
+            }
+            else if (key !== "x-mcp-header")
+                walk(child, path, false, depth + 1);
+        }
+    };
+    walk(schema, [], true, 0);
+    return slots;
+}
+export function paramHeaders(schema, args, _toolName) {
+    if (schema === undefined)
+        return {};
+    const headers = {};
+    for (const slot of collectHeaderSlots(schema)) {
+        let value = args;
+        for (const key of slot.path)
+            value =
+                typeof value === "object" && value !== null && Object.hasOwn(value, key)
+                    ? value[key]
+                    : undefined;
+        if (value === undefined || value === null)
+            continue;
+        if (slot.type === "integer"
+            ? typeof value !== "number" || !Number.isSafeInteger(value)
+            : typeof value !== slot.type)
+            throw new McpError(`invalid header argument ${slot.path.join(".")}`);
+        headers[`Mcp-Param-${slot.header}`] = encodeHeaderValue(String(value));
+    }
+    return headers;
+}
+export function validateRequestHeaders(headers, method, params, context = {}) {
+    if (context.era === "legacy")
+        return;
+    const meta = params._meta;
+    const version = meta?.["io.modelcontextprotocol/protocolVersion"];
+    const fail = (header) => {
+        throw new McpError(`MCP header mismatch: ${header}`, 400, McpErrorCode.HeaderMismatch);
+    };
+    if (typeof version !== "string" ||
+        headers.get("MCP-Protocol-Version") !== version)
+        fail("MCP-Protocol-Version");
+    if (version !== (context.protocolVersion ?? MCP_PROTOCOL_VERSION))
+        throw new McpError("unsupported protocol version", 400, McpErrorCode.UnsupportedProtocolVersion, { requested: version, supported: [MCP_PROTOCOL_VERSION] });
+    if (headers.get("Mcp-Method") !== method)
+        fail("Mcp-Method");
+    const name = mcpNameFor(method, params);
+    const actual = headers.get("Mcp-Name");
+    if (name !== undefined &&
+        (actual === null || decodeHeaderValue(actual) !== name))
+        fail("Mcp-Name");
+    if (name === undefined && actual !== null)
+        fail("Mcp-Name");
+    const expected = paramHeaders(context.inputSchema, params.arguments);
+    for (const [key, value] of Object.entries(expected)) {
+        const received = headers.get(key);
+        if (received === null ||
+            decodeHeaderValue(received) !== decodeHeaderValue(value))
+            fail(key);
+    }
+    for (const key of headers.keys())
+        if (key.startsWith("mcp-param-") &&
+            !Object.keys(expected).some((name) => name.toLowerCase() === key))
+            fail(key);
+}

package/dist/protocol/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./extensions.js";
+export * from "./methods.js";
+export * from "./headers.js";
+export * from "./json-schema.js";
+export * from "./schemas.js";
+export * from "./envelopes.js";
+export * from "./ui.js";
+export * from "./content.js";
+export * from "./legacy.js";

package/dist/protocol/index.js

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./extensions.js";
+export * from "./methods.js";
+export * from "./headers.js";
+export * from "./json-schema.js";
+export * from "./schemas.js";
+export * from "./envelopes.js";
+export * from "./ui.js";
+export * from "./content.js";
+export * from "./legacy.js";

package/dist/protocol/json-schema.d.ts

@@ -0,0 +1,8 @@
+import type { JsonSchema } from "./types.js";
+/** Limits apply before AJV compilation and before data validation. No network resolver is installed. */
+export declare function assertJsonBounds(value: unknown, schema?: boolean): void;
+/** Resource payloads alone get an explicit allowance; metadata and JSON structure
+ * remain bounded. */
+export declare function assertResourceJsonBounds(value: unknown, maxDecodedBytes: number): void;
+export declare function validateSchema(schema: unknown): JsonSchema;
+export declare function validateInstance(schema: unknown, value: unknown): void;

package/dist/protocol/json-schema.js

@@ -0,0 +1,152 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { Ajv } from "ajv";
+import { McpError, McpErrorCode } from "./errors.js";
+const options = {
+    strict: false,
+    allErrors: false,
+    validateFormats: false,
+    addUsedSchema: false,
+    ownProperties: true,
+    code: { optimize: false },
+    loopRequired: 100,
+    loopEnum: 100,
+};
+const modern = new Ajv2020(options);
+const draft7 = new Ajv(options);
+const cache = new Map();
+/** Limits apply before AJV compilation and before data validation. No network resolver is installed. */
+export function assertJsonBounds(value, schema = false) {
+    assertBounds(value, schema);
+}
+/** Resource payloads alone get an explicit allowance; metadata and JSON structure
+ * remain bounded. */
+export function assertResourceJsonBounds(value, maxDecodedBytes) {
+    if (!Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < 0)
+        throw new McpError("maxDecodedBytes must be a nonnegative safe integer");
+    assertBounds(value, false, Math.min(maxDecodedBytes, 16 * 1024 * 1024));
+}
+function assertBounds(value, schema, resourceBytes) {
+    let nodes = 0;
+    let bytes = 0;
+    let decodedBytes = 0;
+    const active = new Set();
+    const visit = (item, depth, path) => {
+        if (++nodes > (schema ? 10_000 : 100_000) || depth > 64)
+            throw new McpError("JSON complexity limit exceeded");
+        if (typeof item === "string") {
+            const payloadPath = path;
+            const payload = resourceBytes !== undefined &&
+                payloadPath.length === 3 &&
+                payloadPath[0] === "contents" &&
+                payloadPath[1] === "*" &&
+                (payloadPath[2] === "text" || payloadPath[2] === "blob");
+            if (payload) {
+                decodedBytes +=
+                    payloadPath[2] === "text"
+                        ? Buffer.byteLength(item)
+                        : Math.max(0, Math.floor((item.length * 3) / 4) -
+                            (item.endsWith("==") ? 2 : item.endsWith("=") ? 1 : 0));
+                if (decodedBytes > resourceBytes)
+                    throw new McpError("Resource decoded byte limit exceeded");
+                bytes += 2; // JSON string delimiters, not payload encoding
+            }
+            else {
+                bytes += Buffer.byteLength(item);
+                if (resourceBytes !== undefined) {
+                    if (bytes > 64 * 1024)
+                        throw new McpError("Resource metadata/envelope byte limit exceeded");
+                    bytes +=
+                        Buffer.byteLength(JSON.stringify(item)) - Buffer.byteLength(item);
+                }
+            }
+        }
+        else if (typeof item === "number" && !Number.isFinite(item))
+            throw new McpError("JSON numbers must be finite");
+        else if (typeof item === "object" && item !== null) {
+            if (active.has(item))
+                throw new McpError("cyclic JSON value");
+            active.add(item);
+            if (resourceBytes !== undefined)
+                bytes += 2; // braces/brackets
+            let first = true;
+            for (const [key, child] of Object.entries(item)) {
+                if (resourceBytes === undefined)
+                    bytes += Buffer.byteLength(key);
+                else {
+                    if (!first)
+                        bytes++;
+                    if (!Array.isArray(item)) {
+                        if (Buffer.byteLength(key) > 64 * 1024)
+                            throw new McpError("Resource metadata/envelope byte limit exceeded");
+                        bytes += Buffer.byteLength(JSON.stringify(key)) + 1;
+                    }
+                }
+                first = false;
+                visit(child, depth + 1, [...path, Array.isArray(item) ? "*" : key]);
+            }
+            active.delete(item);
+        }
+        else if (item !== null &&
+            typeof item !== "boolean" &&
+            typeof item !== "number")
+            throw new McpError("non-JSON value");
+        if (resourceBytes !== undefined) {
+            if (item === null ||
+                typeof item === "boolean" ||
+                typeof item === "number")
+                bytes += String(item).length;
+            if (bytes > 64 * 1024)
+                throw new McpError("Resource metadata/envelope byte limit exceeded");
+        }
+        if (resourceBytes === undefined &&
+            bytes > (schema ? 256 * 1024 : 4 * 1024 * 1024))
+            throw new McpError("JSON byte limit exceeded");
+    };
+    visit(value, 0, []);
+}
+function compile(schema) {
+    assertJsonBounds(schema, true);
+    if (typeof schema !== "boolean" &&
+        (typeof schema !== "object" || schema === null || Array.isArray(schema)))
+        throw new McpError("JSON Schema must be an object or boolean");
+    const key = JSON.stringify(schema);
+    const existing = cache.get(key);
+    if (existing !== undefined)
+        return existing;
+    const dialect = typeof schema === "object" && schema !== null
+        ? schema.$schema
+        : undefined;
+    const validator = dialect === undefined ||
+        dialect === "https://json-schema.org/draft/2020-12/schema"
+        ? modern
+        : dialect === "http://json-schema.org/draft-07/schema#" ||
+            dialect === "http://json-schema.org/draft-07/schema"
+            ? draft7
+            : undefined;
+    if (validator === undefined)
+        throw new McpError(`unsupported JSON Schema dialect ${String(dialect)}`);
+    try {
+        // Compile an immutable snapshot: caller mutation cannot change a cached validator.
+        const result = validator.compile(JSON.parse(key));
+        if (cache.size >= 128) {
+            const first = cache.keys().next().value;
+            if (first !== undefined)
+                cache.delete(first);
+        }
+        cache.set(key, result);
+        return result;
+    }
+    catch (cause) {
+        throw new McpError(`invalid JSON Schema: ${cause instanceof Error ? cause.message : String(cause)}`, undefined, McpErrorCode.InvalidParams);
+    }
+}
+export function validateSchema(schema) {
+    compile(schema);
+    return schema;
+}
+export function validateInstance(schema, value) {
+    assertJsonBounds(value);
+    const validator = compile(schema);
+    if (!validator(value))
+        throw new McpError(`JSON Schema instance validation failed: ${modern.errorsText(validator.errors)}`, undefined, McpErrorCode.InvalidParams);
+}

package/dist/protocol/legacy.d.ts

@@ -0,0 +1,12 @@
+/** Lifecycle request shared by the three supported Streamable HTTP revisions. */
+declare const Initialize: import("arktype/internal/variants/object.ts").ObjectType<{
+    protocolVersion: string;
+    capabilities: Record<string, unknown>;
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+    _meta?: Record<string, unknown>;
+}, {}>;
+export declare function validateLegacyInitialize(value: unknown): typeof Initialize.infer;
+export {};

package/dist/protocol/legacy.js

@@ -0,0 +1,18 @@
+import { type } from "arktype";
+import { McpError, McpErrorCode } from "./errors.js";
+import { assertJsonBounds } from "./json-schema.js";
+/** Lifecycle request shared by the three supported Streamable HTTP revisions. */
+const Initialize = type({
+    protocolVersion: "string > 0",
+    capabilities: "Record<string, unknown>",
+    clientInfo: { name: "string", version: "string" },
+    "_meta?": "Record<string, unknown>",
+});
+export function validateLegacyInitialize(value) {
+    assertJsonBounds(value);
+    const params = Initialize(value);
+    if (params instanceof type.errors || Array.isArray(params.capabilities)) {
+        throw new McpError("Invalid initialize parameters", 400, McpErrorCode.InvalidParams);
+    }
+    return params;
+}

package/dist/protocol/methods.d.ts

@@ -0,0 +1,116 @@
+export interface McpMethodDescriptor {
+    capability?: string;
+    extension?: string;
+    cacheable: boolean;
+    inputRequired: boolean;
+    task: boolean;
+    nameSource?: "name" | "uri" | "taskId";
+}
+export declare const MCP_METHODS: {
+    readonly "server/discover": {
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "tools/list": {
+        readonly capability: "tools";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "tools/call": {
+        readonly capability: "tools";
+        readonly inputRequired: true;
+        readonly task: true;
+        readonly nameSource: "name";
+        readonly cacheable: false;
+    };
+    readonly "prompts/list": {
+        readonly capability: "prompts";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "prompts/get": {
+        readonly capability: "prompts";
+        readonly inputRequired: true;
+        readonly nameSource: "name";
+        readonly cacheable: false;
+        readonly task: false;
+    };
+    readonly "resources/list": {
+        readonly capability: "resources";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "resources/templates/list": {
+        readonly capability: "resources";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "resources/read": {
+        readonly capability: "resources";
+        readonly cacheable: true;
+        readonly inputRequired: true;
+        readonly nameSource: "uri";
+        readonly task: false;
+    };
+    readonly "completion/complete": {
+        readonly capability: "completions";
+        readonly cacheable: false;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "subscriptions/listen": {
+        readonly capability: "subscriptions";
+        readonly cacheable: false;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "tasks/get": {
+        readonly extension: "io.modelcontextprotocol/tasks";
+        readonly nameSource: "taskId";
+        readonly cacheable: false;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "tasks/update": {
+        readonly extension: "io.modelcontextprotocol/tasks";
+        readonly nameSource: "taskId";
+        readonly cacheable: false;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "tasks/cancel": {
+        readonly extension: "io.modelcontextprotocol/tasks";
+        readonly nameSource: "taskId";
+        readonly cacheable: false;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "skills/list": {
+        readonly extension: "io.modelcontextprotocol/skills";
+        readonly capability: "resources";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "skills/get": {
+        readonly extension: "io.modelcontextprotocol/skills";
+        readonly capability: "resources";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+    readonly "resources/directory/read": {
+        readonly extension: "io.modelcontextprotocol/skills";
+        readonly capability: "resources";
+        readonly cacheable: true;
+        readonly inputRequired: false;
+        readonly task: false;
+    };
+};
+export declare function methodDescriptor(method: string): McpMethodDescriptor | undefined;
+export declare function mcpNameFor(method: string, params?: Record<string, unknown>): string | undefined;

package/dist/protocol/methods.js

@@ -0,0 +1,78 @@
+import { MCP_EXT_SKILLS, MCP_EXT_TASKS } from "./extensions.js";
+const ordinary = {
+    cacheable: false,
+    inputRequired: false,
+    task: false,
+};
+export const MCP_METHODS = {
+    "server/discover": { ...ordinary, cacheable: true },
+    "tools/list": { ...ordinary, capability: "tools", cacheable: true },
+    "tools/call": {
+        ...ordinary,
+        capability: "tools",
+        inputRequired: true,
+        task: true,
+        nameSource: "name",
+    },
+    "prompts/list": { ...ordinary, capability: "prompts", cacheable: true },
+    "prompts/get": {
+        ...ordinary,
+        capability: "prompts",
+        inputRequired: true,
+        nameSource: "name",
+    },
+    "resources/list": { ...ordinary, capability: "resources", cacheable: true },
+    "resources/templates/list": {
+        ...ordinary,
+        capability: "resources",
+        cacheable: true,
+    },
+    "resources/read": {
+        ...ordinary,
+        capability: "resources",
+        cacheable: true,
+        inputRequired: true,
+        nameSource: "uri",
+    },
+    "completion/complete": { ...ordinary, capability: "completions" },
+    "subscriptions/listen": { ...ordinary, capability: "subscriptions" },
+    "tasks/get": { ...ordinary, extension: MCP_EXT_TASKS, nameSource: "taskId" },
+    "tasks/update": {
+        ...ordinary,
+        extension: MCP_EXT_TASKS,
+        nameSource: "taskId",
+    },
+    "tasks/cancel": {
+        ...ordinary,
+        extension: MCP_EXT_TASKS,
+        nameSource: "taskId",
+    },
+    "skills/list": {
+        ...ordinary,
+        extension: MCP_EXT_SKILLS,
+        capability: "resources",
+        cacheable: true,
+    },
+    "skills/get": {
+        ...ordinary,
+        extension: MCP_EXT_SKILLS,
+        capability: "resources",
+        cacheable: true,
+    },
+    "resources/directory/read": {
+        ...ordinary,
+        extension: MCP_EXT_SKILLS,
+        capability: "resources",
+        cacheable: true,
+    },
+};
+export function methodDescriptor(method) {
+    return Object.hasOwn(MCP_METHODS, method)
+        ? MCP_METHODS[method]
+        : undefined;
+}
+export function mcpNameFor(method, params) {
+    const source = methodDescriptor(method)?.nameSource;
+    const value = source === undefined ? undefined : params?.[source];
+    return typeof value === "string" ? value : undefined;
+}