import { EventEmitter } from "node:events";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
import { type JsonObject, type ToolPermissionPolicy } from "./built-in-file-tools.js";
import type { ACodeRuntimeConfig } from "./types.js";
export interface ACodeMcpConnection {
    serverName: string;
    client: Client;
    transport: Transport;
    tools: ACodeMcpTool[];
}
interface ACodeMcpTool {
    kind: "mcp";
    serverName: string;
    toolName: string;
    exposedName: string;
    description?: string;
    inputSchema: JsonObject;
}
export declare class ACodeRuntime extends EventEmitter {
    private readonly config;
    private readonly hookBus;
    private initialConversation;
    private state;
    private abortController;
    
    private exposedToolsInitialized;
    
    private readonly pendingMemorySubAgents;
    
    private readonly memoryDelegateCooldownUntil;
    private submitQueue;
    
    private activeTurnToken;
    
    private readonly forceSettleWaiters;
    
    private abortForceSettleTimer;
    private activeTurn;
    
    private forceMessagePending;
    private abortRequested;
    
    private toolSettleSlot;
    private toolSettleSeq;
    
    private pendingAwaitedSubIds;
    
    private pendingAwaitedBgTaskIds;
    private sessionCompleteEmitted;
    private contextVersion;
    
    private lastIterationUsage;
    private readonly stopWaiters;
    
    private compactionDebugTimer;
    
    private skillTool;
    
    private skillWatchers;
    
    private skillRefreshTimer;
    
    private static readonly SKILL_REFRESH_DEBOUNCE_MS;
    
    private readonly questionWaiters;
    constructor(config: ACodeRuntimeConfig);
    
    getAvailableTools(): string[];
    private emitAcodeEvent;
    
    private emitCompactionPhase;
    
    private handleCompactionPhase;
    
    start(): Promise<void>;
    
    private loadAllSkills;
    
    private startSkillWatchers;
    
    private scheduleSkillRefresh;
    
    private refreshSkills;
    
    private stopSkillWatchers;
    
    private startCompactionDebugLog;
    
    private stopCompactionDebugLog;
    
    submit(message: string): Promise<void>;
    
    private executeSubmitGuarded;
    
    private armAbortForceSettle;
    
    private forceSettleActiveTurn;
    
    notifyForceMessage(): void;
    
    addBuiltInTools(tools: unknown[]): number;
    
    removeBuiltInToolsByPrefix(prefix: string): number;
    
    addPluginCommands(commands: import("./types.js").ACodeCommandSpec[]): void;
    
    private emitExposedToolsStatus;
    
    private injectForceMessage;
    
    resetContext(): Promise<void>;
    private isTurnSuperseded;
    private executeSubmit;
    
    abort(): Promise<void>;
    
    private buildAskUserQuestionDeps;
    
    private buildAllocatableToolList;
    
    private buildSubAgentToolDeps;
    
    private buildAwaitCompleteDeps;
    
    submitQuestionAnswer(toolCallId: string, answers: Record<string, string>): boolean;
    
    private rejectAllQuestionWaiters;
    
    private readonly permissionWaiters;
    
    private createToolPermissionController;
    
    private requestToolPermission;
    
    submitToolPermissionDecision(requestId: string, allowed: boolean): boolean;
    
    private rejectAllPermissionWaiters;
    
    setToolPermissionPolicy(policy: Partial<ToolPermissionPolicy>): void;
    
    private cancelPendingAwaitedSubAgents;
    
    private cancelPendingAwaitedBgTasks;
    
    detachCurrentToolExecution(): boolean;
    
    private beginToolSettle;
    
    private clearToolSettle;
    
    stop(): Promise<void>;
    
    private discoverPluginCommandDirs;
    private resolveCommandDirs;
    private runModelTurn;
    
    private summarizeConversationWithLLM;
    private requestChatCompletion;
    private readChatCompletionStream;
    private handleToolCalls;
    private callMcpToolWithTimeout;
    
    private static formatSubAgentCompletionAsPollResult;
    
    private static mergeSubAgentCompletionsIntoMcpResult;
    
    private recheckMemoryDelegate;
    
    private readMemoryViaMcp;
    
    private recheckMemoryFileChange;
    
    private recheckMemoryExpiration;
    
    private recheckMemoryCleanup;
    
    private buildMemoryDelegatePrompt;
    
    private processMemoryAutoDelegates;
    
    private callPollMessageWithSubAgentRace;
    
    private summarizePollResultForDebug;
    
    private pollResultHasMessages;
    
    private waitForDelegateRepoll;
    
    private createRuntimeStopWaiter;
    
    private notifyRuntimeStop;
    private appendSyntheticMultimodalUserMessage;
    
    private expandCommandsInPolledResult;
    
    private cleanToolMessageAttachments;
    private appendToolFailureResult;
    
    private filterSharedMcpConnectionsForSubAgent;
    private connectMcpServers;
    
    requestMcpToolsRefresh(serverName?: string): void;
    
    private refreshMcpConnectionTools;
    
    private recoverHiddenMcpTool;
    
    private recoveredToolNames;
    
    private static readonly MAX_RECOVERY_ATTEMPTS;
    private createMcpTransport;
    
    private fetchProfilePrompt;
    
    private extractProfileFromToolResult;
    private disconnectMcpServers;
}
export {};