@xenosystem/agent-sdk 0.8.12

package/dist/mcp/index.d.ts

@@ -0,0 +1,960 @@
+import { ChildProcess } from "node:child_process";
+type PermissionProfileName = "default" | "read-only" | "trusted-dev";
+type PermissionProfileDecision = "allow" | "ask" | "deny";
+type PermissionProfileMode = "default" | "acceptEdits" | "bypassPermissions" | "auto";
+interface PermissionProfile {
+    schemaVersion: 1;
+    name: PermissionProfileName;
+    displayName: string;
+    description: string;
+    permissionMode: PermissionProfileMode;
+    filesystem: {
+        scope: "workspace" | "workspace-readonly" | "unrestricted";
+        read: PermissionProfileDecision;
+        write: PermissionProfileDecision;
+        allowedPaths: string[];
+        deniedPaths: string[];
+    };
+    shell: {
+        default: PermissionProfileDecision;
+        allowedCommands: string[];
+        deniedCommands: string[];
+    };
+    network: {
+        default: PermissionProfileDecision;
+        allowDomains: string[];
+        denyDomains: string[];
+    };
+    mcp: {
+        remoteServers: PermissionProfileDecision;
+        allowedServers: string[];
+        deniedServers: string[];
+    };
+    lsp: {
+        enabled: boolean;
+        diagnostics: PermissionProfileDecision;
+        navigation: PermissionProfileDecision;
+        startProcesses: PermissionProfileDecision;
+    };
+}
+declare const MCP_APPS_EXTENSION_ID: "io.modelcontextprotocol/ui";
+declare const MCP_APP_RESOURCE_SCHEME: "ui:";
+declare const MCP_APP_MIME_TYPE: "text/html;profile=mcp-app";
+type MCPAppVisibility = "model" | "app";
+interface MCPAppCapabilities {
+    mimeTypes: string[];
+}
+interface MCPAppContentSecurityPolicy {
+    connectDomains?: string[];
+    resourceDomains?: string[];
+    frameDomains?: string[];
+    baseUriDomains?: string[];
+}
+interface MCPAppPermissions {
+    camera?: boolean;
+    microphone?: boolean;
+    geolocation?: boolean;
+    clipboardWrite?: boolean;
+}
+interface MCPAppMetadata {
+    resourceUri?: string;
+    visibility?: MCPAppVisibility[];
+    csp?: MCPAppContentSecurityPolicy;
+    permissions?: MCPAppPermissions;
+}
+interface MCPAppExtensionMetadata {
+    ui?: MCPAppMetadata;
+    [key: string]: unknown;
+}
+interface MCPAppResourceDescriptor {
+    uri: string;
+    mimeType?: string;
+    _meta?: MCPAppExtensionMetadata;
+}
+interface MCPAppValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+declare function createMcpAppCapabilities(mimeTypes?: string[]): MCPAppCapabilities;
+declare function createMcpAppExtensionCapabilities(capabilities?: MCPAppCapabilities): Record<string, MCPAppCapabilities>;
+declare function getMcpAppMetadata(metadata: MCPAppExtensionMetadata | Record<string, unknown> | undefined): MCPAppMetadata | undefined;
+declare function normalizeMcpAppVisibility(metadata: MCPAppExtensionMetadata | Record<string, unknown> | undefined): MCPAppVisibility[];
+declare function isMcpToolVisibleToModel(metadata: MCPAppExtensionMetadata | Record<string, unknown> | undefined): boolean;
+declare function isMcpToolVisibleToApp(metadata: MCPAppExtensionMetadata | Record<string, unknown> | undefined): boolean;
+declare function getMcpAppResourceUri(metadata: MCPAppExtensionMetadata | Record<string, unknown> | undefined): string | undefined;
+declare function isMcpAppResourceUri(uri: string): boolean;
+declare function validateMcpAppResource(resource: MCPAppResourceDescriptor): MCPAppValidationResult;
+declare function assertValidMcpAppResource(resource: MCPAppResourceDescriptor): void;
+type MCPTransport = "stdio" | "streamable-http" | "sse";
+type MCPServerScope = "project" | "mcprc" | "user" | "session";
+type MCPApprovalDecision = "approved" | "denied";
+interface MCPOAuthConfig {
+    protectedResourceMetadataUrl?: string;
+    authorizationServerMetadataUrl?: string;
+    scopes?: string[];
+    clientId?: string;
+    clientSecretEnv?: string;
+    clientMetadataUrl?: string;
+    allowDynamicRegistration?: boolean;
+}
+interface MCPServerConfig {
+    name: string;
+    transport?: MCPTransport;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    url?: string;
+    headers?: Record<string, string>;
+    bearerTokenEnv?: string;
+    oauth?: MCPOAuthConfig;
+    legacySseFallback?: boolean;
+    approvalRequired?: boolean;
+    scope?: MCPServerScope;
+    sourcePath?: string;
+    approvalKey?: string;
+    approvalState?: MCPApprovalDecision;
+    disabled?: boolean;
+}
+interface MCPServerState {
+    config: MCPServerConfig;
+    status: "connecting" | "ready" | "error" | "disconnected";
+    tools: MCPTool[];
+    prompts?: MCPPrompt[];
+    resources?: MCPResource[];
+    capabilities?: MCPInitializeResult["capabilities"];
+    protocolVersion?: string;
+    instructions?: string;
+    error?: string;
+    approvalState?: MCPApprovalDecision;
+    subscribedResources?: string[];
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    server: string;
+    _meta?: MCPAppExtensionMetadata;
+    appResourceUri?: string;
+    visibility: MCPAppVisibility[];
+}
+interface MCPPrompt {
+    name: string;
+    description: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    server: string;
+}
+interface MCPResource {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    server: string;
+    _meta?: MCPAppExtensionMetadata;
+}
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcSuccessResponse {
+    jsonrpc: "2.0";
+    id: number | string;
+    result: unknown;
+}
+interface JsonRpcErrorResponse {
+    jsonrpc: "2.0";
+    id: number | string;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface JsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}
+type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;
+interface MCPInitializeParams {
+    protocolVersion: string;
+    capabilities: {
+        roots?: {
+            listChanged?: boolean;
+        };
+        elicitation?: Record<string, unknown>;
+        sampling?: Record<string, unknown>;
+        tasks?: Record<string, unknown>;
+        experimental?: Record<string, unknown>;
+        extensions?: Record<string, unknown>;
+    };
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface MCPInitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: {
+            listChanged?: boolean;
+        };
+        resources?: {
+            subscribe?: boolean;
+            listChanged?: boolean;
+        };
+        prompts?: {
+            listChanged?: boolean;
+        };
+        logging?: Record<string, unknown>;
+        completions?: Record<string, unknown>;
+        tasks?: Record<string, unknown>;
+        experimental?: Record<string, unknown>;
+        extensions?: Record<string, unknown>;
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+    instructions?: string;
+}
+interface MCPToolsListResult {
+    tools: Array<{
+        name: string;
+        description?: string;
+        inputSchema: Record<string, unknown>;
+        _meta?: MCPAppExtensionMetadata;
+    }>;
+}
+interface MCPPromptsListResult {
+    prompts: Array<{
+        name: string;
+        description?: string;
+        arguments?: Array<{
+            name: string;
+            description?: string;
+            required?: boolean;
+        }>;
+    }>;
+}
+interface MCPPromptGetParams {
+    name: string;
+    arguments?: Record<string, string>;
+}
+interface MCPPromptGetResult {
+    description?: string;
+    messages: Array<{
+        role: "user" | "assistant" | "system";
+        content: string | {
+            type: "text" | "image" | "resource";
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        };
+    }>;
+}
+interface MCPResourcesListResult {
+    resources: Array<{
+        uri: string;
+        name?: string;
+        description?: string;
+        mimeType?: string;
+        _meta?: MCPAppExtensionMetadata;
+    }>;
+}
+interface MCPResourceReadParams {
+    uri: string;
+}
+interface MCPResourceReadResult {
+    contents: Array<{
+        uri: string;
+        mimeType?: string;
+        text?: string;
+        blob?: string;
+        _meta?: MCPAppExtensionMetadata;
+    }>;
+}
+interface MCPResourceSubscribeParams {
+    uri: string;
+}
+interface MCPResourceUnsubscribeParams {
+    uri: string;
+}
+interface MCPToolCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface MCPToolCallResult {
+    content: Array<{
+        type: "text" | "image" | "resource";
+        text?: string;
+        data?: string;
+        mimeType?: string;
+    }>;
+    isError?: boolean;
+    structuredContent?: Record<string, unknown>;
+    _meta?: Record<string, unknown>;
+}
+type MCPElicitationAction = "accept" | "decline" | "cancel";
+interface MCPElicitationRequest {
+    serverName: string;
+    message: string;
+    requestedSchema?: Record<string, unknown>;
+    params: Record<string, unknown>;
+}
+interface MCPElicitationResponse {
+    action: MCPElicitationAction;
+    content?: Record<string, unknown>;
+}
+type MCPElicitationHandler = (request: MCPElicitationRequest) => Promise<MCPElicitationResponse> | MCPElicitationResponse;
+type MCPBearerTokenResolver = (server: MCPServerConfig) => string | null | undefined | Promise<string | null | undefined>;
+interface MCPHttpAuthChallenge {
+    status: 401 | 403;
+    wwwAuthenticate?: string;
+    resourceMetadataUrl?: string;
+    error?: string;
+    errorDescription?: string;
+    scopes: string[];
+}
+type MCPBearerTokenRefreshHandler = (server: MCPServerConfig, challenge: MCPHttpAuthChallenge) => string | null | undefined | Promise<string | null | undefined>;
+interface MCPManagerOptions {
+    handleElicitation?: MCPElicitationHandler;
+    resolveBearerToken?: MCPBearerTokenResolver;
+    refreshBearerToken?: MCPBearerTokenRefreshHandler;
+    permissionProfile?: PermissionProfile;
+    fetch?: typeof globalThis.fetch;
+    appCapabilities?: MCPAppCapabilities | false;
+}
+interface MCPConfigFile {
+    mcpServers: Record<string, Omit<MCPServerConfig, "name" | "scope" | "sourcePath" | "approvalKey">>;
+}
+interface MCPConfiguredServer extends MCPServerConfig {
+    scope: Exclude<MCPServerScope, "session">;
+    sourcePath: string;
+    approvalKey: string;
+    approvalState?: MCPApprovalDecision;
+}
+interface ConnectConfiguredMCPServersOptions {
+    cwd: string;
+    promptForApproval?: (server: MCPConfiguredServer) => Promise<MCPApprovalDecision>;
+}
+interface ConnectConfiguredMCPServersResult {
+    connected: string[];
+    skipped: string[];
+    denied: string[];
+    errors: Array<{
+        name: string;
+        error: string;
+    }>;
+}
+interface MCPServerPromptRegistration {
+    name: string;
+    description?: string;
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+    get?: (args?: Record<string, string>) => Promise<MCPPromptGetResult> | MCPPromptGetResult;
+    result?: MCPPromptGetResult;
+}
+interface MCPServerResourceRegistration {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+    _meta?: MCPAppExtensionMetadata;
+    read?: () => Promise<MCPResourceReadResult> | MCPResourceReadResult;
+    result?: MCPResourceReadResult;
+}
+interface MCPServerModeOptions {
+    name?: string;
+    version?: string;
+    instructions?: string;
+    toolListChanged?: boolean;
+    prompts?: MCPServerPromptRegistration[];
+    resources?: MCPServerResourceRegistration[];
+    toolMetadata?: Record<string, MCPAppExtensionMetadata>;
+    appCapabilities?: MCPAppCapabilities | false;
+}
+type MCPServerChangeReason = "connected" | "disconnected" | "tools_changed" | "prompts_changed" | "resources_changed" | "resource_updated" | "error";
+interface MCPServerChangeEvent {
+    serverName: string;
+    reason: MCPServerChangeReason;
+    state: MCPServerState;
+    resourceUri?: string;
+}
+type MCPServerChangeListener = (event: MCPServerChangeEvent) => void | Promise<void>;
+declare class MCPManager {
+    private servers;
+    private nextRequestId;
+    private pendingRequests;
+    private disposed;
+    private changeListeners;
+    private readonly elicitationHandler?;
+    private readonly resolveBearerToken?;
+    private readonly refreshBearerToken?;
+    private readonly permissionProfile?;
+    private readonly fetcher?;
+    private readonly appCapabilities?;
+    constructor(options?: MCPManagerOptions);
+    onServerStateChanged(listener: MCPServerChangeListener): () => void;
+    addServer(config: MCPServerConfig): Promise<void>;
+    connectConfiguredServers(options: ConnectConfiguredMCPServersOptions): Promise<ConnectConfiguredMCPServersResult>;
+    removeServer(name: string): void;
+    listTools(serverName?: string): MCPTool[];
+    listAllTools(serverName?: string): MCPTool[];
+    listAppTools(serverName?: string): MCPTool[];
+    listPrompts(serverName?: string): MCPPrompt[];
+    listResources(serverName?: string): MCPResource[];
+    listServers(): MCPServerState[];
+    loadConfiguredServers(cwd?: string): MCPConfiguredServer[];
+    callTool(serverName: string, toolName: string, input: Record<string, unknown>): Promise<MCPToolCallResult>;
+    getPrompt(serverName: string, promptName: string, input?: Record<string, string>): Promise<MCPPromptGetResult>;
+    readResource(serverName: string, uri: string): Promise<MCPResourceReadResult>;
+    subscribeResource(serverName: string, uri: string): Promise<void>;
+    unsubscribeResource(serverName: string, uri: string): Promise<void>;
+    dispose(): void;
+    static loadConfigFile(cwd?: string): MCPServerConfig[];
+    static loadConfiguredServers(cwd?: string): MCPConfiguredServer[];
+    private createTransport;
+    private discoverServerState;
+    private refreshTools;
+    private refreshPrompts;
+    private refreshResources;
+    private listFromServers;
+    private getReadyServer;
+    private sendRequest;
+    private sendNotification;
+    private sendResponse;
+    private sendError;
+    private handleMessage;
+    private handleRequest;
+    private handleElicitationCreate;
+    private handleNotification;
+    private resolveApprovalDecision;
+    private emitServerStateChanged;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+        additionalProperties?: boolean | Record<string, unknown>;
+        [keyword: string]: unknown;
+    };
+}
+interface ImageUrlBlock {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+}
+interface ResourceContentBlock {
+    type: "resource";
+    uri?: string;
+    mimeType?: string;
+    text?: string;
+    data?: string;
+}
+type ToolAssistantContentBlock = TextBlock | ImageUrlBlock | ResourceContentBlock;
+type ToolOperationState = "registered" | "starting" | "running_foreground" | "running_background" | "waiting_for_input" | "stalled" | "verifying" | "completed" | "failed" | "timed_out" | "cancelled" | "orphaned";
+type ToolCompletionPolicy = "await" | "observe" | "detach";
+interface ExpectedOutputContract {
+    path: string;
+    kind?: "file" | "directory";
+    nonEmpty?: boolean;
+}
+interface ToolEvidence {
+    id: string;
+    kind: "artifact" | "process" | "verification";
+    status: "pending" | "verified" | "failed";
+    path?: string;
+    observedAt: string;
+    operationId: string;
+    detail?: Record<string, string | number | boolean | null>;
+}
+interface ToolOperationSnapshot {
+    schemaVersion: 1;
+    operationId: string;
+    turnId: string;
+    generation: number;
+    toolCallId: string;
+    toolName: string;
+    ownerSessionId?: string;
+    state: ToolOperationState;
+    terminal: boolean;
+    presentation: "foreground" | "background";
+    completionPolicy: ToolCompletionPolicy;
+    promotable: boolean;
+    processId?: string;
+    taskId?: string;
+    pid?: number;
+    commandFingerprint?: string;
+    outputPath?: string;
+    startedAt: string;
+    lastActivityAt: string;
+    deadlineAt?: string;
+    elapsedMs: number;
+    idleMs: number;
+    outputBytes: number;
+    nextOffset: number;
+    exitCode?: number | null;
+    completionReason?: string;
+    suggestedNextAction?: string;
+    expectedOutputs?: ExpectedOutputContract[];
+    evidence?: ToolEvidence[];
+}
+interface ToolProgressUpdate {
+    activity?: "stdout" | "stderr" | "input" | "waiting_for_input" | "heartbeat" | "state";
+    message?: string;
+    bytes?: number;
+    outputBytes?: number;
+    nextOffset?: number;
+}
+interface ToolAuthorizationReceipt {
+    turnId: string;
+    toolCallId: string;
+    toolName: string;
+    iteration: number;
+    policy: {
+        allowed: true;
+        reason: string;
+        temporaryOverride: boolean;
+    };
+    permission: {
+        allowed: true;
+        reason: string;
+    };
+}
+interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    errorCode?: string;
+    errorDetails?: Record<string, unknown>;
+    assistantContent?: ToolAssistantContentBlock[];
+    assistantOnlyContent?: ToolAssistantContentBlock[];
+    operation?: ToolOperationSnapshot;
+    evidence?: ToolEvidence[];
+    retryable?: boolean;
+}
+interface ToolExecutionContext {
+    signal?: AbortSignal;
+    operationId?: string;
+    reportProgress?: (event: ToolProgressUpdate) => void;
+    authorization?: ToolAuthorizationReceipt;
+}
+type ToolExecutor = (input: Record<string, unknown>, context?: ToolExecutionContext) => Promise<ToolResult>;
+interface ToolPolicyProjection {
+    observabilityInput: Record<string, unknown>;
+    permissionInput: Record<string, unknown>;
+    permissionPreview?: string;
+    approvalKey?: string;
+    riskLevel?: "low" | "medium" | "high";
+}
+interface RegisteredTool {
+    definition: ToolDefinition;
+    execute: ToolExecutor;
+    projectPolicyInput?: (input: Record<string, unknown>) => ToolPolicyProjection | {
+        error: ToolResult;
+    };
+}
+interface TextBlock {
+    type: "text";
+    text: string;
+}
+interface ToolRegistryOptions {
+    validateInputs?: boolean;
+    toolSchemaMode?: "all" | "demand";
+}
+declare class ToolRegistry {
+    private tools;
+    private compiledSchemas;
+    private changeListeners;
+    private aliasNames;
+    private validateInputs;
+    private readonly toolSchemaMode;
+    private readonly activatedDefinitions;
+    constructor(options?: ToolRegistryOptions);
+    setValidateInputs(enabled: boolean): this;
+    get inputValidationEnabled(): boolean;
+    get schemaLoadingMode(): "all" | "demand";
+    register(tool: RegisteredTool): void;
+    registerAlias(tool: RegisteredTool): void;
+    registerAll(tools: Iterable<RegisteredTool>): void;
+    unregister(name: string): boolean;
+    onChange(listener: () => void): () => void;
+    private emitChange;
+    get(name: string): RegisteredTool | undefined;
+    getDefinitions(): ToolDefinition[];
+    getDefinitionsForRequest(): ToolDefinition[];
+    getCapabilityCatalog(): string;
+    activateMatchingDefinitions(query: string, limit?: number): ToolDefinition[];
+    private static namespaceOf;
+    getDefinitionsByNamespace(namespace: string): ToolDefinition[];
+    listNamespaces(): string[];
+    execute(name: string, input: Record<string, unknown>, context?: ToolExecutionContext): Promise<ToolResult>;
+    listNames(): string[];
+    has(name: string): boolean;
+    projectPolicyInput(name: string, input: Record<string, unknown>): ToolPolicyProjection | {
+        error: ToolResult;
+    };
+    get size(): number;
+    private compileDefinition;
+    private assertDefinitionsExportable;
+}
+declare class MCPServer {
+    private toolRegistry;
+    private name;
+    private version;
+    private initialized;
+    private buffer;
+    private running;
+    private prompts;
+    private resources;
+    private instructions?;
+    private toolMetadata;
+    private appCapabilities?;
+    private resourceSubscriptions;
+    private unsubscribeToolRegistryChange?;
+    constructor(toolRegistry: ToolRegistry, options?: MCPServerModeOptions);
+    start(): void;
+    stop(): void;
+    get isRunning(): boolean;
+    private processBuffer;
+    private handleMessage;
+    private handleNotification;
+    private handleInitialize;
+    private handleToolsList;
+    private handlePromptsList;
+    private handlePromptGet;
+    private handleResourcesList;
+    private handleResourceRead;
+    private handleResourceSubscribe;
+    private handleResourceUnsubscribe;
+    private handleToolCall;
+    private sendResponse;
+    private sendError;
+    private writeMessage;
+    private validateAppRegistrations;
+    setPrompts(prompts: MCPServerPromptRegistration[]): void;
+    setResources(resources: MCPServerResourceRegistration[]): void;
+    notifyResourceUpdated(uri: string): void;
+    private notifyListChanged;
+}
+type MessageHandler$2 = (message: JsonRpcMessage) => void;
+type ErrorHandler$2 = (error: Error) => void;
+type CloseHandler$2 = (code: number | null) => void;
+interface MCPTransportConnection {
+    setMessageHandler(handler: MessageHandler$2): void;
+    setErrorHandler(handler: ErrorHandler$2): void;
+    setCloseHandler(handler: CloseHandler$2): void;
+    send(message: JsonRpcMessage): void | Promise<void>;
+    close(): void;
+    readonly isAlive: boolean;
+}
+declare class StdioTransport implements MCPTransportConnection {
+    private process;
+    private buffer;
+    private onMessage;
+    private onError;
+    private onClose;
+    private closed;
+    constructor(process: ChildProcess);
+    setMessageHandler(handler: MessageHandler$2): void;
+    setErrorHandler(handler: ErrorHandler$2): void;
+    setCloseHandler(handler: CloseHandler$2): void;
+    send(message: JsonRpcMessage): void;
+    close(): void;
+    get isAlive(): boolean;
+    private setupListeners;
+    private processBuffer;
+}
+type MessageHandler$1 = (message: JsonRpcMessage) => void;
+type ErrorHandler$1 = (error: Error) => void;
+type CloseHandler$1 = (code: number | null) => void;
+interface SSETransportOptions {
+    validateUrl?: (url: string, phase: "stream" | "post") => void;
+}
+declare class SSETransport implements MCPTransportConnection {
+    private readonly url;
+    private readonly headers?;
+    private readonly options;
+    private onMessage;
+    private onError;
+    private onClose;
+    private closed;
+    private buffer;
+    private eventName;
+    private dataLines;
+    private endpointUrl?;
+    private readonly streamAbortController;
+    private readonly readyPromise;
+    private endpointResolver;
+    private readonly endpointPromise;
+    constructor(url: string, headers?: Record<string, string> | undefined, options?: SSETransportOptions);
+    waitUntilReady(): Promise<void>;
+    setMessageHandler(handler: MessageHandler$1): void;
+    setErrorHandler(handler: ErrorHandler$1): void;
+    setCloseHandler(handler: CloseHandler$1): void;
+    send(message: JsonRpcMessage): Promise<void>;
+    close(): void;
+    get isAlive(): boolean;
+    private connect;
+    private consumeStream;
+    private processBuffer;
+    private dispatchEvent;
+    private resolvePostUrl;
+}
+type MessageHandler = (message: JsonRpcMessage) => void;
+type ErrorHandler = (error: Error) => void;
+type CloseHandler = (code: number | null) => void;
+type MCPHttpUrlPhase = "post" | "stream" | "resume" | "delete" | "redirect";
+interface StreamableHTTPTransportOptions {
+    headers?: Record<string, string>;
+    resolveHeaders?: () => Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
+    handleAuthChallenge?: (challenge: MCPHttpAuthChallenge) => Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
+    validateUrl?: (url: string, phase: MCPHttpUrlPhase) => void | Promise<void>;
+    fetch?: typeof globalThis.fetch;
+    protocolVersion?: string;
+    legacySseFallback?: boolean;
+    allowInsecureRemoteHttp?: boolean;
+    allowCrossOriginRedirects?: boolean;
+    maxRedirects?: number;
+    maxResponseBytes?: number;
+    defaultReconnectDelayMs?: number;
+}
+interface StreamableHTTPTransportSnapshot {
+    mode: "streamable-http" | "legacy-sse";
+    sessionId?: string;
+    protocolVersion: string;
+    lastEventId?: string;
+    receiveLoopActive: boolean;
+}
+declare class MCPHttpTransportError extends Error {
+    readonly status?: number | undefined;
+    readonly challenge?: MCPHttpAuthChallenge | undefined;
+    constructor(message: string, status?: number | undefined, challenge?: MCPHttpAuthChallenge | undefined);
+}
+declare class StreamableHTTPTransport implements MCPTransportConnection {
+    private readonly options;
+    private onMessage;
+    private onError;
+    private onClose;
+    private readonly fetcher;
+    private readonly abortController;
+    private readonly endpoint;
+    private readonly maxRedirects;
+    private readonly maxResponseBytes;
+    private readonly defaultReconnectDelayMs;
+    private closed;
+    private legacy?;
+    private sessionId?;
+    private protocolVersion;
+    private initializeRequest?;
+    private sessionExpired;
+    private lastEventId?;
+    private retryMs?;
+    private receiveLoopPromise?;
+    private receiveLoopActive;
+    private reinitializePromise?;
+    private challengeHeaders?;
+    private readonly seenEventIds;
+    constructor(url: string, options?: StreamableHTTPTransportOptions);
+    setMessageHandler(handler: MessageHandler): void;
+    setErrorHandler(handler: ErrorHandler): void;
+    setCloseHandler(handler: CloseHandler): void;
+    send(message: JsonRpcMessage): Promise<void>;
+    close(): void;
+    get isAlive(): boolean;
+    get snapshot(): StreamableHTTPTransportSnapshot;
+    private postMessage;
+    private reinitialize;
+    private startReceiveLoop;
+    private runReceiveLoop;
+    private consumeSse;
+    private activateLegacySse;
+    private fetchEndpoint;
+    private readJsonMessage;
+    private captureSessionHeader;
+    private captureProtocolVersion;
+    private resolveHeaders;
+    private assertUrl;
+    private rememberEventId;
+    private deleteSessionBestEffort;
+}
+declare const MCP_PROTOCOL_VERSION: "2025-11-25";
+declare const MCP_SUPPORTED_PROTOCOL_VERSIONS: readonly [
+    "2025-11-25",
+    "2025-06-18",
+    "2025-03-26",
+    "2024-11-05"
+];
+type MCPSupportedProtocolVersion = typeof MCP_SUPPORTED_PROTOCOL_VERSIONS[number];
+declare function isSupportedMcpProtocolVersion(value: string): value is MCPSupportedProtocolVersion;
+declare function assertSupportedMcpProtocolVersion(value: string): MCPSupportedProtocolVersion;
+type MCPOAuthUrlPhase = "protected-resource-metadata" | "authorization-server-metadata" | "client-registration" | "authorization" | "token" | "redirect";
+interface MCPOAuthProtectedResourceMetadata {
+    resource?: string;
+    authorizationServers: string[];
+    scopesSupported: string[];
+    bearerMethodsSupported: string[];
+    resourceName?: string;
+    raw: Record<string, unknown>;
+}
+interface MCPOAuthAuthorizationServerMetadata {
+    issuer: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    registrationEndpoint?: string;
+    deviceAuthorizationEndpoint?: string;
+    codeChallengeMethodsSupported: string[];
+    scopesSupported: string[];
+    clientIdMetadataDocumentSupported: boolean;
+    raw: Record<string, unknown>;
+}
+type MCPOAuthClientRegistrationSource = "pre-registered" | "client-id-metadata-document" | "dynamic";
+interface MCPOAuthClientRegistration {
+    clientId: string;
+    clientSecret?: string;
+    clientIdIssuedAt?: number;
+    clientSecretExpiresAt?: number;
+    tokenEndpointAuthMethod?: string;
+    source: MCPOAuthClientRegistrationSource;
+}
+interface MCPOAuthDiscoveryResult {
+    resource: string;
+    protectedResourceMetadata?: MCPOAuthProtectedResourceMetadata;
+    protectedResourceMetadataUrl?: string;
+    authorizationServer: string;
+    authorizationServerMetadata: MCPOAuthAuthorizationServerMetadata;
+    authorizationServerMetadataUrl: string;
+    scopes: string[];
+    challenge?: MCPHttpAuthChallenge;
+}
+interface MCPOAuthAuthorizationSession {
+    authorizationUrl: string;
+    state: string;
+    codeVerifier: string;
+    redirectUri: string;
+    resource: string;
+    scopes: string[];
+    discovery: MCPOAuthDiscoveryResult;
+    registration: MCPOAuthClientRegistration;
+}
+interface MCPOAuthTokenSet {
+    accessToken: string;
+    tokenType: string;
+    expiresAt?: string;
+    refreshToken?: string;
+    scope?: string;
+    resource: string;
+    authorizationServer: string;
+    clientId: string;
+    clientSecret?: string;
+    tokenEndpointAuthMethod?: string;
+}
+interface MCPOAuthTokenStore {
+    get(resource: string): MCPOAuthTokenSet | null | Promise<MCPOAuthTokenSet | null>;
+    set(resource: string, token: MCPOAuthTokenSet): void | Promise<void>;
+    delete(resource: string): boolean | void | Promise<boolean | void>;
+}
+interface MCPOAuthClientOptions {
+    resource: string;
+    protectedResourceMetadataUrl?: string;
+    authorizationServerMetadataUrl?: string;
+    scopes?: string[];
+    clientId?: string;
+    clientSecret?: string;
+    clientMetadataUrl?: string;
+    clientName?: string;
+    clientUri?: string;
+    allowDynamicRegistration?: boolean;
+    fetch?: typeof globalThis.fetch;
+    validateUrl?: (url: string, phase: MCPOAuthUrlPhase) => void | Promise<void>;
+    selectAuthorizationServer?: (servers: string[]) => string | Promise<string>;
+    allowInsecureLoopback?: boolean;
+    maxMetadataBytes?: number;
+    maxRedirects?: number;
+    now?: () => Date;
+}
+interface PrepareMCPOAuthAuthorizationOptions {
+    redirectUri: string;
+    scopes?: string[];
+    challenge?: string | MCPHttpAuthChallenge;
+    prompt?: string;
+}
+interface ExchangeMCPOAuthCodeOptions {
+    code: string;
+    returnedState: string;
+}
+declare function canonicalizeMcpResourceUri(input: string): string;
+declare function parseMcpWwwAuthenticate(value: string | null | undefined): MCPHttpAuthChallenge | undefined;
+declare function getMcpProtectedResourceMetadataUrls(resource: string): string[];
+declare function getMcpAuthorizationServerMetadataUrls(issuer: string): string[];
+declare function createMcpPkcePair(): {
+    verifier: string;
+    challenge: string;
+};
+declare function isMcpOAuthTokenExpired(token: Pick<MCPOAuthTokenSet, "expiresAt">, now?: Date, skewMs?: number): boolean;
+declare class MCPOAuthClient {
+    private readonly options;
+    private readonly resource;
+    private readonly fetcher;
+    private readonly maxMetadataBytes;
+    private readonly maxRedirects;
+    constructor(options: MCPOAuthClientOptions);
+    discover(challengeInput?: string | MCPHttpAuthChallenge): Promise<MCPOAuthDiscoveryResult>;
+    prepareAuthorization(input: PrepareMCPOAuthAuthorizationOptions): Promise<MCPOAuthAuthorizationSession>;
+    exchangeAuthorizationCode(session: MCPOAuthAuthorizationSession, input: ExchangeMCPOAuthCodeOptions): Promise<MCPOAuthTokenSet>;
+    refresh(token: MCPOAuthTokenSet, scopes?: string[]): Promise<MCPOAuthTokenSet>;
+    private resolveRegistration;
+    private postToken;
+    private tokenSet;
+    private firstJson;
+    private fetchJson;
+    private requestJson;
+    private request;
+    private assertUrl;
+}
+type PersistentMcpScope = Exclude<MCPServerScope, "session">;
+declare function loadMcpConfigFile(configPath: string, scope?: PersistentMcpScope): MCPConfigFile;
+declare function saveMcpConfigFile(configPath: string, config: MCPConfigFile, scope?: PersistentMcpScope): void;
+declare function loadConfiguredMcpServers(cwd?: string): MCPConfiguredServer[];
+declare function upsertMcpServerConfig(scope: PersistentMcpScope, cwd: string | undefined, config: MCPServerConfig): string;
+declare function removeMcpServerConfig(scope: PersistentMcpScope, cwd: string | undefined, name: string): string;
+declare function approveMcpServer(cwd: string, approvalKey: string): void;
+declare function denyMcpServer(cwd: string, approvalKey: string): void;
+declare function clearMcpServerApproval(cwd: string, approvalKey: string): void;
+declare function getMcpApprovalDecision(cwd: string, approvalKey: string): MCPApprovalDecision | undefined;
+declare function resetMcpServerApprovals(cwd: string, scope?: PersistentMcpScope): number;
+type MCPRegistryEntryKind = "tool" | "prompt" | "resource";
+type MCPRegistryAccessPolicy = "none" | "prompts" | "resources" | "context" | "all";
+interface MCPRegistryEntryDescriptor {
+    kind: MCPRegistryEntryKind;
+    server: string;
+    name: string;
+    description?: string;
+    uri?: string;
+}
+type MCPRegistryFilter = (entry: MCPRegistryEntryDescriptor) => boolean;
+declare function matchesMcpRegistryEntryPolicy(entry: MCPRegistryEntryDescriptor, policy: MCPRegistryAccessPolicy): boolean;
+declare function getMcpToolName(serverName: string, toolName: string): string;
+declare function getMcpPromptToolName(serverName: string, promptName: string): string;
+declare function getMcpResourceToolName(serverName: string, resource: MCPResource): string;
+declare function createMcpRegisteredTool(manager: MCPManager, tool: MCPTool): RegisteredTool;
+declare function createMcpPromptRegisteredTool(manager: MCPManager, prompt: MCPPrompt): RegisteredTool;
+declare function createMcpResourceRegisteredTool(manager: MCPManager, resource: MCPResource): RegisteredTool;
+declare function syncMcpToolsToRegistry(manager: MCPManager, registry: ToolRegistry, previouslyRegistered?: string[], filter?: MCPRegistryFilter): string[];
+export { type ConnectConfiguredMCPServersOptions, type ConnectConfiguredMCPServersResult, type ExchangeMCPOAuthCodeOptions, type JsonRpcErrorResponse, type JsonRpcMessage, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type JsonRpcSuccessResponse, type MCPAppCapabilities, type MCPAppContentSecurityPolicy, type MCPAppExtensionMetadata, type MCPAppMetadata, type MCPAppPermissions, type MCPAppResourceDescriptor, type MCPAppValidationResult, type MCPAppVisibility, type MCPApprovalDecision, type MCPBearerTokenRefreshHandler, type MCPBearerTokenResolver, type MCPConfigFile, type MCPConfiguredServer, type MCPElicitationAction, type MCPElicitationHandler, type MCPElicitationRequest, type MCPElicitationResponse, type MCPHttpAuthChallenge, MCPHttpTransportError, type MCPHttpUrlPhase, type MCPInitializeParams, type MCPInitializeResult, MCPManager, type MCPManagerOptions, type MCPOAuthAuthorizationServerMetadata, type MCPOAuthAuthorizationSession, MCPOAuthClient, type MCPOAuthClientOptions, type MCPOAuthClientRegistration, type MCPOAuthClientRegistrationSource, type MCPOAuthConfig, type MCPOAuthDiscoveryResult, type MCPOAuthProtectedResourceMetadata, type MCPOAuthTokenSet, type MCPOAuthTokenStore, type MCPOAuthUrlPhase, type MCPPrompt, type MCPPromptGetParams, type MCPPromptGetResult, type MCPPromptsListResult, type MCPRegistryAccessPolicy, type MCPRegistryEntryDescriptor, type MCPRegistryEntryKind, type MCPRegistryFilter, type MCPResource, type MCPResourceReadParams, type MCPResourceReadResult, type MCPResourceSubscribeParams, type MCPResourceUnsubscribeParams, type MCPResourcesListResult, MCPServer, type MCPServerConfig, type MCPServerModeOptions, type MCPServerPromptRegistration, type MCPServerResourceRegistration, type MCPServerScope, type MCPServerState, type MCPTool, type MCPToolCallParams, type MCPToolCallResult, type MCPToolsListResult, type MCPTransport, type MCPTransportConnection, MCP_APPS_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_SCHEME, MCP_PROTOCOL_VERSION, MCP_SUPPORTED_PROTOCOL_VERSIONS, type PrepareMCPOAuthAuthorizationOptions, SSETransport, StdioTransport, StreamableHTTPTransport, type StreamableHTTPTransportOptions, type StreamableHTTPTransportSnapshot, approveMcpServer, assertSupportedMcpProtocolVersion, assertValidMcpAppResource, canonicalizeMcpResourceUri, clearMcpServerApproval, createMcpAppCapabilities, createMcpAppExtensionCapabilities, createMcpPkcePair, createMcpPromptRegisteredTool, createMcpRegisteredTool, createMcpResourceRegisteredTool, denyMcpServer, getMcpAppMetadata, getMcpAppResourceUri, getMcpApprovalDecision, getMcpAuthorizationServerMetadataUrls, getMcpPromptToolName, getMcpProtectedResourceMetadataUrls, getMcpResourceToolName, getMcpToolName, isMcpAppResourceUri, isMcpOAuthTokenExpired, isMcpToolVisibleToApp, isMcpToolVisibleToModel, isSupportedMcpProtocolVersion, loadConfiguredMcpServers, loadMcpConfigFile, matchesMcpRegistryEntryPolicy, normalizeMcpAppVisibility, parseMcpWwwAuthenticate, removeMcpServerConfig, resetMcpServerApprovals, saveMcpConfigFile, syncMcpToolsToRegistry, upsertMcpServerConfig, validateMcpAppResource };