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

package/dist/core/agent-session.d.ts

@@ -12,7 +12,7 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, AgentToolCall, AgentToolResult, ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, AgentToolCall, AgentToolResult, InternalAgentChannel, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import { type ThinkingSelection } from "@earendil-works/pi-ai";
 import type { Api, ImageContent, Model, TextContent } from "@earendil-works/pi-ai/compat";
 import { type ToolRuntimeKind } from "../cli/tool-runtime.ts";
@@ -60,6 +60,7 @@ import type { SessionRelocationHost } from "./session-relocation.ts";
 import { type SettingsManager, type SettingsSourceSelection } from "./settings-manager.ts";
 import { type SkillInvocationSyntax } from "./skill-invocation.ts";
 import { type SourceInfo } from "./source-info.ts";
+import { type AgentSessionStructuredRecord } from "./structured-session-lane.ts";
 import { type ThinkingClampNotice } from "./thinking-levels.ts";
 import { type ToolBarrierSpec } from "./tool-barrier.ts";
 import { type SessionMessageUpdateEvent } from "./tool-call-display-name.ts";
@@ -372,6 +373,8 @@ export type AgentSessionEvent = WithParentToolCallId<Exclude<AgentEvent, {
 export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
 export interface AgentSessionConfig {
     agent: Agent;
+    /** @internal Construction channel for senpi's session layer only; absent for externally supplied Agents. */
+    internalChannel?: InternalAgentChannel;
     /** Explicit service tier for the initial model. */
     serviceTier?: ServiceTier;
     sessionManager: SessionManager;
@@ -650,6 +653,7 @@ export declare class AgentSession {
     private _unsubscribeSettingsSource?;
     private _unregisterMemoryReport;
     private _eventListeners;
+    private readonly _structuredLane;
     private _agentEventQueue;
     /**
      * Exact message objects whose message_end persistence is still queued.
@@ -1211,6 +1215,12 @@ export declare class AgentSession {
      * Multiple listeners can be added. Returns unsubscribe function for this listener.
      */
     subscribe(listener: AgentSessionEventListener): () => void;
+    /**
+     * The internal structured lane (senpi#4272): every session event in `_emit` order with its provider capture, plus
+     * block controls at their position. Attach before a turn's first provider push; a stream already pushing keeps
+     * its decision and yields no capture.
+     */
+    subscribeStructured(listener: (record: AgentSessionStructuredRecord) => void): () => void;
     /**
      * Temporarily disconnect from agent events.
      * User listeners are preserved and will receive events again after resubscribe().

package/dist/core/agent-session.js

@@ -139,6 +139,7 @@ import { formatSkillInvocationPrompt, parseSkillInvocationTokens, removeSkillInv
 import { BUILTIN_SLASH_COMMANDS } from "./slash-commands.js";
 import { BUILTIN_PATH_PREFIX, createSyntheticSourceInfo } from "./source-info.js";
 import { stopResumeDirective } from "./stop-resume-directive.js";
+import { StructuredSessionLane } from "./structured-session-lane.js";
 import { clampThinkingSelection, getSupportedThinkingLevels, getThinkingClampNotice, supportsMax, supportsXhigh, } from "./thinking-levels.js";
 import { resetTimings, time } from "./timings.js";
 import { ToolBarrier, toolBarrierSpecError } from "./tool-barrier.js";
@@ -701,6 +702,11 @@ export class AgentSession {
         this._promptSurface = config.promptSurface;
         this._browserEngine = config.browserEngine;
         this.agent = config.agent;
+        this._structuredLane = new StructuredSessionLane(config.internalChannel, (deliver) => {
+            if (!this._unsubscribeAgent)
+                return;
+            this._agentEventQueue = this._agentEventQueue.then(deliver, deliver);
+        });
         this.sessionManager = config.sessionManager;
         this._sessionThinkingMemory = new SessionThinkingMemory(config.sessionManager);
         this._thinkingLevelSource = config.initialThinkingLevelSource ?? "default";
@@ -1701,7 +1707,7 @@ export class AgentSession {
         this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
         this._emitEntryAppended(entry.id);
     }
-    _emit(event) {
+    _emit(event, captureSource = event) {
         if (event.type === "session_paused" ||
             event.type === "session_resumed" ||
             event.type === "compaction_start" ||
@@ -1744,6 +1750,8 @@ export class AgentSession {
         for (const l of [...this._eventListeners]) {
             l(event);
         }
+        if (this._structuredLane.active)
+            this._structuredLane.emitEvent(event, captureSource);
     }
     async _emitSessionCompactFailed(event) {
         if (this._extensionRunner.hasHandlers("session_compact_failed")) {
@@ -2567,7 +2575,7 @@ export class AgentSession {
             : event.type === "message_update"
                 ? withResolvedToolName(event, (name) => this.resolveToolCallName(name))
                 : event;
-        this._emit(sessionEvent);
+        this._emit(sessionEvent, event);
         if (event.type === "agent_end") {
             if (this._abortProvenance.takeLateUserJoin())
                 await this._emitSessionAbort();
@@ -3234,6 +3242,14 @@ export class AgentSession {
             }
         };
     }
+    /**
+     * The internal structured lane (senpi#4272): every session event in `_emit` order with its provider capture, plus
+     * block controls at their position. Attach before a turn's first provider push; a stream already pushing keeps
+     * its decision and yields no capture.
+     */
+    subscribeStructured(listener) {
+        return this._structuredLane.subscribe(listener);
+    }
     /**
      * Temporarily disconnect from agent events.
      * User listeners are preserved and will receive events again after resubscribe().
@@ -3302,6 +3318,7 @@ export class AgentSession {
         this._unsubscribeWakeSources = undefined;
         this._lifecycleBinding.dispose();
         this._eventListeners = [];
+        this._structuredLane.dispose();
         cleanupSessionResources(this.sessionId);
         // Nothing reads or writes this manager once its session is gone: it releases
         // its writer grant and its disposable blob directory here.

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

@@ -648,8 +648,14 @@ export default function compactionExtension(pi, remoteCompactionDependencies = {
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 const failureKind = classifyRequiredCompactionFallbackFailure(error);
+                // A terminal provider failure (dead model, dead credential) has no cheaper
+                // recovery on any compaction kind: without this, a soft-threshold pre_prompt
+                // compaction cancelled instead, the session rejected it, and the pending
+                // prompt failed with RequiredCompactionError while shouldCompact still said
+                // compact (the "Compaction rejected: compaction generator failed" wedge).
                 if ((requiresDeterministicCompactionFallback(event, ctx.getContextUsage()) ||
-                    failureKind === "unsafe-retained-content") &&
+                    failureKind === "unsafe-retained-content" ||
+                    failureKind === "summarization-provider-failure") &&
                     failureKind !== undefined &&
                     !event.signal.aborted) {
                     const recovery = recoverRequiredCompaction(ctx, snapshot, failureKind, error);

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

@@ -2,6 +2,7 @@ import { closeSync, openSync, readdirSync, readFileSync, readSync } from "node:f
 import { createConnection } from "node:net";
 import { join, win32 } from "node:path";
 import { debuglog } from "node:util";
+import { APP_COMMAND } from "../../../../config.js";
 import { isTerminalMonitorStateEvent, isWakeSourceStateEvent, TERMINAL_MONITOR_STATE_EVENT, WAKE_SOURCE_STATE_EVENT, } from "../monitor-state-event.js";
 import { HerdrClient } from "./herdr-client.js";
 import { initialHerdrState, isHerdrBlockedEvent, reduceHerdrState, selectHerdrReport } from "./herdr-state.js";
@@ -115,11 +116,14 @@ export function createHerdrExtension(deps) {
                 void publish();
             }, 4000);
             poll.unref();
-            await Promise.all([
-                reportTitle(ctx),
-                send("pane.report_agent_session", { agent: "pi", ...sessionRef(), session_start_source: _event.reason }),
-                publish(),
-            ]);
+            // Herdr accepts a resume command only after this reporter holds the pane.
+            await Promise.all([reportTitle(ctx), publish()]);
+            await send("pane.report_agent_session", {
+                agent: "pi",
+                ...sessionRef(),
+                resume_argv: [APP_COMMAND, "--session", bound.getSessionFile() ?? bound.getSessionId()],
+                session_start_source: _event.reason,
+            });
         });
         pi.on("session_info_changed", (_event, ctx) => {
             if (owns(ctx))

package/dist/core/extensions/builtin/mcp/auth/oauth-issuer.d.ts

@@ -0,0 +1,6 @@
+import type { OAuthServerInfo } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { McpStoredAuth } from "./token-store.ts";
+export declare function canonicalAuthorizationServerIssuer(issuer: string): string;
+export declare function validatedAuthorizationServerIssuer(info: OAuthServerInfo, serverName: string): string;
+export declare function credentialsMatchIssuer(record: McpStoredAuth | undefined, issuer: string): boolean;
+//# sourceMappingURL=oauth-issuer.d.ts.map

package/dist/core/extensions/builtin/mcp/auth/oauth-issuer.js

@@ -0,0 +1,25 @@
+import { OAuthFlowError } from "./oauth-errors.js";
+// Credential stamps tolerate only the slash spelling of an origin-only URL, not URL normalization.
+export function canonicalAuthorizationServerIssuer(issuer) {
+    return issuer.replace(/^(https?:\/\/[^/?#]+)\/$/, "$1");
+}
+// RFC 8414 section 3.3: identifiers from metadata are compared verbatim, not as normalized URLs.
+export function validatedAuthorizationServerIssuer(info, serverName) {
+    // The SDK's legacy fallback discovers root metadata and spells the origin with a trailing slash.
+    // Only that configured-resource fallback is normalized; PRM-provided identifiers remain exact.
+    const origin = new URL(info.authorizationServerUrl).origin;
+    const issuer = !info.resourceMetadata?.authorization_servers?.length && info.authorizationServerUrl === `${origin}/`
+        ? canonicalAuthorizationServerIssuer(info.authorizationServerUrl)
+        : info.authorizationServerUrl;
+    if (info.authorizationServerMetadata !== undefined && info.authorizationServerMetadata.issuer !== issuer) {
+        throw new OAuthFlowError("needs_auth", `MCP server ${serverName} authorization server metadata issuer mismatch; restart authorization after correcting the server metadata.`, { serverName });
+    }
+    return issuer;
+}
+export function credentialsMatchIssuer(record, issuer) {
+    const grantIssuer = record?.issuer ?? record?.discoveryState?.authorizationServerUrl;
+    const clientIssuer = record?.clientInfo?.issuer ?? grantIssuer;
+    return [grantIssuer, clientIssuer].every((stamp) => stamp === undefined ||
+        canonicalAuthorizationServerIssuer(stamp) === canonicalAuthorizationServerIssuer(issuer));
+}
+//# sourceMappingURL=oauth-issuer.js.map

package/dist/core/extensions/builtin/mcp/auth/oauth-provider.d.ts

@@ -15,8 +15,6 @@ export interface McpOAuthProviderOptions {
     onRedirect?: (url: URL) => void | Promise<void>;
 }
 export declare function tokenExpiresAt(tokens: OAuthTokens, now?: number): number | undefined;
-/** Compares authorization server identifiers the way the SDK does: parsed, tolerating one trailing `/`. */
-export declare function sameAuthorizationServer(a: string, b: string): boolean;
 /**
  * The authorization server a stored grant belongs to (senpi#2940, GHSA-6qxp-vccf-f47h): its `issuer` stamp, or
  * for a record saved before the stamp existed, the authorization server its sign-in discovered. A record with
@@ -37,7 +35,9 @@ export declare class McpOAuthProvider implements OAuthClientProvider {
     get lastAuthorizationUrl(): URL | undefined;
     get redirectUrl(): string | URL | undefined;
     get clientMetadataUrl(): string | undefined;
-    get clientMetadata(): OAuthClientMetadata;
+    get clientMetadata(): OAuthClientMetadata & {
+        application_type?: "native" | "web";
+    };
     state(): string;
     consumeState(candidate: string | undefined): boolean;
     clientInformation(): OAuthClientInformationMixed | undefined;

package/dist/core/extensions/builtin/mcp/auth/oauth-provider.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { fingerprintSecret } from "../log.js";
 import { OAuthFlowError } from "./oauth-errors.js";
+import { canonicalAuthorizationServerIssuer, credentialsMatchIssuer, validatedAuthorizationServerIssuer, } from "./oauth-issuer.js";
 // Buffer before absolute token expiry at which a refresh is considered due.
 export const REFRESH_LEEWAY_MS = 5 * 60 * 1000;
 export function tokenExpiresAt(tokens, now = Date.now()) {
@@ -8,20 +9,6 @@ export function tokenExpiresAt(tokens, now = Date.now()) {
         return undefined;
     return now + tokens.expires_in * 1000;
 }
-/** Compares authorization server identifiers the way the SDK does: parsed, tolerating one trailing `/`. */
-export function sameAuthorizationServer(a, b) {
-    const normalize = (value) => {
-        try {
-            return new URL(value).href.replace(/\/$/, "");
-        }
-        catch (error) {
-            if (error instanceof TypeError)
-                return value.replace(/\/$/, "");
-            throw error;
-        }
-    };
-    return normalize(a) === normalize(b);
-}
 /**
  * The authorization server a stored grant belongs to (senpi#2940, GHSA-6qxp-vccf-f47h): its `issuer` stamp, or
  * for a record saved before the stamp existed, the authorization server its sign-in discovered. A record with
@@ -101,6 +88,14 @@ export class McpOAuthProvider {
     get clientMetadata() {
         const redirect = this.#options.redirectUrl;
         return {
+            ...(redirect === undefined
+                ? {}
+                : {
+                    application_type: !["http:", "https:"].includes(new URL(redirect).protocol) ||
+                        ["127.0.0.1", "localhost", "[::1]"].includes(new URL(redirect).hostname)
+                        ? "native"
+                        : "web",
+                }),
             redirect_uris: redirect === undefined ? [] : [String(redirect)],
             grant_types: ["authorization_code", "refresh_token"],
             response_types: ["code"],
@@ -127,20 +122,56 @@ export class McpOAuthProvider {
         return this.#store.read()?.clientInfo;
     }
     async saveClientInformation(info) {
-        // The SDK stamps `info.issuer`; it is persisted with the rest so the binding survives a restart.
-        await this.#store.update((current) => ({ ...(current ?? {}), clientInfo: info }));
+        const discovery = this.discoveryState();
+        const issuer = discovery === undefined
+            ? info.issuer && canonicalAuthorizationServerIssuer(info.issuer)
+            : validatedAuthorizationServerIssuer(discovery, this.serverName);
+        await this.#store.update((current) => ({ ...(current ?? {}), clientInfo: { ...info, issuer } }));
     }
     async saveDiscoveryState(state) {
-        await this.#store.update((current) => ({ ...freezeGrantAttribution(current), discoveryState: state }));
+        const issuer = validatedAuthorizationServerIssuer(state, this.serverName);
+        const discoveryState = { ...state, authorizationServerUrl: issuer };
+        await this.#store.update((current) => {
+            const attributed = freezeGrantAttribution(current);
+            if (!credentialsMatchIssuer(attributed, issuer))
+                return { discoveryState };
+            const clientIssuer = attributed.clientInfo?.issuer ?? storedGrantIssuer(attributed);
+            return {
+                ...attributed,
+                // Unattributed legacy registrations cannot be sent to the server discovered now.
+                clientInfo: clientIssuer === undefined || attributed.clientInfo === undefined
+                    ? undefined
+                    : { ...attributed.clientInfo, issuer },
+                discoveryState,
+            };
+        });
     }
     discoveryState() {
-        return this.#store.read()?.discoveryState;
+        const current = this.#store.read();
+        const state = current?.discoveryState;
+        if (state !== undefined) {
+            try {
+                const issuer = validatedAuthorizationServerIssuer(state, this.serverName);
+                if (!credentialsMatchIssuer(current, issuer))
+                    return undefined;
+            }
+            catch (error) {
+                if (error instanceof OAuthFlowError)
+                    return undefined;
+                throw error;
+            }
+        }
+        return state;
     }
     tokens() {
         return storedAuthToTokens(this.#store.read());
     }
     async saveTokens(tokens) {
-        await this.#store.update((current) => mergeTokensIntoStoredAuth(current, tokens, this.serverUrl));
+        const discovery = this.discoveryState();
+        const issuer = discovery === undefined
+            ? tokens.issuer && canonicalAuthorizationServerIssuer(tokens.issuer)
+            : validatedAuthorizationServerIssuer(discovery, this.serverName);
+        await this.#store.update((current) => mergeTokensIntoStoredAuth(current, { ...tokens, issuer }, this.serverUrl));
         this.#logFingerprint("saveTokens", tokens.access_token);
     }
     async saveCodeVerifier(codeVerifier) {

package/dist/core/extensions/builtin/mcp/auth/oauth-refresh.js

@@ -2,7 +2,8 @@ import { loadMcpSdkAuth } from "../sdk.lazy.js";
 import { safeDelay } from "../wrap.js";
 import { isInvalidGrant, isTransientTokenError, OAuthFlowError } from "./oauth-errors.js";
 import { oauthFetch } from "./oauth-fetch.js";
-import { mergeTokensIntoStoredAuth, REFRESH_LEEWAY_MS, sameAuthorizationServer, storedAuthToTokens, storedGrantIssuer, } from "./oauth-provider.js";
+import { credentialsMatchIssuer, validatedAuthorizationServerIssuer } from "./oauth-issuer.js";
+import { mergeTokensIntoStoredAuth, REFRESH_LEEWAY_MS, storedAuthToTokens, storedGrantIssuer, } from "./oauth-provider.js";
 export function isTokenStale(record, now) {
     const token = record?.accessToken;
     if (token === undefined || token.length === 0)
@@ -67,8 +68,8 @@ export class McpRefreshManager {
         // elsewhere, or one that cannot be attributed at all, is a continuity break: drop it and require a fresh
         // sign-in rather than refreshing silently against whatever server discovery now names.
         const issuer = storedGrantIssuer(current);
-        const authorizationServer = String(info.authorizationServerUrl);
-        if (issuer === undefined || !sameAuthorizationServer(issuer, authorizationServer)) {
+        const authorizationServer = validatedAuthorizationServerIssuer(info, this.#provider.serverName);
+        if (issuer === undefined || !credentialsMatchIssuer(current, authorizationServer)) {
             this.#provider.store.writeUnlocked(undefined);
             throw new OAuthFlowError("needs_auth", issuer === undefined
                 ? `MCP server ${this.#provider.serverName} has a saved sign-in with no record of the authorization server that issued it; credentials cleared, re-authentication required.`

package/dist/core/extensions/builtin/mcp/auth/oauth.js

@@ -1,6 +1,7 @@
 import { loadMcpSdkAuth } from "../sdk.lazy.js";
 import { isInvalidGrant, OAuthFlowError } from "./oauth-errors.js";
 import { oauthFetch } from "./oauth-fetch.js";
+import { validatedAuthorizationServerIssuer } from "./oauth-issuer.js";
 import { assertS256Supported } from "./oauth-refresh.js";
 // Pre-flight: discover the authorization server and REFUSE (typed) if it does
 // not advertise PKCE S256. Runs before any authorize redirect.
@@ -20,7 +21,7 @@ export async function beginAuthorization(provider, options = {}) {
 }
 // Paste flow: validates single-use state itself, then exchanges the code.
 export async function completeAuthorization(provider, redirectInput, options = {}) {
-    const { code, state, iss } = parseRedirect(redirectInput, provider.serverName);
+    const { code, state, iss } = parseRedirect(redirectInput, provider);
     if (!provider.consumeState(state)) {
         throw new OAuthFlowError("state_mismatch", `MCP server ${provider.serverName} authorization state did not match (possible CSRF or a stale/replayed link); restart with /mcp auth-start.`, { serverName: provider.serverName });
     }
@@ -56,15 +57,19 @@ export async function finishAuthorization(provider, code, options = {}, iss) {
 // RFC 9207: an authorization response that names another authorization server, or that omits `iss`
 // although this server promises to send it, may have been injected by a mix-up attack; never exchange its code.
 function assertAuthorizationResponseIssuer(provider, iss) {
-    const metadata = provider.discoveryState()?.authorizationServerMetadata;
-    if (metadata === undefined)
-        return;
+    const discovery = provider.discoveryState();
+    if (discovery === undefined) {
+        throw new OAuthFlowError("needs_auth", `MCP server ${provider.serverName} has no trusted authorization discovery; restart with /mcp auth-start ${provider.serverName}.`, { serverName: provider.serverName });
+    }
+    const metadata = discovery.authorizationServerMetadata;
+    const issuer = validatedAuthorizationServerIssuer(discovery, provider.serverName);
     // The SDK keeps unknown metadata fields (loose schema) but does not type this RFC 9207 one.
-    const promised = metadata
-        .authorization_response_iss_parameter_supported === true;
+    const promised = metadata !== undefined &&
+        "authorization_response_iss_parameter_supported" in metadata &&
+        metadata.authorization_response_iss_parameter_supported === true;
     if (iss === undefined && !promised)
         return;
-    if (iss !== undefined && iss === metadata.issuer)
+    if (iss !== undefined && iss === issuer)
         return;
     throw new OAuthFlowError("needs_auth", iss === undefined
         ? `MCP server ${provider.serverName} authorization response has no issuer although its authorization server promises one; restart with /mcp auth-start ${provider.serverName}.`
@@ -111,19 +116,19 @@ export async function clientCredentialsGrant(provider, options = {}) {
         resource: new URL(provider.serverUrl),
         fetchFn: oauthFetch(options.fetchFn),
     });
-    await provider.saveTokens({ ...tokens, issuer: String(info.authorizationServerUrl) });
+    await provider.saveTokens({ ...tokens, issuer: validatedAuthorizationServerIssuer(info, provider.serverName) });
 }
 export async function logout(provider) {
     await provider.store.clear();
 }
 async function discover(provider, options) {
-    if (options.discover !== undefined)
-        return options.discover(provider.serverUrl);
     const cached = provider.discoveryState();
     if (cached !== undefined)
         return cached;
     const { discoverOAuthServerInfo } = await loadMcpSdkAuth();
-    const info = await discoverOAuthServerInfo(provider.serverUrl, { fetchFn: oauthFetch(options.fetchFn) });
+    const info = options.discover !== undefined
+        ? await options.discover(provider.serverUrl)
+        : await discoverOAuthServerInfo(provider.serverUrl, { fetchFn: oauthFetch(options.fetchFn) });
     await provider.saveDiscoveryState(toDiscoveryState(info));
     return info;
 }
@@ -134,7 +139,8 @@ function toDiscoveryState(info) {
         resourceMetadata: info.resourceMetadata,
     };
 }
-function parseRedirect(input, serverName) {
+function parseRedirect(input, provider) {
+    const serverName = provider.serverName;
     let url;
     try {
         url = new URL(input.trim());
@@ -142,6 +148,7 @@ function parseRedirect(input, serverName) {
     catch {
         throw new OAuthFlowError("needs_auth", `MCP server ${serverName} received a malformed redirect URL; paste the full http://127.0.0.1/... address from your browser.`, { serverName });
     }
+    assertAuthorizationResponseIssuer(provider, url.searchParams.get("iss") ?? undefined);
     const error = url.searchParams.get("error");
     if (error !== null) {
         throw new OAuthFlowError("needs_auth", `MCP server ${serverName} authorization failed: ${error}`, { serverName });

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

@@ -1,7 +1,7 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { McpServerDeclaredConfig } from "./config-schema.ts";
 import type { ServerConnection } from "./connection.ts";
-type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
+import type { McpListedTool as ListedTool } from "./tool-contracts.ts";
 type ListedResource = Awaited<ReturnType<Client["listResources"]>>["resources"][number];
 type ListedResourceTemplate = Awaited<ReturnType<Client["listResourceTemplates"]>>["resourceTemplates"][number];
 type ListedPrompt = Awaited<ReturnType<Client["listPrompts"]>>["prompts"][number];
@@ -10,6 +10,7 @@ export interface McpCatalogCacheFile {
     readonly servers: Record<string, McpCachedServerCatalog>;
 }
 export interface McpCachedServerCatalog {
+    readonly modern?: boolean;
     readonly configHash: string;
     readonly credentialIdentity?: string;
     readonly fetchedAt: number;

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 {