overmind-mcp
Version:
Orchestrateur universel agents IA multi-modeles via MCP. Inclut le protocole 'Custom-Nickname' pour identifier vos agents avec des surnoms originaux (The Chaos Prophet, Shadow Sniper, etc.), l'isolation mémoire (Private Memory Context) et le support pour
216 lines • 8.62 kB
TypeScript
/**
* ╔══════════════════════════════════════════════════════════════════════╗
* ║ 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