import type { RiskDecision } from "../safety/classifier.js";
import type { ToolDefinition, ToolResult } from "../types.js";
import { McpManager, type McpManagerOptions } from "./manager.js";
import type { OAuthConsentInfo } from "./auth/provider.js";
import type { McpSnapshot, McpToolMetadata } from "./types.js";
export type McpRuntimeSelection = {
    readonly mode: "all";
} | {
    readonly mode: "off";
} | {
    readonly mode: "servers";
    readonly serverNames: readonly string[];
};
export type McpBaseSelection = {
    readonly mode: "all";
} | {
    readonly mode: "off";
};
export interface McpRuntimeState {
    readonly snapshot: McpSnapshot;
    readonly selection: McpRuntimeSelection;
    readonly refreshing: boolean;
    readonly activeToolCount: number;
    readonly catalogSignature: string;
    readonly error?: string | undefined;
}
export interface McpRuntimeOptions {
    readonly manager?: McpManager | undefined;
    readonly managerOptions?: McpManagerOptions | undefined;
    readonly openBrowser?: ((url: string) => Promise<void>) | undefined;
    readonly requestOAuthConsent?: ((info: OAuthConsentInfo) => Promise<boolean>) | undefined;
    readonly oauthInteractive?: boolean | undefined;
    readonly onDeviceAuthorization?: McpManagerOptions["onDeviceAuthorization"];
    readonly onAuthorizationUrl?: McpManagerOptions["onAuthorizationUrl"];
}
export declare function mcpSelectionLabel(selection: McpRuntimeSelection): string;
export interface McpTurnLease {
    release(): void;
}
export declare class McpRuntime {
    private readonly manager;
    private readonly listeners;
    private refreshPromise;
    private started;
    private closed;
    private state;
    private base;
    private readonly leases;
    private readonly unregisterDispatcher;
    constructor(options?: McpRuntimeOptions);
    readonly subscribe: (listener: () => void) => (() => void);
    readonly getState: () => McpRuntimeState;
    private emit;
    private publish;
    private registerSnapshotTools;
    start(): Promise<McpRuntimeState>;
    ensureReady(): Promise<McpRuntimeState>;
    refresh(options?: {
        force?: boolean;
    }): Promise<McpRuntimeState>;
    reconnect(serverName: string): Promise<McpRuntimeState>;
    private selectionWithout;
    isStopped(serverName: string): boolean;
    stopServer(serverName: string): Promise<McpRuntimeState>;
    private adoptSelectionInLeases;
    selectAll(): McpRuntimeState;
    selectOff(): McpRuntimeState;
    serverNames(): ReadonlySet<string>;
    selectServers(serverNames: readonly string[]): McpRuntimeState;
    selectServer(serverName: string): McpRuntimeState;
    applyMentionSelection(text: string): McpRuntimeState;
    beginTurn(): McpTurnLease;
    private liveView;
    private view;
    private views;
    toolDefinitions(options?: {
        askMode?: boolean;
    }): ToolDefinition[];
    toolNames(options?: {
        askMode?: boolean;
    }): string[];
    private resolveMetadata;
    getTool(name: string, options?: {
        includeUnselected?: boolean;
    }): McpToolMetadata | undefined;
    unavailableToolMessage(name: string): string;
    canonicalizeToolName(name: string): string;
    classify(name: string): RiskDecision | undefined;
    isParallelSafe(name: string): boolean;
    private secretsFor;
    private normalizeResult;
    callTool(name: string, args: Record<string, unknown>, options?: {
        signal?: AbortSignal | undefined;
        timeoutMs?: number | undefined;
    }): Promise<ToolResult>;
    agentList(): Promise<ToolResult>;
    agentTools(server?: string): Promise<ToolResult>;
    private enabledSummary;
    agentEnable(target?: string | readonly string[]): Promise<ToolResult>;
    agentConnect(serverName: string): Promise<ToolResult>;
    agentAdd(options: {
        name?: string;
        json?: string;
    }): Promise<ToolResult>;
    agentLogin(serverName: string): Promise<ToolResult>;
    canLogin(serverName: string): boolean;
    promptContext(options: {
        nativeTools: boolean;
        askMode?: boolean;
    }): string | undefined;
    statusLabel(): string | undefined;
    closeAll(): Promise<void>;
}