@code-yeongyu/senpi 2026.10.25-3 → 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/elicitation.js

@@ -45,10 +45,8 @@ async function rejectPrivateElicitation() {
 }
 async function privateElicitation(client, params, signal, requestId, timeoutMs) {
     const operation = legacyMcpOperation(client);
-    if (operation === "ambiguous") {
-        const { ErrorCode, McpError } = await loadMcpSdkTypes();
-        throw new McpError(ErrorCode.InternalError, "Elicitation cannot be processed: ambiguous origin from concurrent legacy tools/call requests. Run these calls sequentially or use an MRTR server.", { reason: "ambiguous_legacy_origin" });
-    }
+    if (operation === "ambiguous")
+        return rejectPrivateElicitation();
     const presenter = operation?.origin.privateForm;
     if (!isRecord(params) ||
         typeof params.message !== "string" ||

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