/**
 * ╔══════════════════════════════════════════════════════════════════════╗
 * ║   OVERMIND BRIDGE — OverBridgeServer (HTTP JSON-RPC 2.0 Entry Point)║
 * ║                                                                      ║
 * ║   Serveur HTTP qui expose l'API Overmind Bridge via JSON-RPC 2.0.    ║
 * ║   Permet à n'importe quel client (curl, Python, fetch...) de :       ║
 * ║     - Parler à un agent                                               ║
 * ║     - Faire parler des agents entre eux (A2A)                        ║
 * ║     - Suivre l'état live des agents (busy/idle/online)               ║
 * ║     - Consulter l'historique persistant des messages                 ║
 * ║                                                                      ║
 * ║   ARCHITECTURE                                                       ║
 * ║   ─────────────                                                      ║
 * ║   Client HTTP → POST /rpc → JSON-RPC dispatcher                      ║
 * ║                          → OverBridgeService (deja wrappe MCP)       ║
 * ║                          → AgentRegistry (etat live)                 ║
 * ║                          → MessageLog (persistence Postgres)         ║
 * ║                          → Overmind MCP :3099                        ║
 * ╚══════════════════════════════════════════════════════════════════════╝
 */
import { OverBridgeService } from './OverBridgeService.js';
import { AgentRegistry } from './AgentRegistry.js';
import { MessageLog, type MessageLogConfig } from './MessageLog.js';
import { SessionStore } from './SessionStore.js';
import { type BridgeLogger } from './utils.js';
export interface JsonRpcRequest {
    jsonrpc: '2.0';
    id?: number | string | null;
    method: string;
    params?: Record<string, unknown>;
}
export interface JsonRpcResponse {
    jsonrpc: '2.0';
    id: number | string | null;
    result?: unknown;
    error?: {
        code: number;
        message: string;
        data?: unknown;
    };
}
export interface OverBridgeServerConfig {
    /** Port d'écoute HTTP (default: 3100) */
    port: number;
    /** Host d'écoute (default: '127.0.0.1') */
    host: string;
    /** Config Postgres pour MessageLog */
    postgres: MessageLogConfig;
    /** Active le MessageLog (si false, les messages ne sont pas persistés) */
    enableMessageLog: boolean;
    /** Authentification simple par token (Authorization: Bearer *** — optionnel */
    authToken?: string;
    /** Health check interval pour OverBridgeService (default: 30000ms) */
    healthCheckIntervalMs: number;
    /** Active le SessionStore multi-tenant (sessions par clé externe) */
    enableSessionStore?: boolean;
    /** Chemin du fichier de persistence des sessions (default: ~/.overmind/bridge/sessions.json) */
    sessionStorePath?: string;
    /** TTL des sessions en ms (default: 4h) */
    sessionTtlMs?: number;
    /** Active le parsing de directives dans les réponses agent (SESSION_ID, CONTEXT_UPDATE, BRIDGE_NEXT) */
    enableDirectives?: boolean;
    /** Active le support webhook (auto-mount /webhook/:provider endpoints) */
    enableWebhooks?: boolean;
    /** JSON body limit (default: '10mb') */
    jsonBodyLimit?: string;
    /** Active la sanitization JSON (Windows paths) */
    sanitizeJson?: boolean;
    /** Origins CORS autorisées (default: ['http://localhost:3000', 'http://localhost:5173']). Mettre ['*'] pour ouvert. */
    allowedOrigins?: string[];
    /** Rate limiting: max requêtes /rpc par IP par fenêtre de 60s (default: 100, 0 = illimité) */
    rateLimitMax?: number;
}
export declare class OverBridgeServer {
    private readonly service;
    private readonly registry;
    private readonly log;
    private readonly messageLog;
    private readonly sessions;
    private readonly directiveParser;
    private readonly webhookAdapter;
    private readonly config;
    private server;
    private startTime;
    private pruneTimer;
    private rateLimiter;
    constructor(service: OverBridgeService, config: OverBridgeServerConfig, logger?: BridgeLogger);
    /**
     * Démarre le serveur HTTP et initialise les dépendances (MessageLog, SessionStore, OverBridgeService).
     */
    start(): Promise<{
        port: number;
        host: string;
        url: string;
    }>;
    /**
     * Ferme proprement le serveur HTTP et les dépendances.
     */
    stop(): Promise<void>;
    /**
     * Expose le registry (pour tests / inspection).
     */
    get agentRegistry(): AgentRegistry;
    /**
     * Expose le MessageLog (pour tests / inspection).
     */
    get messages(): MessageLog | undefined;
    /**
     * Expose le SessionStore (pour tests / inspection).
     */
    get sessionStore(): SessionStore | undefined;
    private handleRequest;
    private writeCors;
    private writeJson;
    private handleWebhook;
    private handleStaticFile;
    private handleHealth;
    private handleRpc;
    /**
     * Dispatch une requête JSON-RPC vers la bonne méthode.
     */
    private dispatchRpc;
    /**
     * agent.run — Lance un agent (from client externe OU from autre agent).
     * Avec support SessionStore (externalKey) et DirectiveParser.
     */
    private methodAgentRun;
    /**
     * agent.a2a — Agent A parle à Agent B (le hub orchestre).
     * B reçoit un prompt enrichi avec le contexte de A.
     */
    private methodAgentA2A;
    /**
     * agent.broadcast — Un agent → tous les agents (fan-out global).
     * Si race=true, retourne dès qu'un agent répond.
     * Si race=false (default), attend tous et retourne les résultats.
     */
    private methodAgentBroadcast;
    /**
     * agent.pipeline — Chaîne séquentielle A→B→C.
     * Le output de chaque step est injecté dans le prompt du suivant.
     */
    private methodAgentPipeline;
    /**
     * agent.fanout — Un agent → plusieurs en parallèle + merge.
     * mergeStrategy: concat | best | vote | first_success
     */
    private methodAgentFanout;
    /**
     * agent.delegate — Délégation async (fire-and-forget avec taskId).
     * Si async=true (default), retourne immédiatement avec un taskId.
     * Si callbackUrl fourni, POST le résultat quand l'agent termine.
     */
    private methodAgentDelegate;
    /**
     * agent.query — Query multi-agents, retourne toutes les réponses rapidement.
     * Comme fanout mais optimisé pour le read-only (courte réponse rapide).
     */
    private methodAgentQuery;
    /**
     * Construit un prompt A2A standardisé avec header.
     */
    private buildA2aPrompt;
    /**
     * agent.status — Status live d'un agent (busy/idle/online) via registry.
     * Possibilité de proxy vers Overmind MCP agent_control aussi.
     */
    private methodAgentStatus;
    /**
     * agent.list — Liste tous les agents et leur état.
     */
    private methodAgentList;
    /**
     * agent.kill — Kill un agent en cours.
     */
    private methodAgentKill;
    /**
     * message.history — Historique des messages persistés.
     */
    private methodMessageHistory;
    /**
     * message.get — Récupère un message par ID.
     */
    private methodMessageGet;
    /**
     * message.replay — Rejoue un message (re-run l'agent avec le même prompt).
     * Le nouveau run crée un NOUVEAU message, l'ancien reste en status 'pending' pour traçabilité.
     */
    private methodMessageReplay;
    /**
     * message.stats — Statistiques globales du log.
     */
    private methodMessageStats;
    private methodSessionGet;
    private methodSessionList;
    private methodSessionDelete;
    private methodSessionStats;
    private methodWebhookSms;
    /**
     * Valide les params d'une requête JSON-RPC via Zod.
     * Retourne soit { data } (succès) soit une JsonRpcResponse d'erreur (à retourner tel quel).
     */
    private validateParams;
    private respondError;
    private buildErrorResponse;
    private readBody;
    /**
     * Parse "10mb" / "1gb" en bytes.
     */
    private parseBodyLimit;
    /**
     * Parse le retour de agent_control pour extraire le status de l'agent distant.
     */
    private parseAgentControlStatus;
}
//# sourceMappingURL=OverBridgeServer.d.ts.map