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

package/dist/core/extensions/builtin/mcp/expose/session.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "../../../types.ts";
+import type { ExtensionAPI, ExtensionUIContext } from "../../../types.ts";
 import type { ToolSearchService } from "../../tool-search/service.ts";
 import type { McpCachedServerCatalog } from "../catalog-cache.ts";
 import type { ResolvedMcpConfig } from "../config-schema.ts";
@@ -7,6 +7,7 @@ import type { McpOutputArtifacts } from "../guard/output-guard.ts";
 import type { McpInvocationResolver } from "../invocation.ts";
 import { type McpLogger } from "../log.ts";
 import type { McpPromptServer } from "../prompts.ts";
+import type { McpRequestOrigin } from "../request-origin.ts";
 import { type McpResourceServer } from "../resources.ts";
 import type { McpCatalogRegistrationOptions } from "./register.ts";
 import { type McpTierBRegistration } from "./tier-b.ts";
@@ -15,6 +16,8 @@ export type McpSessionRegistration = McpTierBRegistration & {
     promptServers: McpPromptServer[];
 };
 export interface McpDirectRegistrationEntry {
+    readonly requestOrigin?: () => McpRequestOrigin | undefined;
+    readonly bindPresentation?: (ui: ExtensionUIContext) => void;
     readonly name: string;
     readonly connection: ServerConnection;
     readonly logger: McpLogger;

package/dist/core/extensions/builtin/mcp/expose/session.js

@@ -24,6 +24,7 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
                     artifacts: entry.artifacts,
                     ensureFresh: entry.ensureFresh,
                     invocation: entry.invocation,
+                    requestOrigin: entry.requestOrigin,
                     outputGuard: config.settings.outputGuard,
                 })
                 : []
@@ -32,6 +33,7 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
                 artifacts: entry.artifacts,
                 ensureFresh: entry.ensureFresh,
                 invocation: entry.invocation,
+                requestOrigin: entry.requestOrigin,
                 outputGuard: config.settings.outputGuard,
             });
         const identity = mcpRegistrationIdentity(catalog, entry.cachedCatalog);
@@ -39,6 +41,9 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
         const cachedPrompts = entry.cachedCatalog?.prompts ?? [];
         if (cachedPrompts.length > 0) {
             promptServers.push({
+                ensureFresh: entry.ensureFresh,
+                bindPresentation: entry.bindPresentation,
+                requestOrigin: entry.requestOrigin,
                 connection: entry.connection,
                 prompts: cachedPrompts,
                 requestTimeoutMs: server.config.requestTimeoutMs,
@@ -48,6 +53,8 @@ export async function registerDirectMcpTools(pi, config, entries, toolSearchServ
         const cachedResources = entry.cachedCatalog?.resources ?? [];
         if (cachedResources.length > 0) {
             resourceServers.push({
+                ensureFresh: entry.ensureFresh,
+                requestOrigin: entry.requestOrigin,
                 agentDir: entry.agentDir,
                 artifacts: entry.artifacts,
                 connection: entry.connection,

package/dist/core/extensions/builtin/mcp/health.js

@@ -1,6 +1,7 @@
 import { AuthError, ConnectError, isMcpSessionExpiredError, isRetriableMcpError, SessionExpiredError, } from "./errors.js";
 import { isMcpNeedsAuthError } from "./needs-auth.js";
 import { reconnectMcpNow } from "./reconnect.js";
+import { McpMrtrError } from "./modern/errors.js";
 export const MCP_PING_STALE_MS = 30_000;
 export const MCP_PING_TIMEOUT_MS = 2_000;
 const healthByConnection = new WeakMap();
@@ -46,6 +47,8 @@ export async function withMcpSessionExpiryRetry(connection, operation) {
         return await operation();
     }
     catch (error) {
+        if (error instanceof McpMrtrError)
+            throw error;
         if (!isMcpSessionExpiredError(error))
             throw error;
         connection.markDegraded(sessionExpiredError(connection, error, true));
@@ -67,6 +70,8 @@ export async function withMcpRetriableFailedSendRetry(connection, operation) {
         return await operation();
     }
     catch (error) {
+        if (error instanceof McpMrtrError)
+            throw error;
         if (!isRetriableFailedSendError(error))
             throw error;
         connection.markDegraded(failedSendError(connection, error, true));

package/dist/core/extensions/builtin/mcp/host-registry.js

@@ -1,3 +1,4 @@
+import { legacyMcpFormEligible } from "./elicitation.js";
 import { observe } from "./env-grants-store.js";
 import { effectiveGrantNames } from "./project-skill-policy.js";
 import { SharedMcpConnection } from "./shared-connection.js";
@@ -17,7 +18,12 @@ export class HostMcpRegistry {
     #shared = new Map();
     #grantObservers = new Map();
     attachShared(key, owner, options) {
-        const identity = sharedMcpKey(options, options.agentDir);
+        const eligible = legacyMcpFormEligible(options.elicitationUiProvider, options.elicitationEnabled !== false);
+        // Enforced pools observe live readiness; it must not remain frozen in a creation-time key.
+        const formPolicy = options.elicitationUiProvider?.enforced?.() === true
+            ? `private:${options.elicitationEnabled !== false}`
+            : `${eligible}:false`;
+        const identity = `${sharedMcpKey(options, options.agentDir)}\0legacy-form:${formPolicy}`;
         let shared = this.#shared.get(identity);
         if (shared === undefined) {
             shared = new SharedMcpConnection(options, () => this.#shared.delete(identity));

package/dist/core/extensions/builtin/mcp/index.js

@@ -61,6 +61,7 @@ export function createMcpExtension(service, sessionOwned = true) {
                 service.activateSkillMcpTools(targets, pi);
         };
         pi.on("input", async (event, ctx) => {
+            service.bindMcpMrtrPresentation(pi, ctx.ui);
             const match = /^\s*\/skill:([A-Za-z0-9._-]+)/.exec(event.text);
             if (match)
                 revealSkill(match[1]);
@@ -125,6 +126,7 @@ export function createMcpExtension(service, sessionOwned = true) {
                     // Elicitation (todo 41): point mid-call forms at this session's UI.
                     service.setMcpElicitationUiProvider(() => (ctx.hasUI ? ctx.ui : undefined));
                     await (attachPromise ?? attach({ type: "session_start", reason: "startup" }, ctx));
+                    service.bindMcpMrtrPresentation(pi, ctx.ui);
                 }
                 const skills = preview ? [] : (event.systemPromptOptions.skills ?? []);
                 if (skills.length > 0) {

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

@@ -0,0 +1,5 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type McpElicitationUiProvider } from "../elicitation.ts";
+import { type ModernProtocolState } from "./request.ts";
+export declare function createMcpRequestClient(protocol: ModernProtocolState, uiProvider: McpElicitationUiProvider | undefined, readCredential?: () => string | undefined, elicitationEnabled?: boolean): Promise<Client>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,15 @@
+import { configureMcpElicitation, legacyMcpFormEligible, mcpClientCapabilities, } from "../elicitation.js";
+import { loadMcpSdkClient } from "../sdk.lazy.js";
+import { mcpElapsedClock } from "../wrap.js";
+import { installModernRequestAdapter } from "./request.js";
+export async function createMcpRequestClient(protocol, uiProvider, readCredential = () => undefined, elicitationEnabled = true) {
+    const { Client } = await loadMcpSdkClient();
+    protocol.privateForms = uiProvider?.enforced?.() === true;
+    const legacyEligible = legacyMcpFormEligible(uiProvider, elicitationEnabled);
+    protocol.legacyFormEligible = legacyEligible;
+    const client = new Client({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: mcpClientCapabilities(legacyEligible) });
+    await configureMcpElicitation(client, uiProvider, undefined, legacyEligible);
+    installModernRequestAdapter(client, protocol, mcpElapsedClock, readCredential);
+    return client;
+}
+//# sourceMappingURL=client.js.map

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