micro-models-agent 2.16.0 → 2.17.1

package/dist/core/agent-moe.js

@@ -1,248 +0,0 @@
-import { OrchestratorClient } from "../llm/orchestrator";
-import { validatePlan, applyAutoFixes } from "../modules/execution/plan-validator";
-import { MoEExecutor } from "../modules/execution/moe-executor";
-import { StepVerifier } from "../modules/execution/verifier";
-import { newAbortError } from "../modules/execution/moe-executor";
-import { t } from "../i18n/index";
-/** Дефолтный лимит циклов re-plan MoE. */
-export const DEFAULT_MOE_MAX_REPLAN_CYCLES = 3;
-/**
- * Исполняет MoE-путь (Mixture of Experts): план → валидация → исполнение →
- * верификация, с re-plan циклом по решению verifyAndMerge оркестратора.
- * Возвращает сигнал фолбэка, когда MoE не может продолжить: вызывающий
- * откатывается в одиночный цикл агента.
- */
-export async function runWithMoE(deps, input, fallback, opts = {}) {
-    const { config, llmProvider, logger, toolExecutor, baseDir } = deps;
-    const { onMeta, onPhase, onTool, signal, onEvent, sessionId } = opts;
-    const emit = (type, data) => onEvent?.({ type, data });
-    const ensureNotAborted = () => {
-        if (signal?.aborted)
-            throw newAbortError();
-    };
-    // Однострочники оркестрации — machine-facing: в чат только при
-    // включённом verbose UI (config.ui.verbose).
-    const verbose = config.ui?.verbose === true;
-    const status = (message) => {
-        if (verbose)
-            onMeta?.(message);
-    };
-    ensureNotAborted();
-    let orchestrator = deps.orchestratorOverride;
-    if (!orchestrator) {
-        orchestrator = new OrchestratorClient({
-            model: config.orchestrator.model,
-            provider: config.orchestrator.provider,
-            contextWindow: config.orchestrator.contextWindow,
-            retry: config.retry,
-            rateLimits: config.security?.rateLimits,
-            logger,
-            experts: config.experts,
-        }, llmProvider, { getSessionId: () => sessionId });
-    }
-    if (!orchestrator.isEnabled()) {
-        // Видно на дефолтном лог-уровне: включивший moe.enabled должен понимать,
-        // почему MoE не стартовал (нет orchestrator.model).
-        logger.warn(t("moe.no_orchestrator"));
-        return fallback();
-    }
-    status(t("moe.planning"));
-    onPhase?.("thinking");
-    const planResult = await orchestrator.plan(input, undefined, signal);
-    onPhase?.("done");
-    if ("error" in planResult) {
-        logger.warn(t("moe.plan_failed", { error: planResult.error }));
-        emit("moe_plan", { status: "error", error: planResult.error });
-        return fallback();
-    }
-    emit("moe_plan", {
-        status: "ok",
-        title: planResult.plan.title,
-        subtaskIds: planResult.plan.subtasks.map((s) => s.id),
-    });
-    const maxCycles = Math.max(1, config.moe?.maxReplanCycles ?? DEFAULT_MOE_MAX_REPLAN_CYCLES);
-    const mergedResults = new Map();
-    let currentPlan = planResult.plan;
-    const usageByTag = {};
-    for (let cycle = 1; cycle <= maxCycles; cycle++) {
-        ensureNotAborted();
-        if (cycle > 1) {
-            status(`${t("moe.replan_started", { cycle, max: maxCycles })}\n`);
-            emit("moe_replan", {
-                cycle,
-                title: currentPlan.title,
-                subtaskIds: currentPlan.subtasks.map((s) => s.id),
-            });
-        }
-        // Валидируем каждый план до исполнения — LLM-плану не доверяем никогда,
-        // включая re-plan от verifyAndMerge.
-        const validation = validatePlan(currentPlan, config);
-        if (!validation.valid) {
-            const applied = applyAutoFixes(currentPlan, validation.autoFixes);
-            const retry = validatePlan(applied, config);
-            if (!retry.valid) {
-                logger.diagnostic("warn", `MoE plan validation failed: ${retry.errors.join("; ")}`);
-                if (cycle === 1) {
-                    status(t("moe.plan_fallback"));
-                    return fallback();
-                }
-                return partialFailure(mergedResults, retry.errors.join("; "));
-            }
-            currentPlan = applied;
-            if (validation.autoFixes.length > 0) {
-                status(t("moe.plan_autofixed", { count: String(validation.autoFixes.length) }));
-            }
-        }
-        const executor = deps.executorOverride ??
-            new MoEExecutor({
-                config,
-                toolRegistry: toolExecutor.getRegistry(),
-                toolExecutor,
-                llmProvider,
-                logger,
-                baseDir,
-                onTool,
-                sessionId,
-                onEvent: (e) => emit(e.type, e.data),
-                onScopeRequest: async (subtaskId, req) => {
-                    const decision = await orchestrator.resolveScopeRequest(subtaskId, req, signal);
-                    if (decision.action === "approve") {
-                        status(`${t("moe.scope_approved", {
-                            subtask: subtaskId,
-                            files: [...decision.write, ...decision.read].join(", "),
-                        })}\n`);
-                    }
-                    else {
-                        status(`${t("moe.scope_rejected", { subtask: subtaskId })}\n`);
-                    }
-                    return decision;
-                },
-            });
-        status(`${t("moe.executing", { count: String(currentPlan.subtasks.length), cycle: String(cycle) })}\n`);
-        // Селективный re-plan (Plan 5.1): успешные сабтаски прошлого цикла
-        // переносятся — переисполняются только упавшие/новые.
-        const skipIds = new Set();
-        const carriedResults = [];
-        for (const s of currentPlan.subtasks) {
-            const prev = mergedResults.get(s.id);
-            if (prev?.success) {
-                skipIds.add(s.id);
-                carriedResults.push(prev);
-            }
-        }
-        for (const id of skipIds) {
-            emit("moe_subtask", { subtaskId: id, status: "carried", cycle });
-        }
-        const planResults = await executor.executePlan(currentPlan, { skipIds, carriedResults });
-        ensureNotAborted();
-        const cycleUsage = executor.getUsageByTag?.();
-        if (cycleUsage) {
-            for (const [tag, usage] of Object.entries(cycleUsage)) {
-                const agg = usageByTag[tag] ?? {
-                    promptTokens: 0,
-                    completionTokens: 0,
-                    totalTokens: 0,
-                    subtasks: 0,
-                };
-                agg.promptTokens += usage.promptTokens;
-                agg.completionTokens += usage.completionTokens;
-                agg.totalTokens += usage.totalTokens;
-                agg.subtasks += usage.subtasks;
-                usageByTag[tag] = agg;
-            }
-        }
-        for (const r of planResults.results) {
-            mergedResults.set(r.subtaskId, r);
-        }
-        const succeeded = [...mergedResults.values()].filter((r) => r.success).length;
-        status(`✅ ${t("moe.execution_complete", { succeeded: String(succeeded), total: String(mergedResults.size) })}\n`);
-        const verifier = deps.verifierOverride ??
-            new StepVerifier(baseDir);
-        const knownTags = collectKnownToolTags(toolExecutor);
-        const verification = await verifier.verifyMoEManifest(currentPlan, config, knownTags);
-        onPhase?.("thinking");
-        ensureNotAborted();
-        let verifyResult;
-        try {
-            verifyResult = await orchestrator.verifyAndMerge({
-                plan: currentPlan,
-                results: [...mergedResults.values()].map((r) => ({
-                    subtaskId: r.subtaskId,
-                    success: r.success,
-                    summary: r.summary,
-                    result: r.result,
-                    error: r.error,
-                })),
-                verifierErrors: verification.errors,
-                verifierWarnings: verification.warnings,
-            }, signal);
-        }
-        catch (err) {
-            onPhase?.("done");
-            if (err?.name === "AbortError")
-                throw err;
-            emit("moe_verify", { status: "error", error: err.message });
-            return {
-                success: false,
-                text: `MoE verifyAndMerge crashed: ${err.message}`,
-                error: err.message,
-                iterationCount: mergedResults.size,
-            };
-        }
-        onPhase?.("done");
-        emit("moe_verify", {
-            decision: verifyResult.type,
-            explanation: verifyResult.explanation,
-            usageByTag: Object.keys(usageByTag).length > 0 ? usageByTag : undefined,
-        });
-        if (verifyResult.type === "final") {
-            return buildFinalResult(mergedResults, verification.success, verifyResult);
-        }
-        if (!verifyResult.plan || !Array.isArray(verifyResult.plan.subtasks)) {
-            // Верификатор просил re-plan, но годного не дал — останавливаемся честно.
-            return partialFailure(mergedResults, verifyResult.explanation || "re-plan requested but no plan returned");
-        }
-        currentPlan = verifyResult.plan;
-    }
-    return partialFailure(mergedResults, t("moe.cycles_exhausted", { max: String(maxCycles) }));
-}
-function collectKnownToolTags(toolExecutor) {
-    const tags = new Set();
-    for (const tool of toolExecutor.getRegistry().getAll()) {
-        for (const tag of tool.tags || [])
-            tags.add(tag);
-    }
-    return Array.from(tags);
-}
-function buildFinalResult(mergedResults, verificationSuccess, verifyResult) {
-    const outputLines = [`## MoE Execution Results\n`];
-    for (const r of mergedResults.values()) {
-        const icon = r.success ? "✅" : "❌";
-        outputLines.push(`${icon} **${r.subtaskId}**: ${r.summary} (${r.durationMs}ms)`);
-    }
-    outputLines.push("");
-    outputLines.push(`**Result:** ${verifyResult.finalAnswer || "Complete"}`);
-    const failedCount = [...mergedResults.values()].filter((r) => !r.success).length;
-    return {
-        success: failedCount === 0 && verificationSuccess,
-        text: outputLines.join("\n"),
-        iterationCount: mergedResults.size,
-        moeHandled: true,
-    };
-}
-function partialFailure(mergedResults, reason) {
-    const outputLines = [`## MoE Execution Results\n`];
-    for (const r of mergedResults.values()) {
-        const icon = r.success ? "✅" : "❌";
-        outputLines.push(`${icon} **${r.subtaskId}**: ${r.summary} (${r.durationMs}ms)`);
-    }
-    outputLines.push("");
-    outputLines.push(`**${t("moe.partial_result")}:** ${reason}`);
-    return {
-        success: false,
-        text: outputLines.join("\n"),
-        error: reason,
-        iterationCount: mergedResults.size,
-        moeHandled: true,
-    };
-}