@gajae-code/coding-agent 0.13.2 → 0.14.0

package/dist/types/runtime-mcp/config.d.ts

@@ -15,6 +15,13 @@ export interface LoadMCPConfigsOptions {
     filterBrowser?: boolean;
     /** Only include startup-eligible servers; exact-config sessions always enforce autoload !== false. */
     autoloadOnly?: boolean;
+    /**
+     * Restrict discovery to GJC's own native config (`.gjc/` project and
+     * `~/.gjc/agent/` user scopes). Conventional standalone sessions use this
+     * mode: Claude Code/Codex project/global MCP files are explicit import
+     * sources into `.gjc`, not implicit competing runtime authorities.
+     */
+    nativeOnly?: boolean;
     /** Load only this explicit MCP config file. */
     configPath?: string;
 }
@@ -28,6 +35,8 @@ export interface LoadMCPConfigsResult {
     sources: Record<string, SourceMeta>;
     /** Whether the explicit configuration was unavailable or contained invalid entries. */
     configurationWarning: boolean;
+    /** Provider warnings surfaced during discovery (parse/skip diagnostics). */
+    warnings: string[];
 }
 /**
  * Load all MCP server configs from standard locations.

package/dist/types/runtime-mcp/manager.d.ts

@@ -9,9 +9,10 @@ import type { SourceMeta } from "../capability/types";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import type { AuthStorage } from "../session/auth-storage";
 import { MCPConnectionPool, type MCPPoolLease } from "./pool";
+import type { MCPProtocolObservation } from "./protocol";
 import type { MCPToolDetails } from "./tool-bridge";
 import type { MCPToolCache } from "./tool-cache";
-import type { MCPGetPromptResult, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
+import type { MCPGetPromptResult, MCPInputRequestHandler, MCPPrompt, MCPRequestOptions, MCPResource, MCPResourceReadResult, MCPResourceTemplate, MCPServerConfig, MCPServerConnection } from "./types";
 export declare function resolveStartupTimeoutMs(configs: MCPServerConfig[], maxStartupTimeoutMs?: number): number;
 export declare function resolveExactConfigStartupTimeoutMs(configs: MCPServerConfig[]): number;
 export declare class MCPManagerLifecycleError extends Error {
@@ -54,6 +55,12 @@ export interface MCPDiscoverOptions {
     filterBrowser?: boolean;
     /** Only connect servers with autoload !== false (default: false) */
     autoloadOnly?: boolean;
+    /**
+     * Restrict discovery to GJC's native `.gjc` scopes (user + project).
+     * Runtime MCP authority for GJC sessions; Claude Code/Codex files are
+     * explicit import sources into `.gjc`, not implicit runtime authorities.
+     */
+    nativeOnly?: boolean;
     /** Called when starting to connect to servers */
     onConnecting?: (serverNames: string[]) => void;
     /** Load only this explicit MCP config file. */
@@ -125,6 +132,13 @@ export declare class MCPManager {
      * Set the auth storage for resolving OAuth credentials.
      */
     setAuthStorage(authStorage: AuthStorage): void;
+    /**
+     * Register the handler for modern MRTR `input_required` results (structured
+     * elicitation/roots/sampling input requests). Runtimes with an interactive
+     * question surface (e.g. ACP `elicitation/create`) register here; without a
+     * handler, `input_required` fails explicitly instead of hanging.
+     */
+    setInputRequestHandler(handler: MCPInputRequestHandler | null): void;
     /**
      * Discover and connect to all MCP servers from .mcp.json files.
      * Returns tools and any connection errors.
@@ -147,6 +161,17 @@ export declare class MCPManager {
      * Get current connection status for a server.
      */
     getConnectionStatus(name: string): "connected" | "connecting" | "disconnected";
+    /**
+     * Get the authoritative protocol observation for a connected server
+     * (preference, negotiated era/version, downgrade decision, deprecation state).
+     * Secret-free; the single observation model consumed by customization doctor
+     * (#4288) and /extensions (#4291). Returns undefined when not connected.
+     */
+    getProtocolObservation(name: string): MCPProtocolObservation | undefined;
+    /**
+     * Snapshot of protocol observations for all connected servers.
+     */
+    getProtocolObservations(): ReadonlyMap<string, MCPProtocolObservation>;
     /**
      * Get the source metadata for a server.
      */

package/dist/types/runtime-mcp/oauth-discovery.d.ts

@@ -10,6 +10,10 @@ export interface OAuthEndpoints {
     tokenUrl: string;
     clientId?: string;
     scopes?: string;
+    /** Issuer recorded from the validated metadata document (RFC 9207). */
+    issuer?: string;
+    /** `authorization_response_iss_parameter_supported` from the same metadata. */
+    authorizationResponseIssSupported?: boolean;
 }
 export interface AuthDetectionResult {
     requiresAuth: boolean;

package/dist/types/runtime-mcp/oauth-flow.d.ts

@@ -6,12 +6,22 @@
  */
 import { OAuthCallbackFlow } from "@gajae-code/ai/utils/oauth/callback-server";
 import type { OAuthController, OAuthCredentials } from "@gajae-code/ai/utils/oauth/types";
+/**
+ * Canonical MCP server resource URI per RFC 8707 §2: absolute URI, lowercase
+ * scheme/host, no fragment, no trailing slash on an empty path.
+ */
+export declare function canonicalMCPResourceUri(raw: string): string | undefined;
 export interface MCPOAuthConfig {
     /** Authorization endpoint URL */
     authorizationUrl: string;
     /** Token endpoint URL */
     tokenUrl: string;
-    /** Client ID (optional when already embedded in authorization URL) */
+    /**
+     * Client ID (optional when already embedded in authorization URL). An
+     * HTTPS URL here is a Client ID Metadata Document (CIMD) reference per
+     * MCP 2026-07-28 and is used as-is; Dynamic Client Registration is only a
+     * deprecated backwards-compatibility fallback when no client id exists.
+     */
     clientId?: string;
     /** Client secret (optional for PKCE flows) */
     clientSecret?: string;
@@ -23,6 +33,19 @@ export interface MCPOAuthConfig {
     callbackPort?: number;
     /** Custom callback path (default: /callback or redirectUri pathname) */
     callbackPath?: string;
+    /**
+     * Canonical URI of the target MCP server (RFC 8707). Sent as the `resource`
+     * parameter on BOTH the authorization and token requests, regardless of
+     * authorization-server support.
+     */
+    resource?: string;
+    /**
+     * Expected authorization-server issuer recorded from validated discovery
+     * metadata (RFC 9207 / MCP 2026-07-28). Validation fails closed on mismatch.
+     */
+    issuer?: string;
+    /** `authorization_response_iss_parameter_supported` from the same metadata. */
+    issuerResponseIssSupported?: boolean;
 }
 /**
  * Generic OAuth flow for MCP servers.

package/dist/types/runtime-mcp/pool-key.d.ts

@@ -48,6 +48,8 @@ export interface MCPPoolKeyIdentity {
     authScopeId: string;
     pluginNetworkPolicyId: string;
     capabilityProfile: MCPPoolCapabilityProfile;
+    /** Resolved protocol preference (auto | 2026-07-28 | legacy); partitions protocol generations. */
+    protocolPreference: string;
     sessionId?: string;
 }
 /**

package/dist/types/runtime-mcp/protocol.d.ts

@@ -0,0 +1,278 @@
+/**
+ * MCP protocol generation model ("MCP v2", specification 2026-07-28).
+ *
+ * Canonical authority (verified against the primary sources, not secondary
+ * summaries):
+ * - https://modelcontextprotocol.io/specification/2026-07-28/basic
+ * - https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http
+ * - https://modelcontextprotocol.io/specification/2026-07-28/basic/versioning
+ * - https://modelcontextprotocol.io/specification/2026-07-28/basic/patterns/mrtr
+ * - https://modelcontextprotocol.io/specification/2026-07-28/server/discover
+ * - https://modelcontextprotocol.io/specification/2026-07-28/server/utilities/caching
+ * - schema source of truth: modelcontextprotocol/specification schema/2026-07-28/schema.ts
+ *
+ * 2026-07-28 ("modern" era) removes the initialize/initialized handshake,
+ * protocol sessions (`Mcp-Session-Id`), the standalone GET SSE stream, and
+ * `Last-Event-ID` replay from the core request path. Every request carries its
+ * protocol version, client identity, and client capabilities in `_meta`, and
+ * Streamable HTTP mirrors selected fields into `MCP-Protocol-Version`,
+ * `Mcp-Method`, and `Mcp-Name` headers.
+ */
+/** The modern (stateless) protocol revision implemented by this client. */
+export declare const MCP_PROTOCOL_VERSION_2026_07_28 = "2026-07-28";
+/** Legacy (initialize handshake) revision this client speaks for compatibility. */
+export declare const MCP_PROTOCOL_VERSION_LEGACY = "2025-03-26";
+/** Modern-era revisions this client can speak, most preferred first. */
+export declare const MCP_MODERN_PROTOCOL_VERSIONS: readonly string[];
+/** Protocol generation: modern = per-request metadata (2026-07-28+), legacy = initialize handshake. */
+export type MCPProtocolEra = "modern" | "legacy";
+/**
+ * Per-server protocol preference from configuration.
+ * - `auto`: attempt modern first; bounded, observable legacy fallback per the
+ *   specification's era-detection rules. Default when unset.
+ * - `2026-07-28`: strict modern-only; never initializes a legacy session.
+ * - `legacy`: bounded compatibility mode; always uses the legacy handshake.
+ */
+export type MCPProtocolPreference = "auto" | "2026-07-28" | "legacy";
+export declare const MCP_PROTOCOL_PREFERENCES: readonly MCPProtocolPreference[];
+export declare function isMCPProtocolPreference(value: unknown): value is MCPProtocolPreference;
+/** Resolve the effective preference; `auto` when unset. */
+export declare function resolveMCPProtocolPreference(value: MCPProtocolPreference | undefined): MCPProtocolPreference;
+/** True when a version string names a modern-era revision (date-based, >= 2026-07-28). */
+export declare function isModernProtocolVersion(version: string): boolean;
+/** Headers do not match the request body, or required headers are missing/malformed. */
+export declare const MCP_ERROR_HEADER_MISMATCH = -32020;
+/** The request requires a client capability the client did not declare. */
+export declare const MCP_ERROR_MISSING_REQUIRED_CLIENT_CAPABILITY = -32021;
+/** The server does not implement the requested protocol version. */
+export declare const MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+/** Standard JSON-RPC method-not-found (modern servers pair it with HTTP 404). */
+export declare const JSONRPC_ERROR_METHOD_NOT_FOUND = -32601;
+/** Standard JSON-RPC invalid-params (modern servers reject missing `_meta` with it). */
+export declare const JSONRPC_ERROR_INVALID_PARAMS = -32602;
+export declare const MCP_META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+export declare const MCP_META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+export declare const MCP_META_CLIENT_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+export declare const MCP_META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+/** Client identity advertised in modern per-request `_meta`. */
+export interface MCPModernClientContext {
+    protocolVersion: string;
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+    /** Capabilities relevant to requests, e.g. `{ roots: {...}, elicitation: {...} }`. */
+    capabilities: Record<string, unknown>;
+}
+/**
+ * Build the `_meta` object every modern request MUST carry. Callers merge this
+ * into `params._meta`, preserving any pre-existing keys (e.g. `progressToken`).
+ */
+export declare function buildModernRequestMeta(context: MCPModernClientContext): Record<string, unknown>;
+/** Merge modern `_meta` into request params without clobbering existing keys. */
+export declare function withModernMeta(params: Record<string, unknown>, context: MCPModernClientContext): Record<string, unknown>;
+/** RFC 9110 field-value safe set: visible ASCII, space, and horizontal tab. */
+export declare function isPlainAsciiHeaderValue(value: string): boolean;
+/**
+ * Encode a value for `Mcp-Name` / `Mcp-Param-{Name}` headers: plain ASCII when
+ * safe, otherwise the `=?base64?<base64-utf8>?=` sentinel. Values already
+ * matching the sentinel pattern MUST also be encoded to avoid ambiguity.
+ */
+export declare function encodeMcpHeaderValue(value: string): string;
+/**
+ * Build the mirrored headers a modern Streamable HTTP request MUST carry:
+ * `MCP-Protocol-Version` (must equal the `_meta` version), `Mcp-Method`, and —
+ * for `tools/call`, `resources/read`, `prompts/get` — `Mcp-Name`.
+ */
+export declare function buildModernMcpHeaders(input: {
+    protocolVersion: string;
+    method: string;
+    params?: Record<string, unknown>;
+}): Record<string, string>;
+/** A validated binding from a tool inputSchema property to an `Mcp-Param-*` header. */
+export interface McpHeaderParamBinding {
+    /** Exact property path (chain of `properties` keys) in the call arguments. */
+    propertyPath: string[];
+    /** The `name` portion of the `Mcp-Param-{name}` header. */
+    headerName: string;
+    /** Primitive type of the annotated property. */
+    propertyType: "string" | "integer" | "boolean";
+}
+export interface XMcpHeaderBindingsResult {
+    bindings: McpHeaderParamBinding[];
+    /** Human-readable reasons the tool definition is invalid for HTTP mirroring. */
+    violations: string[];
+}
+/**
+ * Collect `x-mcp-header` bindings from a tool `inputSchema`, enforcing the
+ * specification constraints: field-name token syntax, primitive (non-number)
+ * types, case-insensitive uniqueness, and static reachability via `properties`
+ * chains only. Any violation invalidates the tool definition for HTTP clients.
+ */
+export declare function collectXMcpHeaderBindings(inputSchema: unknown): XMcpHeaderBindingsResult;
+/**
+ * Extract `Mcp-Param-{name}` headers from tool call arguments per validated
+ * bindings. Missing or null values omit the header, per the specification.
+ */
+export declare function buildXMcpParamHeaders(bindings: readonly McpHeaderParamBinding[], args: Record<string, unknown>): Record<string, string>;
+/** Failure classes for a modern probe request. */
+export type MCPProbeFailureClass = 
+/** Recognized modern JSON-RPC error: the server speaks a modern revision. */
+"modern-error"
+/** 4xx without a recognized modern error body: legacy-era server signal. */
+ | "legacy-signal"
+/** 401/403 (and WWW-Authenticate challenges): never a downgrade signal. */
+ | "auth-failure"
+/** Anything else (5xx, network, malformed payload): not a downgrade signal. */
+ | "other-failure";
+export interface MCPProbeClassification {
+    class: MCPProbeFailureClass;
+    /** Protocol-defined modern error code when recognized. */
+    modernErrorCode?: number;
+    /** `data.supported` from an UnsupportedProtocolVersionError, when present. */
+    supportedVersions?: string[];
+    /** `data.requested` from an UnsupportedProtocolVersionError, when present. */
+    requestedVersion?: string;
+}
+/**
+ * Classify a failed modern probe per the specification's era-detection rules:
+ * recognized modern JSON-RPC errors identify a modern server; a 400/404/405
+ * without one identifies a legacy server; auth and security failures are never
+ * era signals and must never authorize a downgrade.
+ */
+export declare function classifyMcpProbeFailure(status: number, parsedBody: unknown): MCPProbeClassification;
+/** Lifecycle state of a protocol feature, mirroring the specification's feature lifecycle. */
+export type MCPFeatureLifecycle = "active" | "deprecated" | "removed";
+export interface MCPProtocolFeatureState {
+    feature: string;
+    lifecycle: MCPFeatureLifecycle;
+    /** Secret-free explanation shown in diagnostics. */
+    note?: string;
+}
+/** How the effective era/version was reached. */
+export type MCPNegotiationState = 
+/** No negotiation attempt has completed yet. */
+"pending"
+/** Modern era confirmed (probe or direct modern request succeeded). */
+ | "modern"
+/** Modern era after selecting a mutually supported version from UnsupportedProtocolVersionError. */
+ | "modern-version-retry"
+/** Legacy era via era detection (legacy server signal) under `auto`. */
+ | "legacy-fallback"
+/** Legacy era because configuration forced it (`legacy`) or the transport is stdio. */
+ | "legacy-forced"
+/** Negotiation failed; the connection could not be established. */
+ | "failed";
+/** Machine-readable reasons a legacy fallback was engaged (never auth/security driven). */
+export type MCPDowngradeReason = 
+/** `protocol: "legacy"` configured explicitly. */
+"preference-legacy"
+/** stdio transport has no per-request HTTP signals; legacy handshake retained. */
+ | "stdio-transport"
+/** Probe returned 400/404/405 without a recognized modern error body. */
+ | "legacy-server-signal"
+/** A modern server advertised only legacy-era versions in `supported`. */
+ | "server-advertised-legacy-only";
+/**
+ * One authoritative, secret-free observation of a server's negotiated protocol
+ * state. Consumed by `/extensions` (#4291) and customization doctor (#4288);
+ * contains no credentials, tokens, metadata documents, or header values.
+ */
+export interface MCPProtocolObservation {
+    /** Configured preference (defaults to `auto`). */
+    preference: MCPProtocolPreference;
+    /** Effective protocol version in use, once negotiated. */
+    effectiveVersion: string | null;
+    /** Effective era, once negotiated. */
+    era: MCPProtocolEra | null;
+    /** How the effective state was reached. */
+    negotiation: MCPNegotiationState;
+    /** Why a legacy fallback engaged; null unless `negotiation` is a legacy state. */
+    downgradeReason: MCPDowngradeReason | null;
+    /** Versions the server advertised (via server/discover or version errors). */
+    supportedVersions: string[];
+    /** Self-reported server identity (display only; never security-relevant). */
+    serverInfo: {
+        name: string;
+        version: string;
+    } | null;
+    /** Lifecycle visibility for protocol features (legacy session behavior, etc). */
+    features: MCPProtocolFeatureState[];
+    /** v2 capability state observed for this connection. */
+    capabilities: {
+        /** server/discover answered (optional per spec; absence does not block calls). */
+        discover: "yes" | "no" | "unknown";
+        /** Server advertised tools capability. */
+        tools: boolean;
+        /** Server advertised resources capability. */
+        resources: boolean;
+        /** Server advertised prompts capability. */
+        prompts: boolean;
+    };
+}
+/** Initial observation before negotiation completes. */
+export declare function createMCPProtocolObservation(preference: MCPProtocolPreference): MCPProtocolObservation;
+/** Legacy session/transport features reported as deprecated under the feature lifecycle. */
+export declare function legacyEraFeatureStates(): MCPProtocolFeatureState[];
+/** Finalize an observation for a negotiated modern connection. */
+export declare function modernEraObservation(input: {
+    preference: MCPProtocolPreference;
+    effectiveVersion: string;
+    negotiation: "modern" | "modern-version-retry";
+    supportedVersions?: string[];
+    serverInfo?: {
+        name: string;
+        version: string;
+    } | null;
+    capabilities?: {
+        tools?: boolean;
+        resources?: boolean;
+        prompts?: boolean;
+    };
+    discover: "yes" | "no" | "unknown";
+}): MCPProtocolObservation;
+/** Finalize an observation for a negotiated legacy connection. */
+export declare function legacyEraObservation(input: {
+    preference: MCPProtocolPreference;
+    effectiveVersion: string;
+    negotiation: "legacy-fallback" | "legacy-forced";
+    downgradeReason: MCPDowngradeReason;
+    serverInfo?: {
+        name: string;
+        version: string;
+    } | null;
+    capabilities?: {
+        tools?: boolean;
+        resources?: boolean;
+        prompts?: boolean;
+    };
+}): MCPProtocolObservation;
+/** Cache scope hint: public results may cross authorization contexts; private must not. */
+export type MCPCacheScope = "public" | "private";
+/** Server-supplied caching hints carried on cacheable `complete` results. */
+export interface MCPCacheHints {
+    /** Milliseconds the result may be considered fresh; absent/negative means 0. */
+    ttlMs?: number;
+    cacheScope?: MCPCacheScope;
+}
+/** Normalize raw hints: negative ttlMs is treated as 0 per the specification. */
+export declare function normalizeMcpCacheHints(raw: unknown): MCPCacheHints | undefined;
+/** Result type marker for interim input requests. */
+export declare const MCP_RESULT_TYPE_INPUT_REQUIRED = "input_required";
+export declare const MCP_RESULT_TYPE_COMPLETE = "complete";
+/** Input request methods a server may embed in an InputRequiredResult. */
+export declare const MCP_INPUT_REQUEST_METHODS: Set<string>;
+export interface MCPInputRequiredData {
+    inputRequests: Record<string, {
+        method: string;
+        params?: Record<string, unknown>;
+    }>;
+    requestState?: string;
+}
+/**
+ * Extract MRTR input data from a JSON-RPC result. Returns null when the result
+ * is a normal `complete` result (including legacy results with no resultType,
+ * which the specification requires clients to treat as `"complete"`).
+ * Throws on a malformed `input_required` payload.
+ */
+export declare function extractMcpInputRequired(result: unknown): MCPInputRequiredData | null;

package/dist/types/runtime-mcp/scope-config.d.ts

@@ -0,0 +1,29 @@
+import { type UpsertMCPServerResult } from "./config-writer";
+import type { MCPConfigFile, MCPServerConfig } from "./types";
+export type MCPConfigScope = "user" | "project";
+/** Resolved scope + path + parsed config (provenance for diagnostics). */
+export interface ScopeMCPConfigSnapshot {
+    scope: MCPConfigScope;
+    path: string;
+    config: MCPConfigFile;
+}
+/** Resolve the canonical file path for a native MCP config scope. */
+export declare function resolveScopeMCPConfigPath(scope: MCPConfigScope, cwd?: string): string;
+/** Read a native MCP config for a scope. Returns an empty config when absent. */
+export declare function readScopeMCPConfig(scope: MCPConfigScope, cwd?: string): Promise<ScopeMCPConfigSnapshot>;
+/** Add a server, or overwrite an existing one only when `force` is set. */
+export declare function upsertScopeMCPServer(scope: MCPConfigScope, name: string, config: MCPServerConfig, options?: {
+    force?: boolean;
+}, cwd?: string): Promise<ScopeMCPConfigSnapshot & {
+    result: UpsertMCPServerResult;
+}>;
+/** Remove a server from a scope (throws when the name does not exist). */
+export declare function removeScopeMCPServer(scope: MCPConfigScope, name: string, cwd?: string): Promise<ScopeMCPConfigSnapshot>;
+/** Get a specific server config from a scope. */
+export declare function getScopeMCPServer(scope: MCPConfigScope, name: string, cwd?: string): Promise<{
+    scope: MCPConfigScope;
+    path: string;
+    config: MCPServerConfig | undefined;
+}>;
+/** Read the disabled-servers denylist for a scope. */
+export declare function readScopeDisabledServers(scope: MCPConfigScope, cwd?: string): Promise<string[]>;

package/dist/types/runtime-mcp/tool-bridge.d.ts

@@ -9,10 +9,20 @@ import type { SourceMeta } from "../capability/types";
 import type { CustomTool, CustomToolContext, CustomToolResult, RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { MCPPoolLease } from "./pool";
-import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types";
+import type { MCPContent, MCPInputRequestHandler, MCPServerConnection, MCPToolDefinition } from "./types";
 /** Reconnect callback: tears down stale connection, returns new one or null. */
 export type MCPReconnect = () => Promise<MCPServerConnection | null>;
 type MCPToolTarget = MCPServerConnection | MCPPoolLease;
+/** Options shared by MCPTool and DeferredMCPTool. */
+export interface MCPToolOptions {
+    /** Shared lease policy: never retry the original request after transport/auth failure. */
+    noReplay?: boolean;
+    /**
+     * Lazy resolver for the modern MRTR `input_required` handler, registered by the
+     * owning manager/runtime. Resolved per call so late registration still applies.
+     */
+    inputHandler?: () => MCPInputRequestHandler | undefined;
+}
 export declare function isRetriableConnectionError(error: unknown): boolean;
 /** Details included in MCP tool results for rendering */
 export interface MCPToolDetails {
@@ -57,12 +67,8 @@ export declare class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
     readonly mcpServerName: string;
     private connection;
     /** Create MCPTool instances for all tools from an MCP server lease/connection. */
-    static fromTools(target: MCPToolTarget, tools: MCPToolDefinition[], reconnect?: MCPReconnect, options?: {
-        noReplay?: boolean;
-    }): MCPTool[];
-    constructor(target: MCPToolTarget, tool: MCPToolDefinition, reconnect?: MCPReconnect | undefined, options?: {
-        noReplay?: boolean;
-    });
+    static fromTools(target: MCPToolTarget, tools: MCPToolDefinition[], reconnect?: MCPReconnect, options?: MCPToolOptions): MCPTool[];
+    constructor(target: MCPToolTarget, tool: MCPToolDefinition, reconnect?: MCPReconnect | undefined, options?: MCPToolOptions);
     renderCall(args: unknown, _options: RenderResultOptions, theme: Theme): import("@gajae-code/tui").Component;
     renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown): import("@gajae-code/tui").Component;
     execute(_toolCallId: string, params: unknown, _onUpdate: AgentToolUpdateCallback<MCPToolDetails> | undefined, _ctx: CustomToolContext, signal?: AbortSignal): Promise<CustomToolResult<MCPToolDetails>>;
@@ -85,12 +91,8 @@ export declare class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetai
     /** Server name */
     readonly mcpServerName: string;
     /** Create DeferredMCPTool instances for all tools from an MCP server */
-    static fromTools(serverName: string, tools: MCPToolDefinition[], getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect, options?: {
-        noReplay?: boolean;
-    }): DeferredMCPTool[];
-    constructor(serverName: string, tool: MCPToolDefinition, getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect | undefined, options?: {
-        noReplay?: boolean;
-    });
+    static fromTools(serverName: string, tools: MCPToolDefinition[], getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect, options?: MCPToolOptions): DeferredMCPTool[];
+    constructor(serverName: string, tool: MCPToolDefinition, getConnection: () => Promise<MCPServerConnection>, source?: SourceMeta, reconnect?: MCPReconnect | undefined, options?: MCPToolOptions);
     renderCall(args: unknown, _options: RenderResultOptions, theme: Theme): import("@gajae-code/tui").Component;
     renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown): import("@gajae-code/tui").Component;
     execute(_toolCallId: string, params: unknown, _onUpdate: AgentToolUpdateCallback<MCPToolDetails> | undefined, _ctx: CustomToolContext, signal?: AbortSignal): Promise<CustomToolResult<MCPToolDetails>>;

package/dist/types/runtime-mcp/transports/http.d.ts

@@ -1,4 +1,5 @@
 import type { MCPHttpServerConfig, MCPRequestOptions, MCPSseServerConfig, MCPTransport } from "../../runtime-mcp/types";
+import { type MCPModernClientContext, type MCPProtocolEra } from "../protocol";
 /**
  * HTTP transport for MCP servers.
  * Uses POST for requests, supports SSE responses.
@@ -16,6 +17,14 @@ export declare class HttpTransport implements MCPTransport {
     get connected(): boolean;
     get closeBeforeReconnect(): false;
     get url(): string;
+    /** Negotiated protocol era (defaults to legacy until the client negotiates). */
+    get era(): MCPProtocolEra;
+    /**
+     * Select the protocol era. Modern mode requires the per-request client
+     * context (protocol version, identity, capabilities) mirrored into `_meta`
+     * and HTTP headers on every request.
+     */
+    setProtocolMode(era: MCPProtocolEra, modernContext?: MCPModernClientContext): void;
     /**
      * Mark transport as connected.
      * HTTP doesn't need persistent connection, but we track state.