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';
/**
 * Traduce keywords del prompt a budget de extended thinking (tokens).
 * Matcheo case-insensitive, busca como palabra completa para no falsar con
 * sustrings (ej. "rethink" NO cuenta como "think").
 *
 *   ultrathink / think harder   → 32k
 *   think hard                  → 10k
 *   think                       → 4k
 *   (nada)                      → 0 (sin thinking)
 *
 * Este patrón lo usa Claude Code. Ahorra al usuario tener que tocar flags.
 */
export declare function detectThinkingBudget(prompt: string): number;
export interface AgentConfig {
    defaultModel: string;
    permissions: 'default' | 'accept-edits' | 'plan' | 'bypass' | '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;
    /** Sandbox Docker para Bash tool. Default: deshabilitado. */
    sandbox?: {
        enabled: boolean;
        image: string;
    };
    /**
     * System prompt extra que se appende al prompt base. Usado por sub-agentes
     * persistentes (`Task subagent_type=X`) para inyectar el system prompt del
     * agente definido en `~/.squeezr-code/agents/X.md`.
     */
    appendSystemPrompt?: string;
    /**
     * Estilo de respuesta. Se traduce a una directiva extra en el system prompt.
     *   - default      → sin modificación
     *   - concise      → respuestas cortas, minimalistas, sin explicaciones
     *   - explanatory  → respuestas pedagógicas con razonamiento paso a paso
     */
    outputStyle?: 'default' | 'concise' | 'explanatory';
    /**
     * Si está, restringe las tools que este agente puede usar. Names sin
     * prefijo de MCP. Útil para agentes especializados (ej: revisor de seguridad
     * solo puede Read/Grep/Glob).
     */
    toolsAllowed?: string[];
}
/**
 * SqAgent — el agente interno de squeezr-code.
 *
 * Todas las requests del REPL pasan por aquí. El agente:
 *   - Gestiona auth de los 3 providers (auto-reimport al expirar).
 *   - Rutea al adapter correcto por modelo.
 *   - Corre el bucle agéntico (call → tools → repeat) con retry y recovery.
 *   - Trackea % de contexto vía Brain.
 *   - Mantiene historial multi-turn entre prompts.
 *   - Genera recaps LLM tras turnos largos.
 *   - Integra tools del MCP manager si está inyectado.
 *
 * (Antes se llamaba `SqProxy` porque el plan original era rutear a través
 * de squeezr-ai como proxy MITM. Ese camino se abandonó: sq habla directo a
 * las APIs con OAuth de suscripción. Renombrado en v0.12.4 para no confundir.)
 */
export interface ModelCostEntry {
    inputTokens: number;
    outputTokens: number;
    /** Tokens servidos desde cache — se cobran ~50% (OpenAI/Gemini) o ~10% (Anthropic) del input price. */
    cacheReadTokens: number;
    usd: number;
}
export declare class SqAgent {
    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;
    /** Último system prompt construido (para /context). */
    private lastSystemPrompt;
    /** 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;
    /** Runner de hooks user-level (PreToolUse, PostToolUse, etc). */
    private hooks;
    constructor(auth: AuthManager, config: AgentConfig);
    /** Flag que corta el loop cuando el usuario pulsa Esc/Ctrl+C durante el turno. */
    private aborted;
    /** Inyecta el MCP manager para que el agente vea sus tools. */
    setMcpManager(mcp: McpManager): void;
    getMcpManager(): McpManager | null;
    /**
     * Aborta el turno en curso. Cierra el adapter (cancela stream/WebSocket)
     * y marca el flag para que el loop del send() termine en la siguiente
     * iteración. Llamado desde el REPL cuando el usuario pulsa Esc o Ctrl+C
     * mientras sq está procesando.
     */
    abortCurrent(): 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<{
            approved: boolean;
            explanation?: string;
        }>;
        attachments?: Array<{
            base64: string;
            mediaType: string;
        }>;
        envContext?: import('../api/types.js').AgentEnvContext;
    }): 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;
    /** Cambia el modo de permisos en runtime (Shift+Tab del REPL). */
    setPermissionMode(mode: AgentConfig['permissions']): void;
    setOutputStyle(style: AgentConfig['outputStyle']): void;
    getOutputStyle(): AgentConfig['outputStyle'];
    getPermissionMode(): AgentConfig['permissions'];
    /** 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[];
    /** Último system prompt construido (para /context). */
    getLastSystemPrompt(): string;
    /** Rehidrata historial desde una sesión persistida (sq resume).
     *  Trunca tool results a 5KB para sanear sesiones antiguas sin límite. */
    setConversationHistory(messages: NormalizedMessage[]): void;
    /**
     * Tamaño estimado del historial en caracteres.
     * Útil para decidir si compactar antes del primer turno.
     */
    historyChars(): number;
    /** 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=agent.d.ts.map