import { EventEmitter } from "node:events";
import type { SubAgentManager, TerminalManager } from "@agentswork/acode";
import { type FeatureState } from "../services/instance-features.js";
import type { AdapterSessionConfig, BaseProviderAdapter, ConversationMessage, RuntimeCapabilities, SessionStatus } from "./types.js";
type ACodeEvent = {
    type: string;
    sessionId: string;
    timestamp: string;
    data: Record<string, unknown>;
};
type ACodeRuntimeInstance = {
    on(eventName: "event", listener: (event: ACodeEvent) => void): void;
    start(): Promise<void>;
    submit(message: string): Promise<void>;
    abort(): Promise<void>;
    resetContext?(): Promise<void>;
    stop(): Promise<void>;
    
    submitQuestionAnswer?(toolCallId: string, answers: Record<string, string>): boolean;
    
    detachCurrentToolExecution?(): boolean;
    
    notifyForceMessage?(): void;
    
    addBuiltInTools?(tools: unknown[]): number;
    
    removeBuiltInToolsByPrefix?(prefix: string): number;
    
    requestMcpToolsRefresh?(serverName?: string): void;
    
    setToolPermissionPolicy?(policy: unknown): void;
    
    submitToolPermissionDecision?(requestId: string, allowed: boolean): boolean;
    
    addPluginCommands?(commands: unknown[]): void;
};
type ACodeRuntimeConstructor = new (config: {
    sessionId: string;
    agentId?: string;
    workingDirectory: string;
    configPath?: string;
    skillsDir?: string;
    pluginsDir?: string;
    initialPrompt?: string;
    model?: string;
    systemPrompt?: string;
    globalPrompt?: string;
    rolePrompt?: string;
    memory?: string;
    env?: Record<string, string>;
    subAgentManager?: SubAgentManager;
    
    terminalManager?: TerminalManager;
    
    pluginBridge?: unknown;
    
    commandDirs?: string[];
    
    toolPermissionPolicy?: unknown;
    onFileChange?: (record: {
        filePath: string;
        operation: "CREATE" | "UPDATE" | "DELETE";
        beforeContent: string | null;
        afterContent: string | null;
    }) => void | Promise<void>;
    
    extraBuiltInTools?: unknown[];
    
    subAgentSuiteTools?: unknown[];
    
    subAgentSuiteToolProvider?: (patterns: string[]) => Promise<unknown[]>;
    
    capabilityState?: (featureKey: string) => FeatureState;
}) => ACodeRuntimeInstance;
export declare function toAcodeEsmImportSpecifier(modulePath: string): string;

export declare function isFailedAcodeTurnComplete(data: Record<string, unknown>): boolean;
export declare class AcodeSdkAdapter extends EventEmitter implements BaseProviderAdapter {
    readonly providerId = "acode";
    readonly displayName = "ACode";
    private sessions;
    
    private expandedBuiltInCapabilities;
    
    private dispatchableCapabilityTools;
    
    private listenerWakeHooks;
    private runtimeConstructor?;
    constructor();
    private syncPluginCommands;
    startSession(sessionId: string, config: AdapterSessionConfig): Promise<void>;
    sendMessage(sessionId: string, message: string): Promise<void>;
    sendConfirmation(_sessionId: string, _accept: boolean): Promise<void>;
    
    submitToolPermissionDecision(sessionId: string, requestId: string, allowed: boolean): boolean;
    
    getPendingToolAuthRequests(sessionId: string): Array<{
        requestId: string;
        capability: string;
        detail: Record<string, unknown>;
        requestedAt: number;
    }>;
    
    sendQuestionAnswer(sessionId: string, answers: Record<string, string>): Promise<void>;
    abortCurrentTurn(sessionId: string): Promise<void>;
    resetContext(sessionId: string): Promise<void>;
    terminateSession(sessionId: string): Promise<void>;
    getConversation(sessionId: string): ConversationMessage[];
    hasSession(sessionId: string): boolean;
    getProviderSessionId(sessionId: string): string | undefined;
    getSessionStatus(sessionId: string): SessionStatus | undefined;
    
    notifyForceMessage(sessionId: string): boolean;
    
    getCapabilities(sessionId: string): RuntimeCapabilities | undefined;
    
    private resolveAgentAiInfo;
    
    
    private resolveAgentSkillsDir;
    applyAgentFeatures(agentId: string): Promise<void>;
    
    private syncMcpToolsForAgent;
    
    setBuiltInCapabilityTools(agentId: string, capability: string, action: "expand" | "collapse"): Promise<{
        sessions: number;
        tools: number;
        manifests?: Array<{
            name: string;
            description?: string;
            inputSchema?: unknown;
        }>;
    }>;
    
    callBuiltInCapabilityTool(agentId: string, capability: string, toolName: string, args: Record<string, unknown>): Promise<{
        ok: boolean;
        result?: unknown;
        error?: string;
    }>;
    
    private pruneDispatchableCapabilityTools;
    
    private shouldInjectCapabilityTools;
    
    getPendingQuestion(sessionId: string): {
        toolCallId: string;
        questions: unknown[];
    } | undefined;
    cleanup(): void;
    setIdleCommands(sessionId: string, commands: {
        idleInputCommand: string;
        nonInputCommand: string;
    }): void;
    
    setRuntimeConstructorForTest(runtimeConstructor: ACodeRuntimeConstructor): void;
    
    
    private loadAcodeProviderSection;
    
    private resolveAcodeProvider;
    private createRuntime;
    
    private buildSubAgentSuiteToolProvider;
    private loadRuntimeConstructor;
    private requireSession;
    
    private startInitialPromptTurn;
    private forwardAcodeEvent;
    private emitProviderEvent;
    
    private armIdleLoopOrAutoPoll;
    private getIdlePollLoop;
    private submitAutoPollPrompt;
    
    private scheduleAutoPoll;
    private cancelScheduledAutoPoll;
    
    private scheduleRequestRetry;
    
    private retryFailedRequest;
    
    private cancelRequestRetry;
    private isTerminalStatus;
    private emitRuntimeErrorEvent;
    
    private estimateOutputTokensFromMessages;
    private recoverTurnFailure;
    
    private recoverResolvedTurnWithoutTerminalEvent;
    
    private startSubmitTimeoutDetection;
    
    private executeWatchdogRecovery;
    
    private cancelSubmitTimeoutDetection;
    
    private resetDataFlowWatchdog;
    
    private startDataFlowWatchdog;
    
    private cancelDataFlowWatchdog;
    
    private formatAiRequestActionDetail;
}
export {};