@code-yeongyu/senpi 2026.10.25-4 → 2026.10.26-2

package/dist/core/extensions/builtin/mcp/expose/schema-compat.d.ts

@@ -1,4 +1,4 @@
-import type { ImageContent, TextContent } from "@earendil-works/pi-ai";
+import { type ImageContent, type TextContent } from "@earendil-works/pi-ai";
 import { type TSchema } from "typebox";
 import { buildMcpToolNames, type McpToolNameEntry } from "./naming.ts";
 import { collectAllPages, type McpListPage, type McpPaginationResult } from "./pagination.ts";
@@ -62,7 +62,7 @@ export type McpMappedToolResult = {
         content: McpMappedContentBlock[];
     };
 };
-export declare function convertJsonSchemaToTypeBox(schema: unknown): SchemaConversionResult;
+export declare function convertJsonSchemaToTypeBox(schema: unknown, modern?: boolean): SchemaConversionResult;
 export declare function prepareOutputSchemaRetry(schema: unknown): OutputSchemaRetryResult;
 export declare function mapMcpToolResult(result: McpToolResultLike): McpMappedToolResult;
 //# sourceMappingURL=schema-compat.d.ts.map

package/dist/core/extensions/builtin/mcp/expose/schema-compat.js

@@ -1,9 +1,19 @@
+import { registerToolArgumentValidator } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
+import { compileModernSchema } from "../modern/tool-schema.js";
 import { buildMcpToolNames } from "./naming.js";
 import { collectAllPages } from "./pagination.js";
 export { buildMcpToolNames, collectAllPages };
 const PERMISSIVE_OBJECT_SCHEMA = { type: "object", properties: {} };
-export function convertJsonSchemaToTypeBox(schema) {
+export function convertJsonSchemaToTypeBox(schema, modern = false) {
+    if (modern && (typeof schema === "boolean" || isRecord(schema))) {
+        const validate = compileModernSchema(schema);
+        // TypeBox/tool APIs require an object container. allOf preserves the exact
+        // boolean constraint; provider-specific object adaptation happens in pi-ai.
+        const parameters = Type.Unsafe(typeof schema === "boolean" ? { allOf: [schema] } : structuredClone(schema));
+        registerToolArgumentValidator(parameters, validate);
+        return { schema: parameters, warnings: [] };
+    }
     const warnings = [];
     const resolved = resolveRefs(stripTopLevelSchemaKeys(schema), schema, new Set(), warnings);
     if (warnings.length > 0) {

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

@@ -3,6 +3,7 @@ import { Check } from "typebox/value";
 import { authorizeToolDispatch, hasDispatchAuthorizer } from "../permission-system/dispatch.js";
 import { getDispatchIdentity } from "../permission-system/dispatch-metadata.js";
 import { TimeoutError } from "./errors.js";
+import { compileModernSchema, McpToolSchemaError } from "./modern/tool-schema.js";
 import { safeTimer } from "./wrap.js";
 export function createMcpInvocationResolver(scope) {
     const identity = (entry) => ({
@@ -13,6 +14,8 @@ export function createMcpInvocationResolver(scope) {
             entry.server,
             entry.tool,
             entry.schema,
+            entry.outputSchema,
+            entry.modern,
             entry.description,
             entry.annotations,
         ]),
@@ -66,7 +69,18 @@ export function createMcpInvocationResolver(scope) {
             if (current === undefined)
                 return refuse("unavailable", "MCP tool is no longer available.");
             // Validate the current raw schema, never the coercing preflight schema.
-            if (!Check(Type.Unsafe(current.schema), args)) {
+            let validate;
+            try {
+                validate = current.modern
+                    ? compileModernSchema(current.schema)
+                    : (value) => Check(Type.Unsafe(current.schema), value);
+            }
+            catch (error) {
+                if (!(error instanceof McpToolSchemaError))
+                    throw error;
+                return refuse("schema_changed", `${error.code}: ${error.message}`, current);
+            }
+            if (!validate(args)) {
                 return refuse("schema_changed", "Arguments do not match the current MCP tool schema.", current);
             }
             const preparedIdentity = identity(current);
@@ -107,7 +121,7 @@ export function createMcpInvocationResolver(scope) {
                     const latest = scope.current(offered.tool);
                     return (latest !== undefined &&
                         identity(latest).metadata === preparedIdentity.metadata &&
-                        Check(Type.Unsafe(latest.schema), args) &&
+                        validate(args) &&
                         (operationFence === undefined || operationFence()) &&
                         (permissionFence === undefined || permissionFence()));
                 },

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

@@ -39,6 +39,7 @@ export async function materializeNegotiatedTransport(options, serverName, timeou
                 clientInfo,
                 clientCapabilities: {},
                 protocolVersion: outcome.version,
+                logger,
             }), outcome.discovery, outcome.version);
             const version = outcome.version;
             logVersion(transport, () => version);

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

@@ -2,10 +2,13 @@
 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;
+/** A local argument error, not a failed transport or an untrusted server diagnostic. */
+export declare class ParameterHeaderValidationError extends Error {
+}
 /** Connection-local catalog: never shared with another server or transport generation. */
 export declare class ModernParameterHeaders {
     #private;
-    filterTools(tools: readonly unknown[], firstPage: boolean): unknown[];
+    filterTools(tools: readonly unknown[], firstPage: boolean, warn: (message: string) => void): 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

@@ -18,22 +18,31 @@ export function clearMcpParameterHeaders(headers) {
 function parseParameterHeaders(schema) {
     const headers = [];
     const names = new Set();
+    let reason = "";
     const visit = (node, path) => {
+        if (Array.isArray(node))
+            return node.every((child) => visit(child, undefined));
         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"))
+            if (!path?.length)
+                reason = "x-mcp-header must be on a properties-only path";
+            else if (typeof name !== "string" || !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name))
+                reason = "x-mcp-header must be a nonempty HTTP field-name token";
+            else if (names.has(name.toLowerCase()))
+                reason = "x-mcp-header names must be case-insensitively unique";
+            else if (type !== "string" && type !== "integer" && type !== "boolean")
+                reason = "x-mcp-header type must be string, integer, or boolean";
+            else {
+                names.add(name.toLowerCase());
+                headers.push({ name, path, type });
+            }
+            if (reason)
                 return false;
-            names.add(name.toLowerCase());
-            headers.push({ name, path, type });
         }
-        // Only schema-valued keywords are traversed: examples/default/const are instance data.
+        // "Anywhere else" includes unknown keywords; instance-data keywords are not schemas.
         for (const [keyword, value] of Object.entries(node)) {
             if (["properties", "patternProperties", "$defs", "definitions", "dependentSchemas", "dependencies"].includes(keyword)) {
                 if (!isRecord(value))
@@ -44,46 +53,31 @@ function parseParameterHeaders(schema) {
                         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;
-                }
+            else if (!["examples", "default", "const", "enum"].includes(keyword)) {
+                if (!visit(value, undefined))
+                    return false;
             }
         }
         return true;
     };
-    return visit(schema, []) ? headers : undefined;
+    return visit(schema, []) ? headers : reason;
+}
+/** A local argument error, not a failed transport or an untrusted server diagnostic. */
+export class ParameterHeaderValidationError extends Error {
 }
 /** Connection-local catalog: never shared with another server or transport generation. */
 export class ModernParameterHeaders {
     #tools = new Map();
-    filterTools(tools, firstPage) {
+    filterTools(tools, firstPage, warn) {
         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) {
+            if (typeof headers === "string") {
                 this.#tools.delete(tool.name);
+                warn(`Rejected MCP tool ${JSON.stringify(tool.name)}: ${headers}`);
                 return false;
             }
             this.#tools.set(tool.name, headers);
@@ -98,11 +92,15 @@ export class ModernParameterHeaders {
             for (const key of parameter.path) {
                 value = isRecord(value) && Object.hasOwn(value, key) ? value[key] : undefined;
             }
+            if (value === undefined)
+                continue;
             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)));
+            if (!valid) {
+                throw new ParameterHeaderValidationError(`MCP tool ${JSON.stringify(name)} argument ${JSON.stringify(parameter.path)} must be ${parameter.type === "integer" ? "a safe integer" : `a ${parameter.type}`}`);
+            }
+            headers.set(`Mcp-Param-${parameter.name}`, encodeMcpHeaderValue(String(value)));
         }
     }
 }

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

@@ -15,6 +15,6 @@ 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. */
+/** One instance-local adapter. Captured SDK requests retain ID allocation; the caller supplies its era's result contract. */
 export declare function installModernRequestAdapter(client: Client, protocol: ModernProtocolState, clock?: MrtrClock, readCredential?: () => string | undefined): void;
 //# sourceMappingURL=request.d.ts.map

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

@@ -7,6 +7,7 @@ import { isRecord, validateMrtrForm } from "./form-schema.js";
 import { McpMrtrError } from "./errors.js";
 import { queuedForm } from "./consent-queue.js";
 import { parseInputs } from "./inputs.js";
+import { ParameterHeaderValidationError } from "./parameter-headers.js";
 export const MAX_MCP_MRTR_ROUNDS = 8;
 const capableMethods = new Set(["tools/call", "resources/read", "prompts/get"]);
 const capabilitiesKey = "io.modelcontextprotocol/clientCapabilities";
@@ -22,7 +23,7 @@ export function getModernDispatchGuard(params) {
         ? params[modernDispatchGuard]
         : undefined;
 }
-/** One instance-local adapter. Captured SDK requests retain ID allocation and final output-schema validation. */
+/** One instance-local adapter. Captured SDK requests retain ID allocation; the caller supplies its era's result contract. */
 export function installModernRequestAdapter(client, protocol, clock = mcpElapsedClock, readCredential = () => undefined) {
     const sdkRequest = client.request.bind(client);
     states.set(client, protocol);
@@ -259,6 +260,8 @@ export function installModernRequestAdapter(client, protocol, clock = mcpElapsed
                 throw error;
             if (error instanceof AuthError)
                 throw error;
+            if (error instanceof ParameterHeaderValidationError)
+                throw error;
             const remoteCode = isRecord(error) && typeof error.code === "number" ? error.code : undefined;
             throw new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED", remoteCode);
         }

package/dist/core/extensions/builtin/mcp/modern/sdk-bridge.js

@@ -1,5 +1,6 @@
 import { InitializeResultSchema, LATEST_PROTOCOL_VERSION, } from "@modelcontextprotocol/sdk/types.js";
 import { ModernTransportError } from "./transport.js";
+import { ModernSubscriptions } from "./subscriptions.js";
 /** The SDK's local `initialize` answer, built from validated discovery; discovery must support the real wire version. */
 export function modernInitializeResult(discovery, wireVersion) {
     if (!discovery.supportedVersions.includes(wireVersion)) {
@@ -22,16 +23,22 @@ export function normalizeModernResult(message) {
 export class ModernSdkBridge {
     #transport;
     #initializeResult;
+    #subscriptions;
     #initialized = false;
     constructor(transport, discovery, wireVersion) {
         this.#initializeResult = modernInitializeResult(discovery, wireVersion);
         this.#transport = transport;
+        this.#subscriptions = new ModernSubscriptions(transport.send.bind(transport), discovery.capabilities, true);
     }
     async start() {
         this.#transport.onmessage = (message, extra) => {
-            this.onmessage?.(normalizeModernResult(message), extra);
+            if (this.#subscriptions.incoming(message))
+                this.onmessage?.(normalizeModernResult(message), extra);
+        };
+        this.#transport.onclose = () => {
+            this.#subscriptions.dispose();
+            this.onclose?.();
         };
-        this.#transport.onclose = () => this.onclose?.();
         this.#transport.onerror = (error) => this.onerror?.(error);
         await this.#transport.start();
     }
@@ -46,9 +53,17 @@ export class ModernSdkBridge {
         }
         if ("method" in message && message.method === "notifications/initialized" && !("id" in message))
             return;
-        await this.#transport.send(message, options);
+        this.#subscriptions.outgoing(message);
+        try {
+            await this.#transport.send(message, options);
+        }
+        catch (error) {
+            this.#subscriptions.failedSend(message);
+            throw error;
+        }
     }
     close() {
+        this.#subscriptions.dispose();
         return this.#transport.close();
     }
 }

package/dist/core/extensions/builtin/mcp/modern/stdio-probe.js

@@ -3,6 +3,7 @@ import { reapProcessTree } from "../process-tree.js";
 import { discoveryReply, probeStdioEra, STDIO_PROBE_ID, StdioProbeSilence, } from "./era.js";
 import { modernInitializeResult, normalizeModernResult } from "./sdk-bridge.js";
 import { ModernTransportError } from "./transport.js";
+import { ModernSubscriptions } from "./subscriptions.js";
 import { sanitizeModernMessage } from "./diagnostics.js";
 import { McpMrtrError } from "./errors.js";
 import { getModernDispatchGuard } from "./request.js";
@@ -186,6 +187,17 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
         const initializeResult = modernInitializeResult(discovery, version);
         const deliver = transport.onmessage;
         const live = new Set();
+        const subscriptions = new ModernSubscriptions((message, options) => transport.send(message, options), discovery.capabilities);
+        const end = transport.close.bind(transport);
+        transport.close = async () => {
+            subscriptions.dispose();
+            await end();
+        };
+        const onclose = transport.onclose;
+        transport.onclose = () => {
+            subscriptions.dispose();
+            onclose?.();
+        };
         let initialized = false;
         transport.onerror = () => {
             // A parser error may quote a wire body; never forward it.
@@ -204,6 +216,14 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
             }
             if ("id" in message && message.id !== undefined && !live.delete(message.id))
                 return;
+            if (!subscriptions.incoming(message)) {
+                const id = "method" in message && message.method === "notifications/cancelled"
+                    ? message.params?.requestId
+                    : undefined;
+                if (typeof id === "string" || typeof id === "number")
+                    live.delete(id);
+                return;
+            }
             if ("method" in message && message.method === "notifications/progress") {
                 const token = message.params?.progressToken;
                 if ((typeof token !== "string" && typeof token !== "number") || !live.has(token))
@@ -227,12 +247,14 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
             if (message.method === "notifications/initialized" && !("id" in message))
                 return;
             if (message.method === "notifications/cancelled" && !("id" in message)) {
+                subscriptions.outgoing(message);
                 const id = message.params?.requestId;
                 if ((typeof id !== "string" && typeof id !== "number") || !live.delete(id))
                     return;
                 return send({ jsonrpc: "2.0", method: message.method, params: { requestId: id, reason: "MCP request canceled" } }, sendOptions);
             }
             getModernDispatchGuard(message.params)?.();
+            subscriptions.outgoing(message);
             const request = modernizeRequest("id" in message ? message.id : 0, message.method, options.clientInfo, options.clientCapabilities, version, message.params);
             if ("id" in message) {
                 live.add(message.id);
@@ -241,6 +263,7 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
                 }
                 catch {
                     live.delete(message.id);
+                    subscriptions.failedSend(message);
                     throw new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED");
                 }
             }

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

@@ -0,0 +1,14 @@
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import type { DiscoveryResult } from "./era.ts";
+/** Connection-owned streams bypass the SDK's finite request timeout and MRTR consent lifecycle. */
+export declare class ModernSubscriptions {
+    #private;
+    constructor(send: Transport["send"], capabilities: DiscoveryResult["capabilities"], sendCompletesStream?: boolean);
+    outgoing(message: JSONRPCMessage): void;
+    /** Returns true only for application messages that may reach the existing SDK notification handlers. */
+    incoming(message: JSONRPCMessage): boolean;
+    failedSend(message: JSONRPCMessage): void;
+    dispose(): void;
+}
+//# sourceMappingURL=subscriptions.d.ts.map

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

@@ -0,0 +1,226 @@
+import { randomUUID } from "node:crypto";
+import { mcpElapsedClock } from "../wrap.js";
+import { isRecord } from "./form-schema.js";
+const subscriptionKey = "io.modelcontextprotocol/subscriptionId";
+const listFilters = {
+    "notifications/tools/list_changed": "toolsListChanged",
+    "notifications/prompts/list_changed": "promptsListChanged",
+    "notifications/resources/list_changed": "resourcesListChanged",
+};
+/** Connection-owned streams bypass the SDK's finite request timeout and MRTR consent lifecycle. */
+export class ModernSubscriptions {
+    #send;
+    #capabilities;
+    #sendCompletesStream;
+    #filter = {};
+    #resourceLists = new Map();
+    #resourceCursors = new Map();
+    #latestSweep;
+    #active;
+    #pending;
+    #timer;
+    #retry = 0;
+    #closed = false;
+    #started = false;
+    constructor(send, capabilities, sendCompletesStream = false) {
+        this.#send = send;
+        this.#capabilities = capabilities;
+        this.#sendCompletesStream = sendCompletesStream;
+    }
+    outgoing(message) {
+        if (!("method" in message))
+            return;
+        if (message.method === "notifications/cancelled") {
+            const id = message.params?.requestId;
+            if (typeof id === "string" || typeof id === "number")
+                this.#resourceLists.delete(id);
+        }
+        if (!("id" in message))
+            return;
+        if (message.method === "resources/list" && this.#supports("resources", "subscribe")) {
+            const cursor = message.params?.cursor;
+            if (cursor === undefined) {
+                const sweep = { uris: [] };
+                this.#latestSweep = sweep;
+                this.#resourceLists.set(message.id, sweep);
+            }
+            else if (typeof cursor === "string") {
+                const sweep = this.#resourceCursors.get(cursor);
+                this.#resourceCursors.delete(cursor);
+                if (sweep)
+                    this.#resourceLists.set(message.id, sweep);
+            }
+        }
+        if (this.#started || !["tools/list", "prompts/list", "resources/list"].includes(message.method))
+            return;
+        this.#started = true;
+        // The builtin catalog uses all three lists. Never opt in to an undeclared feature.
+        if (this.#supports("tools", "listChanged"))
+            this.#filter.toolsListChanged = true;
+        if (this.#supports("prompts", "listChanged"))
+            this.#filter.promptsListChanged = true;
+        if (this.#supports("resources", "listChanged"))
+            this.#filter.resourcesListChanged = true;
+        this.#open();
+    }
+    /** Returns true only for application messages that may reach the existing SDK notification handlers. */
+    incoming(message) {
+        const sweep = "id" in message && message.id !== undefined ? this.#resourceLists.get(message.id) : undefined;
+        if ("id" in message && message.id !== undefined)
+            this.#resourceLists.delete(message.id);
+        if (sweep && "result" in message) {
+            const resources = message.result.resources;
+            if (Array.isArray(resources)) {
+                for (const resource of resources)
+                    if (isRecord(resource) && typeof resource.uri === "string")
+                        sweep.uris.push(resource.uri);
+                if (typeof message.result.nextCursor === "string" && message.result.nextCursor) {
+                    this.#resourceCursors.set(message.result.nextCursor, sweep);
+                }
+                else if (sweep === this.#latestSweep) {
+                    const uris = [...new Set(sweep.uris)].sort();
+                    if (JSON.stringify(uris) !== JSON.stringify(this.#filter.resourceSubscriptions ?? [])) {
+                        this.#filter.resourceSubscriptions = uris;
+                        this.#open();
+                    }
+                }
+            }
+        }
+        if ("id" in message) {
+            const stream = [this.#active, this.#pending].find((entry) => entry?.id === message.id);
+            if (!stream)
+                return true;
+            // A response ends the long-lived request; graceful server shutdown is not a retry trigger.
+            this.#retire(stream);
+            return false;
+        }
+        if (!("method" in message))
+            return true;
+        if (message.method === "notifications/cancelled") {
+            const stream = [this.#active, this.#pending].find((entry) => entry?.id === message.params?.requestId);
+            if (stream) {
+                this.#retire(stream);
+                return false;
+            }
+        }
+        const meta = message.params?._meta;
+        const id = isRecord(meta) ? meta[subscriptionKey] : undefined;
+        const acknowledged = message.method === "notifications/subscriptions/acknowledged";
+        const list = Object.hasOwn(listFilters, message.method);
+        const resource = message.method === "notifications/resources/updated";
+        if (!acknowledged && !list && !resource)
+            return true;
+        const active = [this.#active, this.#pending].find((entry) => entry?.id === id);
+        if (!active)
+            return false;
+        if (acknowledged) {
+            if (active.accepted)
+                return false;
+            if (!isRecord(message.params?.notifications)) {
+                this.#failed(active);
+                this.#cancel(active);
+                return false;
+            }
+            const offered = message.params.notifications;
+            const accepted = {};
+            for (const key of Object.values(listFilters))
+                if (active.requested[key] && offered[key] === true)
+                    accepted[key] = true;
+            const uris = offered.resourceSubscriptions;
+            if (Array.isArray(uris))
+                accepted.resourceSubscriptions = active.requested.resourceSubscriptions?.filter((uri) => uris.includes(uri));
+            active.accepted = accepted;
+            const previous = this.#active;
+            this.#pending = undefined;
+            this.#active = active;
+            if (previous && previous !== active)
+                this.#cancel(previous);
+            if (!Object.values(accepted).some((value) => value === true) && !accepted.resourceSubscriptions?.length)
+                this.#cancel(active);
+            return false;
+        }
+        if (active !== this.#active || !active.accepted)
+            return false;
+        const deliver = resource
+            ? typeof message.params?.uri === "string" &&
+                active.accepted.resourceSubscriptions?.includes(message.params.uri) === true
+            : active.accepted[listFilters[message.method]] === true;
+        if (deliver)
+            this.#retry = 0;
+        return deliver;
+    }
+    failedSend(message) {
+        if ("id" in message && message.id !== undefined)
+            this.#resourceLists.delete(message.id);
+    }
+    dispose() {
+        this.#closed = true;
+        if (this.#timer)
+            mcpElapsedClock.cancel(this.#timer);
+        this.#timer = undefined;
+        if (this.#pending)
+            this.#cancel(this.#pending);
+        if (this.#active)
+            this.#cancel(this.#active);
+        this.#resourceLists.clear();
+        this.#resourceCursors.clear();
+        this.#latestSweep = undefined;
+    }
+    #supports(feature, flag) {
+        const capability = this.#capabilities[feature];
+        return isRecord(capability) && capability[flag] === true;
+    }
+    #retire(active) {
+        if (this.#active === active)
+            this.#active = undefined;
+        if (this.#pending === active)
+            this.#pending = undefined;
+    }
+    #cancel(active) {
+        this.#retire(active);
+        void this.#send({
+            jsonrpc: "2.0",
+            method: "notifications/cancelled",
+            params: { requestId: active.id },
+        }).catch(() => { });
+    }
+    #open() {
+        if (this.#closed || JSON.stringify((this.#pending ?? this.#active)?.requested) === JSON.stringify(this.#filter))
+            return;
+        if (this.#timer)
+            mcpElapsedClock.cancel(this.#timer);
+        this.#timer = undefined;
+        if (this.#pending)
+            this.#cancel(this.#pending);
+        if (!Object.values(this.#filter).some((value) => value === true) && !this.#filter.resourceSubscriptions?.length) {
+            if (this.#active)
+                this.#cancel(this.#active);
+            return;
+        }
+        const active = { id: `senpi-subscription-${randomUUID()}`, requested: structuredClone(this.#filter) };
+        this.#pending = active;
+        // HTTP send remains pending for the entire SSE lifetime. No caller awaits it.
+        void this.#send({
+            jsonrpc: "2.0",
+            id: active.id,
+            method: "subscriptions/listen",
+            params: { notifications: active.requested },
+        }).then(() => {
+            if (this.#sendCompletesStream)
+                this.#failed(active);
+        }, () => this.#failed(active));
+    }
+    #failed(active) {
+        if (this.#closed || (this.#active !== active && this.#pending !== active))
+            return;
+        this.#retire(active);
+        if (this.#pending || this.#timer)
+            return;
+        this.#timer = mcpElapsedClock.schedule(() => {
+            this.#timer = undefined;
+            this.#open();
+        }, Math.min(30_000, 1000 * 2 ** Math.min(this.#retry++, 5)));
+        this.#timer.unref?.();
+    }
+}
+//# sourceMappingURL=subscriptions.js.map

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

@@ -0,0 +1,13 @@
+import type { ValidateFunction } from "ajv";
+import type { McpJsonSchema, McpListedTool } from "../tool-contracts.ts";
+type SchemaErrorCode = "MCP_SCHEMA_UNSUPPORTED_DIALECT" | "MCP_SCHEMA_INVALID" | "MCP_SCHEMA_LIMIT" | "MCP_OUTPUT_SCHEMA_MISMATCH";
+export declare class McpToolSchemaError extends Error {
+    readonly code: SchemaErrorCode;
+    constructor(code: SchemaErrorCode, message: string);
+}
+/** No coercion/default insertion/removal, no network resolver, no shared $id namespace. */
+export declare function compileModernSchema(schema: McpJsonSchema): ValidateFunction;
+/** Reject one unusable definition, never its valid siblings; diagnostics contain no schema or arguments. */
+export declare function hasSupportedModernToolSchemas(tool: Pick<McpListedTool, "name" | "inputSchema" | "outputSchema">): boolean;
+export {};
+//# sourceMappingURL=tool-schema.d.ts.map