overmind-mcp 3.3.9 → 3.4.1

package/README.md

@@ -28,6 +28,7 @@ _Orchestrateur universel agents IA multi-modèles via MCP. Pilote Hermes, Claude
 - 🌉 **Bridge HTTP JSON-RPC** : Orchestration A2A, scénarios, webhooks, sessions multi-tenant
 - 🛡️ **Anti-Zombie** : 1 seul process HTTP partagé, processRegistry avec TTL + cleanup auto
 - 📋 **14 Outils MCP** : run_agent, create_agent, memory_search/store, agent_control, etc.
+- 🧠 **Mémoire par défaut** : tout agent créé via Overmind reçoit automatiquement le MCP `memory` (3 tools: memory_search/store/runs sur :3099). Pour l'accès complet 14 tools, utiliser `overmind` explicitement.
 - 🅾️ **HTTP Singleton** : FastMCP httpStream — 1 serveur, tous les agents
 
 ---

package/dist/bridge/OverBridgeServer.d.ts

@@ -130,6 +130,37 @@ export declare class OverBridgeServer {
      * 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.

package/dist/bridge/OverBridgeServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OverBridgeServer.d.ts","sourceRoot":"","sources":["../../src/bridge/OverBridgeServer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"OverBridgeServer.d.ts","sourceRoot":"","sources":["../../src/bridge/OverBridgeServer.ts"],"names":[],"mappings":"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"}

package/dist/bridge/OverBridgeServer.js

@@ -66,6 +66,82 @@ const A2AParams = z.object({
     path: z.string().optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
 });
+// ─── A2A Extended Schemas ──────────────────────────────────────────────────
+/** agent.broadcast — Un agent → tous les agents (fan-out global) */
+const BroadcastParams = z.object({
+    fromAgent: z.string().min(1),
+    runner: z.string().min(1),
+    prompt: z.string().min(1),
+    /** Liste des agents cibles. Si absent → tous les agents online. */
+    targets: z.array(z.string().min(1)).optional(),
+    /** Si true, retourne dès qu'un agent répond (default: false = attend tous) */
+    race: z.boolean().optional().default(false),
+    /** Timeout par agent en ms (default: 60_000) */
+    agentTimeoutMs: z.number().int().min(1000).max(3_600_000).optional().default(120_000),
+    model: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/** agent.pipeline — Chaîne séquentielle A→B→C (output de l'un = input du suivant) */
+const PipelineParams = z.object({
+    /** Agent qui initie la chaîne (fromAgent) */
+    initiator: z.string().min(1),
+    runner: z.string().min(1),
+    /** Prompt initial */
+    prompt: z.string().min(1),
+    /** Étapes de la pipeline — chaque step reçoit le output du précédent */
+    steps: z
+        .array(z.object({
+        agentName: z.string().min(1),
+        /** Prompt prefix optionnel (le output précédent est appended) */
+        promptPrefix: z.string().optional(),
+        model: z.string().optional(),
+    }))
+        .min(1),
+    /** Si true, chaque step reçoit TOUS les outputs précédents (default: false = juste le dernier) */
+    accumulateContext: z.boolean().optional().default(false),
+    /** Timeout total en ms (default: 3_600_000 = 1h) */
+    totalTimeoutMs: z.number().int().min(10_000).max(86_400_000).optional().default(3_600_000),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/** agent.fanout — Un agent → plusieurs en parallèle + merge */
+const FanoutParams = z.object({
+    fromAgent: z.string().min(1),
+    runner: z.string().min(1),
+    prompt: z.string().min(1),
+    targets: z.array(z.string().min(1)).min(1),
+    /** Stratégie de merge des résultats */
+    mergeStrategy: z.enum(['concat', 'best', 'vote', 'first_success']).optional().default('concat'),
+    /** Critère pour 'best' (default: le plus long) */
+    bestCriterion: z.string().optional(),
+    /** Timeout par agent en ms (default: 120_000) */
+    agentTimeoutMs: z.number().int().min(1000).max(3_600_000).optional().default(120_000),
+    model: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/** agent.delegate — Délégation async (fire-and-forget avec ID de tracking) */
+const DelegateParams = z.object({
+    fromAgent: z.string().min(1),
+    toAgent: z.string().min(1),
+    runner: z.string().min(1),
+    prompt: z.string().min(1),
+    model: z.string().optional(),
+    /** Si fourni, callback URL appelée quand l'agent termine (POST result) */
+    callbackUrl: z.string().url().optional(),
+    /** Si true, retourne immédiatement avec un taskId (default: true) */
+    async: z.boolean().optional().default(true),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
+/** agent.query — Query multi-agents, retourne toutes les réponses */
+const QueryParams = z.object({
+    fromAgent: z.string().min(1),
+    runner: z.string().min(1),
+    prompt: z.string().min(1),
+    targets: z.array(z.string().min(1)).min(1),
+    /** Timeout par agent en ms (default: 30_000) */
+    agentTimeoutMs: z.number().int().min(1000).max(3_600_000).optional().default(30_000),
+    model: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+});
 const AgentStatusParams = z.object({
     agentName: z.string().min(1),
     runner: z.string().optional(),
@@ -518,6 +594,16 @@ export class OverBridgeServer {
                     return this.methodAgentRun(req);
                 case 'agent.a2a':
                     return this.methodAgentA2A(req);
+                case 'agent.broadcast':
+                    return this.methodAgentBroadcast(req);
+                case 'agent.pipeline':
+                    return this.methodAgentPipeline(req);
+                case 'agent.fanout':
+                    return this.methodAgentFanout(req);
+                case 'agent.delegate':
+                    return this.methodAgentDelegate(req);
+                case 'agent.query':
+                    return this.methodAgentQuery(req);
                 case 'agent.status':
                     return this.methodAgentStatus(req);
                 case 'agent.list':
@@ -762,6 +848,449 @@ export class OverBridgeServer {
         });
         return { jsonrpc: '2.0', id: req.id ?? null, result };
     }
+    // ─── A2A Extended Methods ────────────────────────────────────────────────
+    /**
+     * 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.
+     */
+    async methodAgentBroadcast(req) {
+        const params = this.validateParams(BroadcastParams, req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const { fromAgent, runner, prompt, targets, race, model } = params.data;
+        const validatedFrom = validateAgentName(fromAgent);
+        const reqId = req.params?.__reqId;
+        // Determine target list
+        let targetAgents;
+        if (targets && targets.length > 0) {
+            targetAgents = targets.map(validateAgentName);
+        }
+        else {
+            // All online agents (excluding fromAgent)
+            const onlineAgents = this.registry
+                .list({ status: 'online' })
+                .map((a) => a.name)
+                .filter((name) => name !== validatedFrom);
+            if (onlineAgents.length === 0) {
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id ?? null,
+                    error: { code: -32005, message: 'No online agents to broadcast to' },
+                };
+            }
+            targetAgents = onlineAgents;
+        }
+        this.log.info(`[reqId=${reqId}] 📡 Broadcast from ${validatedFrom} → ${targetAgents.length} agents (race=${race})`);
+        // Register + increment counters
+        this.registry.register(validatedFrom, runner);
+        this.registry.incrementA2aSent(validatedFrom);
+        for (const t of targetAgents) {
+            this.registry.register(t, runner);
+            this.registry.incrementA2aReceived(t);
+        }
+        const enrichedPrompt = this.buildA2aPrompt(validatedFrom, 'BROADCAST', prompt);
+        // Run agents
+        const runOne = async (agentName) => {
+            try {
+                const result = await this.service.runAgent({
+                    runner: runner,
+                    prompt: enrichedPrompt,
+                    agentName,
+                    model,
+                });
+                return {
+                    agentName,
+                    success: !result.isError,
+                    content: result.content,
+                    sessionId: result.sessionId,
+                };
+            }
+            catch (err) {
+                return {
+                    agentName,
+                    success: false,
+                    error: err.message,
+                    content: [],
+                };
+            }
+        };
+        let results;
+        if (race) {
+            // Return first successful result
+            const promises = targetAgents.map((t) => runOne(t));
+            const first = await Promise.race(promises);
+            results = [first];
+        }
+        else {
+            results = await Promise.all(targetAgents.map((t) => runOne(t)));
+        }
+        const successCount = results.filter((r) => r.success).length;
+        this.log.info(`[reqId=${reqId}] 📡 Broadcast done: ${successCount}/${results.length} success`);
+        return {
+            jsonrpc: '2.0',
+            id: req.id ?? null,
+            result: {
+                from: validatedFrom,
+                targets: targetAgents,
+                total: results.length,
+                successCount,
+                race,
+                results,
+            },
+        };
+    }
+    /**
+     * agent.pipeline — Chaîne séquentielle A→B→C.
+     * Le output de chaque step est injecté dans le prompt du suivant.
+     */
+    async methodAgentPipeline(req) {
+        const params = this.validateParams(PipelineParams, req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const { initiator, runner, prompt, steps, accumulateContext, totalTimeoutMs } = params.data;
+        const validatedInitiator = validateAgentName(initiator);
+        const reqId = req.params?.__reqId;
+        this.log.info(`[reqId=${reqId}] 🔗 Pipeline: ${validatedInitiator} → ${steps.map((s) => s.agentName).join(' → ')}`);
+        const deadline = Date.now() + totalTimeoutMs;
+        const outputs = [];
+        let currentPrompt = prompt;
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            if (Date.now() > deadline) {
+                this.log.warn(`[reqId=${reqId}] ⏱️ Pipeline timeout at step ${i}/${steps.length}`);
+                break;
+            }
+            const validatedAgent = validateAgentName(step.agentName);
+            this.registry.register(validatedAgent, runner);
+            // Build prompt for this step
+            const stepPrompt = (step.promptPrefix ? step.promptPrefix + '\n\n' : '') +
+                `[Pipeline Step ${i + 1}/${steps.length} — Input from previous]\n${currentPrompt}`;
+            try {
+                const result = await this.service.runAgent({
+                    runner: runner,
+                    prompt: stepPrompt,
+                    agentName: validatedAgent,
+                    model: step.model,
+                });
+                const outputText = result.content.map((c) => c.text).join('\n');
+                const success = !result.isError;
+                outputs.push({ agentName: validatedAgent, output: outputText, success });
+                if (!success) {
+                    this.log.warn(`[reqId=${reqId}] ❌ Pipeline step ${i + 1} (${validatedAgent}) failed — stopping`);
+                    break;
+                }
+                // Next step gets: just the last output, or all accumulated outputs
+                if (accumulateContext) {
+                    currentPrompt = outputs.map((o) => `[${o.agentName}]: ${o.output}`).join('\n\n---\n\n');
+                }
+                else {
+                    currentPrompt = outputText;
+                }
+            }
+            catch (err) {
+                this.log.error(`[reqId=${reqId}] 💥 Pipeline step ${i + 1} (${validatedAgent}) error: ${err.message}`);
+                outputs.push({
+                    agentName: validatedAgent,
+                    output: '',
+                    success: false,
+                });
+                break;
+            }
+        }
+        return {
+            jsonrpc: '2.0',
+            id: req.id ?? null,
+            result: {
+                initiator: validatedInitiator,
+                totalSteps: steps.length,
+                executedSteps: outputs.length,
+                allSuccess: outputs.every((o) => o.success),
+                outputs,
+                finalOutput: outputs.length > 0 ? outputs[outputs.length - 1].output : '',
+            },
+        };
+    }
+    /**
+     * agent.fanout — Un agent → plusieurs en parallèle + merge.
+     * mergeStrategy: concat | best | vote | first_success
+     */
+    async methodAgentFanout(req) {
+        const params = this.validateParams(FanoutParams, req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const { fromAgent, runner, prompt, targets, mergeStrategy, model } = params.data;
+        const validatedFrom = validateAgentName(fromAgent);
+        const reqId = req.params?.__reqId;
+        const targetAgents = targets.map(validateAgentName);
+        this.log.info(`[reqId=${reqId}] 🌐 Fanout from ${validatedFrom} → ${targetAgents.length} agents (merge=${mergeStrategy})`);
+        const enrichedPrompt = this.buildA2aPrompt(validatedFrom, 'FANOUT', prompt);
+        // Run all targets in parallel
+        const results = await Promise.all(targetAgents.map(async (agentName) => {
+            try {
+                const result = await this.service.runAgent({
+                    runner: runner,
+                    prompt: enrichedPrompt,
+                    agentName,
+                    model,
+                });
+                return {
+                    agentName,
+                    success: !result.isError,
+                    text: result.content.map((c) => c.text).join('\n'),
+                    sessionId: result.sessionId,
+                };
+            }
+            catch (err) {
+                return {
+                    agentName,
+                    success: false,
+                    text: err.message,
+                    sessionId: undefined,
+                };
+            }
+        }));
+        // Merge results
+        let merged;
+        let winner;
+        switch (mergeStrategy) {
+            case 'first_success': {
+                const first = results.find((r) => r.success);
+                merged = first ? first.text : 'All agents failed';
+                winner = first?.agentName;
+                break;
+            }
+            case 'best': {
+                // Default: longest response
+                const sorted = [...results]
+                    .filter((r) => r.success)
+                    .sort((a, b) => b.text.length - a.text.length);
+                merged = sorted.length > 0 ? sorted[0].text : 'All agents failed';
+                winner = sorted[0]?.agentName;
+                break;
+            }
+            case 'vote': {
+                // Simple vote: count similar responses (by length bucket)
+                const buckets = new Map();
+                for (const r of results.filter((r) => r.success)) {
+                    const bucket = Math.floor(r.text.length / 100) * 100;
+                    if (!buckets.has(bucket))
+                        buckets.set(bucket, []);
+                    buckets.get(bucket).push({ agentName: r.agentName, text: r.text });
+                }
+                const sortedBuckets = [...buckets.entries()].sort((a, b) => b[1].length - a[1].length);
+                merged = sortedBuckets.length > 0 ? sortedBuckets[0][1][0].text : 'No votes';
+                winner = sortedBuckets[0]?.[1]?.[0]?.agentName;
+                break;
+            }
+            case 'concat':
+            default: {
+                merged = results
+                    .map((r) => `### ${r.agentName}${r.success ? '' : ' (FAILED)'}\n${r.text}`)
+                    .join('\n\n---\n\n');
+                break;
+            }
+        }
+        return {
+            jsonrpc: '2.0',
+            id: req.id ?? null,
+            result: {
+                from: validatedFrom,
+                targets: targetAgents,
+                mergeStrategy,
+                winner,
+                totalResults: results.length,
+                successCount: results.filter((r) => r.success).length,
+                results,
+                merged,
+            },
+        };
+    }
+    /**
+     * 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.
+     */
+    async methodAgentDelegate(req) {
+        const params = this.validateParams(DelegateParams, req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const { fromAgent, toAgent, runner, prompt, model, callbackUrl, async: isAsync, metadata, } = params.data;
+        const validatedFrom = validateAgentName(fromAgent);
+        const validatedTo = validateAgentName(toAgent);
+        const reqId = req.params?.__reqId;
+        const taskId = crypto.randomUUID();
+        this.log.info(`[reqId=${reqId}] 🤝 Delegate ${validatedFrom} → ${validatedTo} (taskId=${taskId}, async=${isAsync})`);
+        const enrichedPrompt = this.buildA2aPrompt(validatedFrom, 'DELEGATE', prompt);
+        // Persist
+        let messageId;
+        if (this.messageLog) {
+            messageId = await this.messageLog.create({
+                fromAgent: validatedFrom,
+                toAgent: validatedTo,
+                runner: runner,
+                prompt: enrichedPrompt,
+                metadata: { ...(metadata ?? {}), taskId, delegate: true },
+            });
+        }
+        // Run async (fire-and-forget)
+        const runAsync = async () => {
+            try {
+                const result = await this.service.runAgent({
+                    runner: runner,
+                    prompt: enrichedPrompt,
+                    agentName: validatedTo,
+                    model,
+                });
+                const responseText = result.content.map((c) => c.text).join('\n');
+                if (messageId && this.messageLog) {
+                    await this.messageLog.markDone(messageId, responseText, result.sessionId);
+                }
+                // Callback si URL fournie
+                if (callbackUrl) {
+                    try {
+                        await fetch(callbackUrl, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                taskId,
+                                from: validatedFrom,
+                                to: validatedTo,
+                                success: !result.isError,
+                                content: result.content,
+                                sessionId: result.sessionId,
+                            }),
+                        });
+                    }
+                    catch (err) {
+                        this.log.warn(`[reqId=${reqId}] ⚠️ Callback ${callbackUrl} failed: ${err.message}`);
+                    }
+                }
+            }
+            catch (err) {
+                const errorMsg = err.message;
+                if (messageId && this.messageLog) {
+                    await this.messageLog.markFailed(messageId, errorMsg);
+                }
+                this.log.error(`[reqId=${reqId}] 💥 Delegate ${taskId} failed: ${errorMsg}`);
+            }
+        };
+        if (isAsync) {
+            // Fire-and-forget — return immediately with taskId
+            void runAsync();
+            return {
+                jsonrpc: '2.0',
+                id: req.id ?? null,
+                result: {
+                    taskId,
+                    from: validatedFrom,
+                    to: validatedTo,
+                    status: 'delegated',
+                    message: `Task delegated to ${validatedTo}. Use agent.status to check progress.`,
+                    messageId,
+                },
+            };
+        }
+        // Sync mode — wait for result
+        try {
+            await runAsync();
+            // Read the result from MessageLog
+            if (messageId && this.messageLog) {
+                const msg = await this.messageLog.getById(messageId);
+                return {
+                    jsonrpc: '2.0',
+                    id: req.id ?? null,
+                    result: {
+                        taskId,
+                        from: validatedFrom,
+                        to: validatedTo,
+                        status: msg?.status ?? 'unknown',
+                        content: msg?.response ? [{ type: 'text', text: msg.response }] : [],
+                        messageId,
+                    },
+                };
+            }
+            return {
+                jsonrpc: '2.0',
+                id: req.id ?? null,
+                result: { taskId, status: 'done', messageId },
+            };
+        }
+        catch (err) {
+            return {
+                jsonrpc: '2.0',
+                id: req.id ?? null,
+                error: { code: -32603, message: `Delegate failed: ${err.message}` },
+            };
+        }
+    }
+    /**
+     * agent.query — Query multi-agents, retourne toutes les réponses rapidement.
+     * Comme fanout mais optimisé pour le read-only (courte réponse rapide).
+     */
+    async methodAgentQuery(req) {
+        const params = this.validateParams(QueryParams, req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const { fromAgent, runner, prompt, targets, agentTimeoutMs, model } = params.data;
+        const validatedFrom = validateAgentName(fromAgent);
+        const reqId = req.params?.__reqId;
+        const targetAgents = targets.map(validateAgentName);
+        this.log.info(`[reqId=${reqId}] ❓ Query from ${validatedFrom} → ${targetAgents.length} agents`);
+        const enrichedPrompt = this.buildA2aPrompt(validatedFrom, 'QUERY', prompt);
+        // Run all in parallel with timeout
+        const results = await Promise.all(targetAgents.map(async (agentName) => {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), agentTimeoutMs);
+            try {
+                const result = await this.service.runAgent({
+                    runner: runner,
+                    prompt: enrichedPrompt,
+                    agentName,
+                    model,
+                });
+                clearTimeout(timer);
+                return {
+                    agentName,
+                    success: !result.isError,
+                    text: result.content.map((c) => c.text).join('\n'),
+                    responseTimeMs: 0, // Could track if needed
+                };
+            }
+            catch (err) {
+                clearTimeout(timer);
+                return {
+                    agentName,
+                    success: false,
+                    text: err.message,
+                    responseTimeMs: agentTimeoutMs,
+                };
+            }
+        }));
+        return {
+            jsonrpc: '2.0',
+            id: req.id ?? null,
+            result: {
+                from: validatedFrom,
+                totalQueried: targetAgents.length,
+                successCount: results.filter((r) => r.success).length,
+                results,
+            },
+        };
+    }
+    // ─── A2A Helpers ──────────────────────────────────────────────────────────
+    /**
+     * Construit un prompt A2A standardisé avec header.
+     */
+    buildA2aPrompt(fromAgent, kind, prompt) {
+        return [
+            `[A2A — ${kind}]`,
+            `FROM: ${fromAgent}`,
+            `TIMESTAMP: ${new Date().toISOString()}`,
+            `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+            prompt,
+        ].join('\n');
+    }
     /**
      * agent.status — Status live d'un agent (busy/idle/online) via registry.
      * Possibilité de proxy vers Overmind MCP agent_control aussi.