@code-yeongyu/senpi 2026.10.25-1 → 2026.10.25-3

package/dist/core/extensions/builtin/mcp/modern/form-schema.js

@@ -0,0 +1,153 @@
+export const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const own = (value, key) => Object.hasOwn(value, key);
+export function enums(property) {
+    if (Array.isArray(property.enum) &&
+        property.enum.length > 0 &&
+        property.enum.every((entry) => typeof entry === "string")) {
+        return property.enum.map((value) => ({ value, label: value }));
+    }
+    const choices = property.oneOf ?? property.anyOf;
+    if (Array.isArray(choices) &&
+        choices.length > 0 &&
+        choices.every((entry) => isRecord(entry) &&
+            typeof entry.const === "string" &&
+            typeof entry.title === "string" &&
+            Object.keys(entry).every((key) => key === "const" || key === "title"))) {
+        return choices.map((entry) => ({ value: entry.const, label: entry.title }));
+    }
+    return undefined;
+}
+export function validValue(property, value) {
+    if (property.type === "boolean")
+        return typeof value === "boolean";
+    if (property.type === "integer" || property.type === "number") {
+        return (typeof value === "number" &&
+            Number.isFinite(value) &&
+            (property.type !== "integer" || Number.isInteger(value)) &&
+            (typeof property.minimum !== "number" || value >= property.minimum) &&
+            (typeof property.maximum !== "number" || value <= property.maximum));
+    }
+    if (property.type === "array") {
+        const choices = isRecord(property.items) ? enums(property.items) : undefined;
+        return (Array.isArray(value) &&
+            value.every((entry) => typeof entry === "string" && choices?.some((choice) => choice.value === entry)) &&
+            new Set(value).size === value.length &&
+            (typeof property.minItems !== "number" || value.length >= property.minItems) &&
+            (typeof property.maxItems !== "number" || value.length <= property.maxItems));
+    }
+    if (typeof value !== "string")
+        return false;
+    const choices = enums(property);
+    if (choices && !choices.some((choice) => choice.value === value))
+        return false;
+    if (typeof property.minLength === "number" && [...value].length < property.minLength)
+        return false;
+    if (typeof property.maxLength === "number" && [...value].length > property.maxLength)
+        return false;
+    switch (property.format) {
+        case "email":
+            return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+        case "uri": {
+            try {
+                return new URL(value).protocol.length > 1;
+            }
+            catch {
+                return false;
+            }
+        }
+        case "date":
+            return (/^\d{4}-\d{2}-\d{2}$/.test(value) &&
+                Number.isFinite(Date.parse(value)) &&
+                new Date(value).toISOString().slice(0, 10) === value);
+        case "date-time": {
+            const date = value.slice(0, 10);
+            return (/^\d{4}-\d{2}-\d{2}T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/.test(value) &&
+                Number.isFinite(Date.parse(value)) &&
+                new Date(date).toISOString().slice(0, 10) === date);
+        }
+        default:
+            return true;
+    }
+}
+/** Validate a complete submitted form, including unknown keys and omitted required fields. */
+export function validMcpFormContent(schema, content) {
+    return (isRecord(content) &&
+        (schema.required ?? []).every((key) => own(content, key)) &&
+        Object.entries(content).every(([key, value]) => own(schema.properties, key) && validValue(schema.properties[key], value)));
+}
+/** Reject unsupported constraints rather than presenting a weaker schema. */
+export function validateMrtrForm(schema) {
+    if (!isRecord(schema) || schema.type !== "object" || !isRecord(schema.properties))
+        return false;
+    for (const key of ["title", "description"])
+        if (own(schema, key) && typeof schema[key] !== "string")
+            return false;
+    if (Object.keys(schema).some((key) => !["type", "properties", "required", "title", "description", "$schema"].includes(key)))
+        return false;
+    if (schema.required !== undefined &&
+        (!Array.isArray(schema.required) ||
+            !schema.required.every((key) => typeof key === "string" && own(schema.properties, key))))
+        return false;
+    for (const property of Object.values(schema.properties)) {
+        if (!isRecord(property))
+            return false;
+        const allowed = ["type", "title", "description", "default"];
+        switch (property.type) {
+            case "string":
+                allowed.push("minLength", "maxLength", "format", "enum", "oneOf");
+                if (property.format !== undefined &&
+                    !["email", "uri", "date", "date-time"].includes(String(property.format)))
+                    return false;
+                if ((own(property, "enum") || own(property, "oneOf")) && !enums(property))
+                    return false;
+                if (own(property, "enum") && own(property, "oneOf"))
+                    return false;
+                break;
+            case "number":
+            case "integer":
+                allowed.push("minimum", "maximum");
+                break;
+            case "boolean":
+                break;
+            case "array":
+                allowed.push("items", "minItems", "maxItems");
+                if (!isRecord(property.items) ||
+                    !enums(property.items) ||
+                    Object.keys(property.items).some((key) => !["type", "enum", "anyOf"].includes(key)) ||
+                    (property.items.type !== undefined && property.items.type !== "string"))
+                    return false;
+                break;
+            default:
+                return false;
+        }
+        if (Object.keys(property).some((key) => !allowed.includes(key)))
+            return false;
+        for (const key of ["title", "description"])
+            if (own(property, key) && typeof property[key] !== "string")
+                return false;
+        for (const key of ["minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"]) {
+            const value = property[key];
+            if (value !== undefined &&
+                (typeof value !== "number" ||
+                    !Number.isFinite(value) ||
+                    (!["minimum", "maximum"].includes(key) && (!Number.isInteger(value) || value < 0))))
+                return false;
+        }
+        for (const [min, max] of [
+            ["minimum", "maximum"],
+            ["minLength", "maxLength"],
+            ["minItems", "maxItems"],
+        ]) {
+            if (min &&
+                max &&
+                typeof property[min] === "number" &&
+                typeof property[max] === "number" &&
+                property[min] > property[max])
+                return false;
+        }
+        if (own(property, "default") && !validValue(property, property.default))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=form-schema.js.map

package/dist/core/extensions/builtin/mcp/modern/http-fetch.d.ts

@@ -1,5 +1,7 @@
 import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
 import type { McpHttpTransportSpec } from "../transport-sdk.ts";
+export declare const modernCredentialSnapshot: (tokens: OAuthTokens | undefined) => string | undefined;
 /** The existing OAuth provider owns credentials; the SDK owns authorization and origin-safe redirects. */
-export declare function modernHttpFetch(spec: McpHttpTransportSpec, signal: AbortSignal): FetchLike;
+export declare function modernHttpFetch(spec: McpHttpTransportSpec, signal: AbortSignal, authorizeResend?: boolean): FetchLike;
 //# sourceMappingURL=http-fetch.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/http-fetch.js

@@ -1,13 +1,18 @@
 import { fetchWithinOrigin } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { loadMcpSdkAuth } from "../sdk.lazy.js";
+import { modernDispatchGuard } from "./request.js";
+import { clearMcpParameterHeaders } from "./parameter-headers.js";
+export const modernCredentialSnapshot = (tokens) => tokens === undefined ? undefined : JSON.stringify([tokens.access_token, tokens.refresh_token]);
 /** The existing OAuth provider owns credentials; the SDK owns authorization and origin-safe redirects. */
-export function modernHttpFetch(spec, signal) {
+export function modernHttpFetch(spec, signal, authorizeResend = true) {
     const fetch = fetchWithinOrigin();
     return async (url, init) => {
         const requestSignal = init?.signal ? AbortSignal.any([signal, init.signal]) : signal;
         const send = () => {
             const headers = new Headers();
             const tokens = spec.authProvider?.tokens();
+            const guard = init?.[modernDispatchGuard];
+            guard?.(modernCredentialSnapshot(tokens));
             if (tokens)
                 headers.set("Authorization", `Bearer ${tokens.access_token}`);
             new Headers(spec.requestInit?.headers).forEach((value, key) => {
@@ -15,6 +20,7 @@ export function modernHttpFetch(spec, signal) {
             });
             for (const key of ["Mcp-Session-Id", "Mcp-Name", "Mcp-Method", "MCP-Protocol-Version"])
                 headers.delete(key);
+            clearMcpParameterHeaders(headers);
             new Headers(init?.headers).forEach((value, key) => {
                 headers.set(key, value);
             });
@@ -27,7 +33,7 @@ export function modernHttpFetch(spec, signal) {
             });
         };
         let response = await send();
-        if (spec.authProvider && (response.status === 401 || response.status === 403)) {
+        if (authorizeResend && spec.authProvider && (response.status === 401 || response.status === 403)) {
             const { auth, extractWWWAuthenticateParams, UnauthorizedError } = await loadMcpSdkAuth();
             const { resourceMetadataUrl, scope, error } = extractWWWAuthenticateParams(response);
             if (response.status === 401 || error === "insufficient_scope") {

package/dist/core/extensions/builtin/mcp/modern/inputs.d.ts

@@ -0,0 +1,11 @@
+type Input = {
+    method: "elicitation/create";
+    params: {
+        mode?: "form" | "url";
+        message: string;
+        requestedSchema?: unknown;
+    };
+};
+export declare function parseInputs(result: Record<string, unknown>): Map<string, Input> | undefined;
+export {};
+//# sourceMappingURL=inputs.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/inputs.js

@@ -0,0 +1,65 @@
+import { isRecord, validateMrtrForm } from "./form-schema.js";
+import { McpMrtrError } from "./errors.js";
+const own = (value, key) => Object.hasOwn(value, key);
+const byteSize = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+export function parseInputs(result) {
+    if (!own(result, "requestState") && !own(result, "inputRequests"))
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    if (own(result, "requestState") && typeof result.requestState !== "string")
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    if (byteSize(result) > 512 * 1024 ||
+        (typeof result.requestState === "string" && Buffer.byteLength(result.requestState) > 64 * 1024))
+        throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+    if (!own(result, "inputRequests"))
+        return undefined;
+    if (!isRecord(result.inputRequests))
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    const entries = Object.entries(result.inputRequests);
+    if (entries.length > 32)
+        throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+    // Scan the complete batch before collecting anything, including unsupported capability requests.
+    for (const [, input] of entries)
+        if (isRecord(input) && ["roots/list", "sampling/createMessage"].includes(String(input.method)))
+            throw new McpMrtrError("MCP_MRTR_UNSUPPORTED_INPUT");
+    const inputs = new Map();
+    const checkStrings = (value) => {
+        if (typeof value === "string" && Buffer.byteLength(value) > 16 * 1024)
+            throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+        if (Array.isArray(value))
+            for (const entry of value)
+                checkStrings(entry);
+        else if (isRecord(value))
+            for (const [key, entry] of Object.entries(value)) {
+                checkStrings(key);
+                checkStrings(entry);
+            }
+    };
+    for (const [key, input] of entries) {
+        checkStrings(key);
+        if (!isRecord(input) ||
+            input.method !== "elicitation/create" ||
+            !isRecord(input.params) ||
+            typeof input.params.message !== "string")
+            throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+        const params = input.params;
+        checkStrings(params);
+        if (params.mode === "url") {
+            if (typeof params.url !== "string" || typeof params.elicitationId !== "string")
+                throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+            throw new McpMrtrError("MCP_MRTR_UNSUPPORTED_INPUT");
+        }
+        else {
+            if (params.mode !== undefined && params.mode !== "form")
+                throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+            if (isRecord(params.requestedSchema) &&
+                isRecord(params.requestedSchema.properties) &&
+                Object.keys(params.requestedSchema.properties).length > 64)
+                throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+            if (!validateMrtrForm(params.requestedSchema))
+                throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+        }
+        inputs.set(key, input);
+    }
+    return inputs;
+}
+//# sourceMappingURL=inputs.js.map

package/dist/core/extensions/builtin/mcp/modern/parameter-headers.d.ts

@@ -0,0 +1,11 @@
+/** RFC 9110 field values, preserving whitespace and literal sentinel strings. */
+export declare function encodeMcpHeaderValue(value: string): string;
+/** Configured headers must never supply parameter metadata absent from the request body. */
+export declare function clearMcpParameterHeaders(headers: Headers): void;
+/** Connection-local catalog: never shared with another server or transport generation. */
+export declare class ModernParameterHeaders {
+    #private;
+    filterTools(tools: readonly unknown[], firstPage: boolean): unknown[];
+    append(headers: Headers, name: unknown, args: unknown): void;
+}
+//# sourceMappingURL=parameter-headers.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/parameter-headers.js

@@ -0,0 +1,109 @@
+import { Buffer } from "node:buffer";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** RFC 9110 field values, preserving whitespace and literal sentinel strings. */
+export function encodeMcpHeaderValue(value) {
+    return /^[\x09\x20-\x7e]*$/.test(value) &&
+        value.trim() === value &&
+        !(value.startsWith("=?base64?") && value.endsWith("?="))
+        ? value
+        : `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+/** Configured headers must never supply parameter metadata absent from the request body. */
+export function clearMcpParameterHeaders(headers) {
+    for (const name of [...headers.keys()]) {
+        if (name.toLowerCase().startsWith("mcp-param-"))
+            headers.delete(name);
+    }
+}
+function parseParameterHeaders(schema) {
+    const headers = [];
+    const names = new Set();
+    const visit = (node, path) => {
+        if (!isRecord(node))
+            return true;
+        if (Object.hasOwn(node, "x-mcp-header")) {
+            const name = node["x-mcp-header"];
+            const type = node.type;
+            if (!path?.length ||
+                typeof name !== "string" ||
+                !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name) ||
+                names.has(name.toLowerCase()) ||
+                (type !== "string" && type !== "integer" && type !== "boolean"))
+                return false;
+            names.add(name.toLowerCase());
+            headers.push({ name, path, type });
+        }
+        // Only schema-valued keywords are traversed: examples/default/const are instance data.
+        for (const [keyword, value] of Object.entries(node)) {
+            if (["properties", "patternProperties", "$defs", "definitions", "dependentSchemas", "dependencies"].includes(keyword)) {
+                if (!isRecord(value))
+                    continue;
+                for (const [key, child] of Object.entries(value)) {
+                    const childPath = keyword === "properties" && path !== undefined ? [...path, key] : undefined;
+                    if (!visit(child, childPath))
+                        return false;
+                }
+            }
+            else if ([
+                "items",
+                "prefixItems",
+                "allOf",
+                "anyOf",
+                "oneOf",
+                "additionalItems",
+                "additionalProperties",
+                "unevaluatedItems",
+                "unevaluatedProperties",
+                "contains",
+                "propertyNames",
+                "not",
+                "if",
+                "then",
+                "else",
+                "contentSchema",
+            ].includes(keyword)) {
+                for (const child of Array.isArray(value) ? value : [value]) {
+                    if (!visit(child, undefined))
+                        return false;
+                }
+            }
+        }
+        return true;
+    };
+    return visit(schema, []) ? headers : undefined;
+}
+/** Connection-local catalog: never shared with another server or transport generation. */
+export class ModernParameterHeaders {
+    #tools = new Map();
+    filterTools(tools, firstPage) {
+        if (firstPage)
+            this.#tools.clear();
+        return tools.filter((tool) => {
+            if (!isRecord(tool) || typeof tool.name !== "string")
+                return true;
+            const headers = parseParameterHeaders(tool.inputSchema);
+            if (headers === undefined) {
+                this.#tools.delete(tool.name);
+                return false;
+            }
+            this.#tools.set(tool.name, headers);
+            return true;
+        });
+    }
+    append(headers, name, args) {
+        if (typeof name !== "string")
+            return;
+        for (const parameter of this.#tools.get(name) ?? []) {
+            let value = args;
+            for (const key of parameter.path) {
+                value = isRecord(value) && Object.hasOwn(value, key) ? value[key] : undefined;
+            }
+            const valid = (parameter.type === "string" && typeof value === "string") ||
+                (parameter.type === "boolean" && typeof value === "boolean") ||
+                (parameter.type === "integer" && typeof value === "number" && Number.isSafeInteger(value));
+            if (valid)
+                headers.set(`Mcp-Param-${parameter.name}`, encodeMcpHeaderValue(String(value)));
+        }
+    }
+}
+//# sourceMappingURL=parameter-headers.js.map

package/dist/core/extensions/builtin/mcp/modern/request.d.ts

@@ -0,0 +1,20 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type McpClock } from "../wrap.ts";
+export declare const MAX_MCP_MRTR_ROUNDS = 8;
+/** Local dispatch guard survives SDK object spreads but is never JSON serialized. */
+export declare const modernDispatchGuard: unique symbol;
+export interface ModernProtocolState {
+    privateForms?: boolean;
+    legacyFormEligible?: boolean;
+    version?: string;
+    legacy?: boolean;
+    resolveStdioDiagnostics?: (modern: boolean) => void;
+    activateRequests?: () => void;
+}
+export type MrtrClock = McpClock;
+export declare const isModernMcpClient: (client: Client) => boolean;
+export declare const legacyMcpFormsAdvertised: (client: Client) => boolean | undefined;
+export declare function getModernDispatchGuard(params: unknown): ((credential?: string) => void) | undefined;
+/** One instance-local adapter. Captured SDK requests retain ID allocation and final output-schema validation. */
+export declare function installModernRequestAdapter(client: Client, protocol: ModernProtocolState, clock?: MrtrClock, readCredential?: () => string | undefined): void;
+//# sourceMappingURL=request.d.ts.map