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

package/dist/core/extensions/builtin/mcp/modern/consent-queue.d.ts

@@ -0,0 +1,2 @@
+export declare function queuedForm<T>(binding: object, signal: AbortSignal, run: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=consent-queue.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/consent-queue.js

@@ -0,0 +1,59 @@
+import { McpMrtrError } from "./errors.js";
+const queues = new WeakMap();
+export function queuedForm(binding, signal, run) {
+    let queue = queues.get(binding);
+    if (!queue) {
+        queue = { busy: false, jobs: [] };
+        queues.set(binding, queue);
+    }
+    const current = queue;
+    const pump = () => {
+        if (current.busy)
+            return;
+        const next = current.jobs.shift();
+        if (!next) {
+            queues.delete(binding);
+            return;
+        }
+        next.signal.removeEventListener("abort", next.abort);
+        if (next.signal.aborted) {
+            next.reject(new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE"));
+            pump();
+            return;
+        }
+        current.busy = true;
+        void next.run().finally(() => {
+            current.busy = false;
+            pump();
+        });
+    };
+    return new Promise((resolve, reject) => {
+        const job = {
+            signal,
+            run: async () => {
+                try {
+                    resolve(await run());
+                }
+                catch (error) {
+                    reject(error);
+                }
+            },
+            reject,
+            abort: () => { },
+        };
+        job.abort = () => {
+            const index = current.jobs.indexOf(job);
+            if (index >= 0) {
+                current.jobs.splice(index, 1);
+                signal.removeEventListener("abort", job.abort);
+                reject(new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE"));
+            }
+        };
+        current.jobs.push(job);
+        signal.addEventListener("abort", job.abort, { once: true });
+        if (signal.aborted)
+            job.abort();
+        pump();
+    });
+}
+//# sourceMappingURL=consent-queue.js.map

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

@@ -0,0 +1,4 @@
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+/** Control/diagnostic payloads are private from admission, not merely after consent starts. */
+export declare function sanitizeModernMessage(message: JSONRPCMessage): JSONRPCMessage | undefined;
+//# sourceMappingURL=diagnostics.d.ts.map

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

@@ -0,0 +1,39 @@
+import { McpMrtrError } from "./errors.js";
+/** Control/diagnostic payloads are private from admission, not merely after consent starts. */
+export function sanitizeModernMessage(message) {
+    if ("error" in message)
+        return {
+            jsonrpc: "2.0",
+            id: message.id,
+            error: { code: message.error.code, message: "MCP server request failed." },
+        };
+    if (!("method" in message))
+        return message;
+    if ("id" in message)
+        throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+    if (message.method === "notifications/progress") {
+        const params = message.params;
+        if (!params ||
+            typeof params.progress !== "number" ||
+            !Number.isFinite(params.progress) ||
+            (params.total !== undefined && (typeof params.total !== "number" || !Number.isFinite(params.total))))
+            return undefined;
+        return {
+            jsonrpc: "2.0",
+            method: message.method,
+            params: {
+                progressToken: params.progressToken,
+                progress: params.progress,
+                ...(params.total === undefined ? {} : { total: params.total }),
+            },
+        };
+    }
+    if (message.method === "notifications/message")
+        return {
+            jsonrpc: "2.0",
+            method: message.method,
+            params: { level: "info", data: "MCP server diagnostic suppressed." },
+        };
+    return message;
+}
+//# sourceMappingURL=diagnostics.js.map

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

@@ -1,19 +1,22 @@
-import { configureMcpElicitation, mcpClientCapabilities } from "../elicitation.js";
 import { ConnectError } from "../errors.js";
-import { loadMcpSdkClient } from "../sdk.lazy.js";
 import { materializeMcpTransport, } from "../transport-sdk.js";
 import { probeHttpEra } from "./era.js";
-import { modernHttpFetch } from "./http-fetch.js";
+import { modernCredentialSnapshot, modernHttpFetch } from "./http-fetch.js";
+import { createMcpRequestClient } from "./client.js";
 import { ModernSdkBridge } from "./sdk-bridge.js";
 import { probeStdioTransport } from "./stdio-probe.js";
 import { ModernHttpTransport } from "./transport.js";
 import { MODERN_PROTOCOL_VERSION } from "./wire.js";
 const clientInfo = { name: "senpi-mcp-client", version: "0.0.0" };
+const probeOptions = {
+    clientInfo,
+    clientCapabilities: {},
+    supportedVersions: [MODERN_PROTOCOL_VERSION],
+};
 export async function materializeNegotiatedTransport(options, serverName, timeoutMs, signal) {
     signal.throwIfAborted();
-    const clientCapabilities = mcpClientCapabilities(options.elicitationEnabled);
-    const probeOptions = { clientInfo, clientCapabilities, supportedVersions: [MODERN_PROTOCOL_VERSION] };
     const { spec, logger } = options;
+    const protocol = {};
     let outcome = { kind: "legacy-fallback" };
     if (spec.kind === "http") {
         const fetch = modernHttpFetch(spec, signal);
@@ -28,14 +31,13 @@ export async function materializeNegotiatedTransport(options, serverName, timeou
                     serverName,
                 });
             }
-            const { Client } = await loadMcpSdkClient();
-            const client = new Client(clientInfo, { capabilities: clientCapabilities });
-            await configureMcpElicitation(client, options.elicitationUiProvider, undefined, options.elicitationEnabled);
+            protocol.version = outcome.version;
+            const client = await createMcpRequestClient(protocol, options.elicitationUiProvider, () => modernCredentialSnapshot(spec.authProvider?.tokens()), options.elicitationEnabled);
             const transport = new ModernSdkBridge(new ModernHttpTransport({
                 url: spec.url,
-                fetch,
+                fetch: modernHttpFetch(spec, signal, false),
                 clientInfo,
-                clientCapabilities,
+                clientCapabilities: {},
                 protocolVersion: outcome.version,
             }), outcome.discovery, outcome.version);
             const version = outcome.version;
@@ -59,12 +61,20 @@ export async function materializeNegotiatedTransport(options, serverName, timeou
         }
     }
     // Unknown endpoints (including legacy session-required 404s and auth challenges) retain SDK diagnostics.
-    const legacy = await materializeMcpTransport(options);
+    if (spec.kind === "http")
+        protocol.legacy = true;
+    const legacy = await materializeMcpTransport(options, protocol);
     // A modern stdio child is detected when the SDK starts it, before its local initialize answer sets the version.
     let stdioModernVersion;
     if (spec.kind === "stdio") {
         probeStdioTransport(legacy.transport, probeOptions, logger, timeoutMs, serverName, (version) => {
             stdioModernVersion = version;
+            protocol.version = version;
+            protocol.activateRequests?.();
+            protocol.resolveStdioDiagnostics?.(true);
+        }, undefined, () => {
+            protocol.legacy = true;
+            protocol.resolveStdioDiagnostics?.(false);
         });
     }
     logVersion(legacy.transport, () => stdioModernVersion);

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

@@ -0,0 +1,14 @@
+import type { McpMrtrPresentation } from "../../../../mcp-mrtr-presentations.ts";
+import { type Value } from "./form-schema.ts";
+export type MrtrInputResponse = {
+    action: "accept";
+    content: Record<string, Value>;
+} | {
+    action: "decline" | "cancel";
+};
+/** No model-facing questions, RPC requests, timers, persistence, or network operations. */
+export declare function collectMrtrForm(presentation: McpMrtrPresentation, serverLabel: string, params: {
+    message: string;
+    requestedSchema: unknown;
+}, signal: AbortSignal): Promise<MrtrInputResponse>;
+//# sourceMappingURL=elicitation.d.ts.map

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

@@ -0,0 +1,145 @@
+import { stripVTControlCharacters } from "node:util";
+import { bindMcpFormPresented } from "../../../../mcp-form-types.js";
+import { McpMrtrError } from "./errors.js";
+import { enums, isRecord, validValue, validateMrtrForm } from "./form-schema.js";
+const own = (value, key) => Object.hasOwn(value, key);
+const inert = (value) => stripVTControlCharacters(value).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g, "");
+/** No model-facing questions, RPC requests, timers, persistence, or network operations. */
+export async function collectMrtrForm(presentation, serverLabel, params, signal) {
+    if (!validateMrtrForm(params.requestedSchema))
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    const schema = params.requestedSchema;
+    const abort = new AbortController();
+    const combined = AbortSignal.any([signal, presentation.signal, abort.signal]);
+    const opts = { signal: combined, ephemeral: true };
+    bindMcpFormPresented(opts, presentation.presented);
+    const heading = `MCP server: ${inert(serverLabel)}\n${inert(params.message)}`;
+    const select = async (title, choices) => {
+        if (combined.aborted)
+            return undefined;
+        const answer = presentation.ui.select(title, choices, opts);
+        const result = await answer;
+        return combined.aborted ? undefined : result;
+    };
+    const content = Object.create(null);
+    const finish = (result) => {
+        if (!combined.aborted)
+            presentation.admit?.();
+        return result;
+    };
+    const required = new Set(schema.required ?? []);
+    const entries = Object.entries(schema.properties);
+    const field = async (name, property) => {
+        const title = `${heading}\n${inert(String(property.title ?? name))}${typeof property.description === "string" ? `\n${inert(property.description)}` : ""}`;
+        for (;;) {
+            const actions = ["Enter value"];
+            if (!required.has(name))
+                actions.push("Leave unset");
+            if (own(property, "default"))
+                actions.push("Use default");
+            // Primitive selectors already require an explicit choice; do not conflate false with dismissal.
+            let action = "Enter value";
+            if (actions.length > 1) {
+                const chosen = await select(title, actions);
+                if (chosen === undefined)
+                    return false;
+                action = chosen;
+            }
+            if (action === "Leave unset") {
+                delete content[name];
+                return true;
+            }
+            if (action === "Use default") {
+                content[name] = structuredClone(property.default);
+                return true;
+            }
+            let value;
+            if (property.type === "boolean") {
+                const chosen = await select(title, ["true", "false"]);
+                if (chosen === undefined)
+                    return false;
+                value = chosen === "true";
+            }
+            else if (property.type === "array" || enums(property)) {
+                const choices = property.type === "array" && isRecord(property.items) ? enums(property.items) : enums(property);
+                if (choices === undefined)
+                    return false;
+                const values = [];
+                for (;;) {
+                    const labels = choices.map((choice, index) => `${index + 1}. ${inert(choice.label)}${values.includes(choice.value) ? " [selected]" : ""}`);
+                    if (property.type === "array")
+                        labels.push("Done");
+                    const chosen = await select(title, labels);
+                    if (chosen === undefined)
+                        return false;
+                    if (chosen === "Done") {
+                        value = values;
+                        break;
+                    }
+                    const index = labels.indexOf(chosen);
+                    const choice = choices[index];
+                    if (!choice)
+                        continue;
+                    if (property.type !== "array") {
+                        value = choice.value;
+                        break;
+                    }
+                    const existing = values.indexOf(choice.value);
+                    if (existing >= 0)
+                        values.splice(existing, 1);
+                    else
+                        values.push(choice.value);
+                }
+            }
+            else {
+                if (combined.aborted)
+                    return false;
+                const text = await presentation.ui.input(title, undefined, opts);
+                if (text === undefined || combined.aborted)
+                    return false;
+                value =
+                    property.type === "number" || property.type === "integer"
+                        ? text.trim() === ""
+                            ? NaN
+                            : Number(text)
+                        : text;
+            }
+            if (validValue(property, value)) {
+                content[name] = value;
+                return true;
+            }
+            if ((await select(`${title}\nValue does not satisfy this field.`, ["Try again", "Cancel"])) !== "Try again")
+                return false;
+        }
+    };
+    try {
+        const begin = await select(heading, ["Continue", "Decline", "Cancel"]);
+        if (begin !== "Continue")
+            return finish({ action: begin === "Decline" ? "decline" : "cancel" });
+        for (const [name, property] of entries)
+            if (!(await field(name, property)))
+                return finish({ action: "cancel" });
+        for (;;) {
+            const review = entries
+                .map(([name]) => `${inert(name)}: ${own(content, name) ? inert(JSON.stringify(content[name])) : "(unset)"}`)
+                .join("\n");
+            const action = await select(`${heading}\nReview\n${review}`, ["Submit", "Edit field", "Decline", "Cancel"]);
+            if (action === "Submit" && !combined.aborted)
+                return finish({ action: "accept", content: structuredClone(content) });
+            if (action !== "Edit field")
+                return finish({ action: action === "Decline" ? "decline" : "cancel" });
+            const labels = entries.map(([name], index) => `${index + 1}. ${inert(name)}`);
+            const chosen = await select(`${heading}\nEdit field`, labels);
+            const entry = chosen === undefined ? undefined : entries[labels.indexOf(chosen)];
+            if (!entry || !(await field(...entry)))
+                return finish({ action: "cancel" });
+        }
+    }
+    finally {
+        bindMcpFormPresented(opts, undefined);
+        abort.abort();
+        for (const key of Object.keys(content))
+            delete content[key];
+    }
+}
+//# sourceMappingURL=elicitation.js.map

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

@@ -0,0 +1,21 @@
+declare const messages: {
+    readonly MCP_MRTR_ROUND_LIMIT: "Request stopped after 8 input rounds; start a new request to continue.";
+    readonly MCP_MRTR_INPUT_LIMIT: "Server input exceeds the client's supported limits.";
+    readonly MCP_MRTR_INVALID_INPUT: "Server returned an invalid input request or form schema.";
+    readonly MCP_MRTR_UNSUPPORTED_INPUT: "Server requested an undeclared client feature.";
+    readonly MCP_MRTR_PROCESSING_UNAVAILABLE: "Elicitation processing unavailable.";
+    readonly MCP_MRTR_INVALID_RESULT: "Server returned an unsupported or invalid result type/shape.";
+    readonly MCP_MRTR_CONTEXT_CHANGED: "Request stopped because its session or server authorization changed.";
+    readonly MCP_MRTR_CANCELLED: "Request was canceled before completion.";
+    readonly MCP_MRTR_TIMEOUT: "Request exceeded its operation deadline.";
+    readonly MCP_MRTR_TRANSPORT_FAILED: "Request could not complete; it was not automatically replayed.";
+};
+export declare class McpMrtrError extends Error {
+    readonly source = "local";
+    readonly retriable = false;
+    readonly code: keyof typeof messages;
+    readonly remoteCode?: number;
+    constructor(code: keyof typeof messages, remoteCode?: number);
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,23 @@
+const messages = {
+    MCP_MRTR_ROUND_LIMIT: "Request stopped after 8 input rounds; start a new request to continue.",
+    MCP_MRTR_INPUT_LIMIT: "Server input exceeds the client's supported limits.",
+    MCP_MRTR_INVALID_INPUT: "Server returned an invalid input request or form schema.",
+    MCP_MRTR_UNSUPPORTED_INPUT: "Server requested an undeclared client feature.",
+    MCP_MRTR_PROCESSING_UNAVAILABLE: "Elicitation processing unavailable.",
+    MCP_MRTR_INVALID_RESULT: "Server returned an unsupported or invalid result type/shape.",
+    MCP_MRTR_CONTEXT_CHANGED: "Request stopped because its session or server authorization changed.",
+    MCP_MRTR_CANCELLED: "Request was canceled before completion.",
+    MCP_MRTR_TIMEOUT: "Request exceeded its operation deadline.",
+    MCP_MRTR_TRANSPORT_FAILED: "Request could not complete; it was not automatically replayed.",
+};
+export class McpMrtrError extends Error {
+    constructor(code, remoteCode) {
+        super(remoteCode === undefined ? messages[code] : `${messages[code]} (remote code ${remoteCode})`);
+        this.source = "local";
+        this.retriable = false;
+        this.code = code;
+        this.remoteCode = remoteCode;
+        this.name = "McpMrtrError";
+    }
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,20 @@
+export type Value = string | number | boolean | string[];
+export type Property = Record<string, unknown>;
+export type ValidatedMcpFormSchema = Form;
+type Form = {
+    type: "object";
+    properties: Record<string, Property>;
+    required?: string[];
+};
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare function enums(property: Property): Array<{
+    value: string;
+    label: string;
+}> | undefined;
+export declare function validValue(property: Property, value: unknown): value is Value;
+/** Validate a complete submitted form, including unknown keys and omitted required fields. */
+export declare function validMcpFormContent(schema: Form, content: unknown): content is Record<string, Value>;
+/** Reject unsupported constraints rather than presenting a weaker schema. */
+export declare function validateMrtrForm(schema: unknown): schema is Form;
+export {};
+//# sourceMappingURL=form-schema.d.ts.map

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