import { EventEmitter } from "node:events";
export type SessionStatus = "starting" | "thinking" | "tool_using" | "waiting_input" | "completed" | "terminated" | "error" | "compacting";
export type ProviderEventType = "ai_request" | "text_delta" | "thinking" | "command_output" | "tool_use_start" | "tool_use_end" | "permission_request" | "ask_user_question" | "exit_plan_mode" | "turn_complete" | "session_complete" | "error" | "context_compaction" | "runtime_capabilities" | "background_command_completed";

export type ToolActionType = "skill" | "mcp" | "idle" | "edit_file" | "write_file" | "read_file" | "bash" | "search" | "web" | "ai_request" | "lsp" | "notebook" | "other" | "context_compaction" | "runtime_capabilities" | "background_command";

export interface ToolActionInfo {
    
    actionType: ToolActionType;
    
    actionLabel: string;
    
    actionDetail?: string;
}

export interface ToolMetadata {
    
    mcpServer?: string;
    
    [key: string]: unknown;
}

export declare function redactTransientClipboardPastePaths(text: string): string;

export declare function isTransientClipboardPasteFilePath(text: string): boolean;

export declare function redactTransientClipboardPastePathsInValue(value: unknown): unknown;
export declare function getCanonicalMcpDetail(rawToolName: string): string;

export declare function getToolActionInfo(toolName: string | undefined, toolInput?: Record<string, unknown>, metadata?: ToolMetadata): ToolActionInfo;
export interface RuntimeTokenUsage {
    inputTokens: number;
    outputTokens: number;
    
    contextLimit?: number;
    
    maxOutput?: number;
    
    inputLimit?: number;
    
    compactionThreshold?: number;
    
    cacheHitTokens?: number;
    
    cacheMissTokens?: number;
}
export type CommandOutputStream = "stdout" | "stderr" | "mixed";
export interface RuntimeStatusActionInfo {
    actionType?: ToolActionType;
    actionLabel?: string;
    actionDetail?: string;
    
    actionInput?: string;
    actionResult?: string;
    actionId?: string;
    
    parentId?: string;
    usage?: RuntimeTokenUsage;
}
export interface ProviderEvent {
    type: ProviderEventType;
    sessionId: string;
    timestamp: string;
    data: {
        
        text?: string;
        
        model?: string;
        
        endpoint?: string;
        
        requestMethod?: string;
        
        requestUrl?: string;
        
        requestHeaders?: Record<string, string>;
        
        stream?: boolean | CommandOutputStream;
        
        messageCount?: number;
        
        toolCount?: number;
        
        lastUserMessagePreview?: string;
        
        requestBody?: string;
        
        toolName?: string;
        
        rawToolName?: string;
        
        toolInput?: Record<string, unknown>;
        
        toolResult?: string;
        
        isError?: boolean;
        
        usage?: RuntimeTokenUsage;
        
        responseBody?: string;
        
        finishReason?: string;
        
        exitCode?: number;
        
        permissionPrompt?: string;
        
        toolUseId?: string;
        
        questions?: Array<{
            question: string;
            header?: string;
            options?: Array<{
                label: string;
                description?: string;
            }>;
            multiple?: boolean;
        }>;
        
        actionType?: ToolActionType;
        
        actionLabel?: string;
        
        actionDetail?: string;
        
        actionId?: string;
        
        parentId?: string;
        
        actionResult?: string;
        
        sequence?: number;
        
        cwd?: string;
        
        commandFilePath?: string;
        
        commandLineCount?: number;
        
        capabilities?: RuntimeCapabilities;
    };
}

export interface RuntimeSkillGroup {
    
    dir: string;
    
    exists: boolean;
    
    skills: Array<{
        name: string;
        description?: string;
        directory?: string;
    }>;
}
export interface RuntimeCapabilities {
    
    kind: "mcp" | "skill" | "combined";
    
    mcpServers?: string[];
    
    mcpTools?: Array<{
        name: string;
        source: string;
        description?: string;
    }>;
    
    skills?: Array<{
        name: string;
        description?: string;
        directory?: string;
    }>;
    
    skillsDir?: string;
    
    skillGroups?: RuntimeSkillGroup[];
}

export interface AdapterInstanceAiConfig {
    model?: string;
    baseURL?: string;
    apiKey?: string;
    
    effort?: string;
    
    subAgentModel?: string;
    
    subAgentEffort?: string;
}
export interface AdapterSessionConfig {
    
    command: string;
    
    workingDirectory: string;
    
    agentId?: string;
    
    scopeKey?: string;
    
    browserAllowPrivate?: boolean;
    
    initialPrompt?: string;
    
    initialPromptVisibility?: "visible" | "hidden";
    
    autoAccept: boolean;
    
    systemPrompt?: string | {
        type: string;
        preset: string;
        append: string;
    };
    
    globalPrompt?: string;
    
    rolePrompt?: string;
    
    memory?: string;
    
    model?: string;
    
    maxTurns?: number;
    
    allowedTools?: string[];
    
    mcpConfigPath?: string;
    
    instanceAiConfig?: AdapterInstanceAiConfig;
    
    subAgentModel?: string;
    
    subAgentEffort?: string;
    
    providerArgs?: string[];
    
    envOverrides?: Record<string, string>;
    
    extraMcpServers?: Record<string, unknown>;
    
    nodeVersion?: string;
    
    executablePath?: string;
    
    gitBashPath?: string;
    
    additionalDirectories?: string[];
}
export interface AdapterSession {
    
    sessionId: string;
    
    providerSessionId?: string;
    
    status: SessionStatus;
    
    messages: ConversationMessage[];
    
    createdAt: string;
    
    totalUsage: RuntimeTokenUsage;
    
    pid?: number;
}
export interface ConversationMessage {
    id: string;
    sessionId: string;
    role: "user" | "assistant" | "tool_use" | "tool_result";
    content: string;
    timestamp: string;
    
    toolName?: string;
    
    toolInput?: Record<string, unknown>;
    
    toolResult?: string;
    
    isError?: boolean;
    
    toolUseId?: string;
}
export interface PermissionRequest {
    sessionId: string;
    toolName: string;
    toolInput: Record<string, unknown>;
    permissionPrompt?: string;
}
export interface AskUserQuestionRequest {
    sessionId: string;
    
    toolCallId?: string;
    questions: Array<{
        question: string;
        header?: string;
        options?: Array<{
            label: string;
            description?: string;
        }>;
        multiple?: boolean;
    }>;
}

export declare abstract class BaseProviderAdapter extends EventEmitter {
    
    abstract readonly providerId: string;
    
    abstract readonly displayName: string;
    
    abstract startSession(sessionId: string, config: AdapterSessionConfig): Promise<void>;
    
    abstract sendMessage(sessionId: string, message: string): Promise<void>;
    
    abstract sendConfirmation(sessionId: string, accept: boolean): Promise<void>;
    
    abstract sendQuestionAnswer?(sessionId: string, answers: Record<string, string>): Promise<void>;
    
    abstract submitToolPermissionDecision?(sessionId: string, requestId: string, allowed: boolean): boolean;
    
    abstract getPendingToolAuthRequests?(sessionId: string): Array<{
        requestId: string;
        capability: string;
        detail: Record<string, unknown>;
        requestedAt: number;
    }>;
    
    abstract setIdleCommands?(sessionId: string, commands: {
        idleInputCommand: string;
        nonInputCommand: string;
    }): void;
    
    abstract sendShortcutInput?(sessionId: string, command: string): Promise<void>;
    
    abstract abortCurrentTurn(sessionId: string): Promise<void>;
    
    abstract applyAgentFeatures?(agentId: string): Promise<void>;
    
    abstract setBuiltInCapabilityTools?(agentId: string, capability: string, action: "expand" | "collapse"): Promise<{
        sessions: number;
        tools: number;
        manifests?: Array<{
            name: string;
            description?: string;
            inputSchema?: unknown;
        }>;
    }>;
    
    abstract callBuiltInCapabilityTool?(agentId: string, capability: string, toolName: string, args: Record<string, unknown>): Promise<{
        ok: boolean;
        result?: unknown;
        error?: string;
    }>;
    
    abstract resetContext?(sessionId: string): Promise<void>;
    
    abstract terminateSession(sessionId: string): Promise<void>;
    
    abstract resumeSession?(sessionId: string, providerSessionId: string, config: AdapterSessionConfig): Promise<void>;
    
    abstract getConversation(sessionId: string): ConversationMessage[];
    
    abstract hasSession(sessionId: string): boolean;
    
    abstract getProviderSessionId(sessionId: string): string | undefined;
    
    abstract getSessionStatus(sessionId: string): SessionStatus | undefined;
    
    abstract notifyForceMessage?(sessionId: string): boolean;
    
    abstract getSessionPid?(sessionId: string): number | undefined;
    
    abstract getCapabilities?(sessionId: string): RuntimeCapabilities | undefined;
    
    abstract getPendingQuestion?(sessionId: string): {
        toolCallId: string;
        questions: unknown[];
    } | undefined;
    
    abstract cleanup(): void;
}