/**
 * Tool Registry — tools como primitives de primeira classe.
 *
 * Fluxo: discover → check permission → check compatibility → select →
 * execute → validate result. Cada tool declara permissões explícitas
 * (princípio do menor privilégio: nada é concedido por default).
 */
import { PolicyEngine, type PolicyEnvironment, type TrustTier } from '../security/policy.js';
export type ToolPermission = 'fs:read' | 'fs:write' | 'net:http' | 'shell';
export interface ToolContext {
    /** Permissões concedidas ao caller. */
    permissions: ToolPermission[];
    /** Diretório base do projeto (sandbox para fs tools). */
    baseDir: string;
    /** Diretórios permitidos para leitura/escrita fora do baseDir. */
    allowedDirs?: string[];
    /** Contexto de execução para o Policy Engine (default: 'development'). */
    environment?: PolicyEnvironment;
    /** Trust tier de quem está solicitando a tool (skill/agent builtin/generated/community). */
    trustTier?: TrustTier;
}
export interface ToolDefinition {
    id: string;
    description: string;
    requiredPermission: ToolPermission;
    /** Versão mínima de compatibilidade do framework. */
    compatibility?: string;
    /** Valida o payload antes da execução. */
    validateInput(input: unknown): string[];
    /**
     * Executa. Pode ser assíncrona: `code.execute` roda um processo isolado, e
     * fazer isso de forma síncrona travaria o event loop — o que na prática
     * mataria o paralelismo dos outros nós do mesmo batch.
     */
    execute(input: unknown, ctx: ToolContext): unknown | Promise<unknown>;
}
export interface ToolResult {
    ok: boolean;
    result?: unknown;
    error?: string;
    durationMs: number;
    /**
     * A política bloqueou MAS a ação pode prosseguir com decisão humana
     * explícita. Distinto de `ok: false` puro, que é um "não" definitivo.
     *
     * Existia em `PolicyDecision.requiresApproval` desde sempre, e `execute` só
     * olhava `allowed`: uma tool que a política mandava submeter à aprovação
     * humana era simplesmente recusada, e não havia caminho de tool para o
     * `izanagi approve` que o resto do runtime já tinha.
     */
    requiresApproval?: boolean;
}
export declare class ToolRegistry {
    private readonly tools;
    /** Ids que entraram por `register()`, e cujo código o runtime nunca viu. */
    private readonly registered;
    private readonly policy;
    constructor(policy?: PolicyEngine);
    /**
     * Registra uma tool externa (MCP/plugin).
     *
     * O id fica marcado como `registered`: a política precisa saber que o
     * runtime nunca viu o código desta tool, e o default de "nenhuma regra casou
     * então permite" não vale para ela. Registrar por cima de uma builtin
     * também marca — a substituição é o caso em que a origem mais importa.
     */
    register(def: ToolDefinition): void;
    /** Discover: lista tools compatíveis com as permissões concedidas. */
    discover(ctx: ToolContext): Array<{
        id: string;
        description: string;
        permission: ToolPermission;
    }>;
    /** Seleciona + verifica permissão + executa + valida resultado. */
    execute(toolId: string, input: unknown, ctx: ToolContext): Promise<ToolResult>;
}
//# sourceMappingURL=registry.d.ts.map