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

package/dist/core/extensions/builtin/mcp/catalog-cache.js

@@ -6,6 +6,9 @@ import { redactResolvedReferenceData } from "../../../config-reference-redaction
 import { lockWithLossHandling } from "../../../file-lock.js";
 import { isEphemeralIdentity } from "./config-identity-key.js";
 import { collectAllPages } from "./expose/pagination.js";
+import { listMcpTools } from "./tool-client.js";
+import { isModernMcpClient } from "./modern/request.js";
+import { hasSupportedModernToolSchemas } from "./modern/tool-schema.js";
 const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const EMPTY_CACHE = { version: 1, servers: {} };
 export function getMcpCatalogCachePath(agentDir = getAgentDir()) {
@@ -36,7 +39,7 @@ export function cachedCatalogNeedsRefresh(cached, now = Date.now()) {
     return now - cached.fetchedAt > CACHE_TTL_MS;
 }
 export async function collectServerCatalogForCache(connection, config, configHash, credentialIdentity) {
-    const tools = await collectAllPages((cursor) => connection.client.listTools(cursor === undefined ? {} : { cursor }, {
+    const tools = await collectAllPages((cursor) => listMcpTools(connection.client, cursor === undefined ? {} : { cursor }, {
         timeout: config.requestTimeoutMs,
     }));
     const resources = await collectOptionalPages((cursor) => connection.client.listResources(cursor === undefined ? {} : { cursor }, {
@@ -50,6 +53,7 @@ export async function collectServerCatalogForCache(connection, config, configHas
     }));
     return {
         configHash,
+        ...(isModernMcpClient(connection.client) ? { modern: true } : {}),
         credentialIdentity,
         fetchedAt: Date.now(),
         instructions: connection.client.getInstructions(),
@@ -128,7 +132,7 @@ function normalizeCachedServer(value) {
     if (!isRecord(value) || typeof value.configHash !== "string" || typeof value.fetchedAt !== "number") {
         return undefined;
     }
-    const tools = normalizeTools(value.tools);
+    const tools = normalizeTools(value.tools, value.modern === true);
     if (tools === undefined)
         return undefined;
     const resources = Array.isArray(value.resources) ? value.resources : [];
@@ -139,6 +143,7 @@ function normalizeCachedServer(value) {
     const instructions = typeof value.instructions === "string" ? value.instructions : undefined;
     return {
         configHash: value.configHash,
+        ...(value.modern === true ? { modern: true } : {}),
         credentialIdentity: typeof value.credentialIdentity === "string" ? value.credentialIdentity : undefined,
         fetchedAt: value.fetchedAt,
         instructions,
@@ -148,19 +153,27 @@ function normalizeCachedServer(value) {
         tools,
     };
 }
-function normalizeTools(value) {
+function normalizeTools(value, modern) {
     if (!Array.isArray(value))
         return undefined;
     const tools = [];
     for (const item of value) {
-        if (!isRecord(item) || typeof item.name !== "string" || !isRecord(item.inputSchema))
+        if (!isRecord(item) || typeof item.name !== "string")
             return undefined;
-        tools.push({
+        if (!isRecord(item.inputSchema) && !(modern && typeof item.inputSchema === "boolean"))
+            return undefined;
+        const tool = {
+            ...(modern ? item : {}),
             annotations: isRecord(item.annotations) ? item.annotations : undefined,
             description: typeof item.description === "string" ? item.description : undefined,
             inputSchema: item.inputSchema,
+            ...(modern && (isRecord(item.outputSchema) || typeof item.outputSchema === "boolean")
+                ? { outputSchema: item.outputSchema }
+                : {}),
             name: item.name,
-        });
+        };
+        if (!modern || hasSupportedModernToolSchemas(tool))
+            tools.push(tool);
     }
     return tools;
 }

package/dist/core/extensions/builtin/mcp/catalog.d.ts

@@ -1,4 +1,4 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { McpListedTool as ListedTool } from "./tool-contracts.ts";
 import type { McpCachedServerCatalog } from "./catalog-cache.ts";
 import type { McpServerDeclaredConfig, McpSettings } from "./config-schema.ts";
 import type { ServerConnection } from "./connection.ts";
@@ -6,12 +6,13 @@ import type { McpOutputArtifacts } from "./guard/output-guard.ts";
 import type { McpEnsureFreshAuth } from "./health.ts";
 import type { McpInvocationResolver } from "./invocation.ts";
 import type { McpRequestOrigin } from "./request-origin.ts";
-type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 export interface McpToolCatalogEntry {
     requestOrigin?: () => McpRequestOrigin | undefined;
     server: string;
     tool: string;
     schema: ListedTool["inputSchema"];
+    outputSchema?: ListedTool["outputSchema"];
+    modern?: boolean;
     description?: string;
     annotations?: ListedTool["annotations"];
     requestTimeoutMs: number;

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

@@ -1,6 +1,9 @@
+import { listMcpTools } from "./tool-client.js";
+import { isModernMcpClient } from "./modern/request.js";
+import { hasSupportedModernToolSchemas } from "./modern/tool-schema.js";
 import { collectAllPages } from "./expose/pagination.js";
 export async function collectToolCatalog(server, connection, config, options = {}) {
-    const result = await collectAllPages((cursor) => connection.client.listTools(cursor === undefined ? {} : { cursor }, { timeout: config.requestTimeoutMs }));
+    const result = await collectAllPages((cursor) => listMcpTools(connection.client, cursor === undefined ? {} : { cursor }, { timeout: config.requestTimeoutMs }));
     return result.items.map((tool) => ({
         requestOrigin: options.requestOrigin,
         annotations: tool.annotations,
@@ -13,6 +16,8 @@ export async function collectToolCatalog(server, connection, config, options = {
         outputGuard: options.outputGuard,
         requestTimeoutMs: config.requestTimeoutMs,
         schema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        modern: isModernMcpClient(connection.client),
         server,
         tool: tool.name,
     }));
@@ -21,13 +26,23 @@ export async function collectToolCatalog(server, connection, config, options = {
  * equal identities register identical definitions. */
 export function mcpRegistrationIdentity(tools, catalog) {
     return JSON.stringify([
-        tools.map((entry) => [entry.tool, entry.description, entry.schema, entry.annotations]),
+        tools.map((entry) => [
+            entry.tool,
+            entry.description,
+            entry.schema,
+            entry.outputSchema,
+            entry.modern,
+            entry.annotations,
+        ]),
         catalog?.resources ?? [],
         catalog?.prompts ?? [],
     ]);
 }
 export function cachedToolsToCatalogEntries(server, catalog, connection, requestTimeoutMs, ensureConnected, options = {}) {
-    return catalog.tools.map((tool) => ({
+    const modern = connection.state === "connected" ? isModernMcpClient(connection.client) || undefined : catalog.modern;
+    return catalog.tools
+        .filter((tool) => !modern || hasSupportedModernToolSchemas(tool))
+        .map((tool) => ({
         requestOrigin: options.requestOrigin,
         annotations: tool.annotations,
         agentDir: options.agentDir,
@@ -40,6 +55,8 @@ export function cachedToolsToCatalogEntries(server, catalog, connection, request
         outputGuard: options.outputGuard,
         requestTimeoutMs,
         schema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        modern,
         server,
         tool: tool.name,
     }));

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

@@ -1,10 +1,11 @@
 import type { McpToolCatalogEntry } from "../catalog.ts";
 import type { McpInvocation, McpInvocationError } from "../invocation.ts";
 import type { McpToolDefinition } from "./register.ts";
+import type { McpToolResult } from "../tool-contracts.ts";
 export declare function callMcpTool(entry: McpToolCatalogEntry, args: Record<string, unknown>, signal: AbortSignal | undefined, onUpdate: Parameters<McpToolDefinition["execute"]>[3], label: string, invocation: McpInvocation | undefined): Promise<{
     kind: "called";
     entry: McpToolCatalogEntry;
-    result: Awaited<ReturnType<McpToolCatalogEntry["connection"]["client"]["callTool"]>>;
+    result: McpToolResult;
 } | {
     kind: "refused";
     error: McpInvocationError;

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

@@ -4,6 +4,7 @@ import { ensureMcpToolCallConnection, withMcpRetriableFailedSendRetry, withMcpSe
 import { runMcpConnectionLifecycleCall } from "../idle.js";
 import { mcpRequestOptions } from "../request-origin.js";
 import { McpMrtrError } from "../modern/errors.js";
+import { callMcpToolRequest } from "../tool-client.js";
 export async function callMcpTool(entry, args, signal, onUpdate, label, invocation) {
     try {
         return await runMcpConnectionLifecycleCall(entry.connection, () => withMcpSessionExpiryRetry(entry.connection, async () => {
@@ -31,7 +32,7 @@ export async function callMcpTool(entry, args, signal, onUpdate, label, invocati
                     if (prepared !== undefined && !prepared.isCurrent())
                         continue;
                     const current = prepared?.entry ?? entry;
-                    const result = await current.connection.client.callTool({ name: current.tool, arguments: args }, undefined, mcpRequestOptions(current.requestOrigin?.(), {
+                    const result = await callMcpToolRequest(current.connection.client, { name: current.tool, arguments: args }, current.outputSchema, mcpRequestOptions(current.requestOrigin?.(), {
                         onprogress: (progress) => {
                             onUpdate?.(redactResolvedReferenceData({
                                 content: [{ type: "text", text: formatProgress(label, progress) }],

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

@@ -18,7 +18,7 @@ export function buildMcpToolDefinitions(entries, warn) {
     return mapMcpCatalogNames(entries, warn).map(({ entry, name }) => createMcpToolDefinition(entry, name));
 }
 function createMcpToolDefinition(entry, name) {
-    const converted = convertJsonSchemaToTypeBox(entry.schema);
+    const converted = convertJsonSchemaToTypeBox(entry.schema, entry.modern);
     const label = `${entry.server}/${entry.tool}`;
     registerDispatchIdentity(converted.schema, () => entry.invocation?.identity(entry));
     return {

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/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

@@ -22,7 +22,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);

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