import { AuthManager } from '../auth/manager.js';
import type { McpManager } from '../mcp/manager.js';
import type { AgentEvent, NormalizedMessage, Provider } from '../api/types.js';
import type { PermissionRules } from '../config.js';
export interface ProxyConfig {
    defaultModel: string;
    permissions: 'default' | 'auto' | 'yolo';
    /** Reglas granulares allow/deny del sq.toml. */
    rules?: PermissionRules;
    transplant: {
        warnThreshold: number;
        autoThreshold: number;
    };
    /** Si generar recap LLM tras turnos largos. Default true. */
    recaps?: boolean;
}
/**
 * SqProxy — the internal brain of squeezr-code.
 *
 * All requests from the REPL go through here. The proxy:
 * - Manages auth for all 3 providers (auto-reimport on expiry)
 * - Routes to the correct API adapter
 * - Runs the agentic loop (call → tools → repeat)
 * - Tracks context % via Brain
 * - Handles retries and error recovery
 * - (Phase 2: integrates squeezr-ai compression)
 * - (Phase 3: intelligent routing via Router)
 */
export interface ModelCostEntry {
    inputTokens: number;
    outputTokens: number;
    usd: number;
}
export declare class SqProxy {
    private apiClient;
    private auth;
    private brain;
    private config;
    private currentModel;
    private currentProvider;
    private totalCostUsd;
    /** Coste acumulado por modelo en la sesión actual (para /cost). */
    private costByModel;
    /** Historial multi-turn persistente entre prompts del REPL. */
    private conversationHistory;
    /** Listener opcional para que el REPL persista la sesión tras cada turno. */
    private onTurnComplete;
    /** Manager de MCP servers (opcional — se inyecta desde el REPL tras arrancarlos). */
    private mcp;
    constructor(auth: AuthManager, config: ProxyConfig);
    /** Inyecta el MCP manager para que el agente vea sus tools. */
    setMcpManager(mcp: McpManager): void;
    /**
     * Send a user prompt through the full agentic loop.
     * Yields AgentEvents for the REPL to render.
     */
    send(prompt: string, opts?: {
        model?: string;
        cwd?: string;
        askPermission?: (name: string, input: Record<string, unknown>) => Promise<boolean>;
    }): AsyncGenerator<AgentEvent>;
    /**
     * Genera un recap del turno actual. Usa el mismo modelo y el historial
     * actualizado (post-turn) para pedir una frase corta de resumen.
     *
     * El recap NO se persiste en conversationHistory: es un ping transient.
     */
    private streamRecap;
    getBrainState(): import("../brain/brain.js").BrainState;
    getTotalCost(): number;
    getCurrentModel(): string;
    getCurrentProvider(): Provider;
    /** Borra contadores del Brain + historial multi-turn (lo que hace /clear). */
    resetBrain(): void;
    /** Snapshot del coste por modelo para `/cost`. */
    getCostByModel(): Map<string, ModelCostEntry>;
    /** Historial completo (para persistencia de sesión). */
    getConversationHistory(): NormalizedMessage[];
    /** Rehidrata historial desde una sesión persistida (sq resume). */
    setConversationHistory(messages: NormalizedMessage[]): void;
    /** Hook que el REPL usa para persistir tras cada turno completo. */
    onPersist(cb: (messages: NormalizedMessage[]) => void): void;
    /**
     * Comprime el historial: pide al modelo actual un resumen conciso de la
     * conversación y reemplaza el historial por un único par user+assistant con
     * el resumen. Úsalo cuando contexto > 70% para seguir sin perder hilo.
     *
     * Devuelve el texto del resumen para que el REPL lo muestre.
     */
    compact(): AsyncGenerator<AgentEvent, string>;
    setModel(model: string): void;
    private resolveProvider;
    private estimateCost;
    shutdown(): void;
}
//# sourceMappingURL=core.d.ts.map