agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/federated/FederatedCoordinator.js

@@ -0,0 +1,824 @@
+"use strict";
+/**
+ * Federated Learning Coordinator
+ *
+ * High-level API for federated learning that coordinates training rounds,
+ * monitors convergence, handles participant failures, and integrates with
+ * AgentChannel for peer communication.
+ *
+ * @module edge/p2p/federated/FederatedCoordinator
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FederatedCoordinator = void 0;
+exports.createFederatedCoordinator = createFederatedCoordinator;
+exports.createFederatedConfig = createFederatedConfig;
+const types_1 = require("./types");
+const GradientAggregator_1 = require("./GradientAggregator");
+const FederatedRound_1 = require("./FederatedRound");
+const ModelManager_1 = require("./ModelManager");
+// ============================================
+// FederatedCoordinator Class
+// ============================================
+/**
+ * High-level federated learning coordinator
+ *
+ * @example
+ * ```typescript
+ * const coordinator = new FederatedCoordinator({
+ *   federatedConfig: {
+ *     sessionId: 'training-session-1',
+ *     modelId: 'my-model',
+ *     aggregationStrategy: AggregationStrategy.FED_AVG,
+ *     selectionStrategy: SelectionStrategy.RANDOM,
+ *     totalRounds: 100,
+ *     minParticipation: 0.3,
+ *   },
+ *   modelConfig: {
+ *     architecture: modelArchitecture,
+ *     optimizer: { type: 'adam', learningRate: 0.001 },
+ *   },
+ *   transport: channelTransport,
+ * });
+ *
+ * // Start training
+ * coordinator.on(event => console.log(event));
+ * const result = await coordinator.startTraining();
+ * ```
+ */
+class FederatedCoordinator {
+    constructor(config) {
+        this.eventHandlers = [];
+        this.checkpointIds = [];
+        this.errors = [];
+        this.lossHistory = [];
+        this.accuracyHistory = [];
+        this.roundHistory = [];
+        this.config = config;
+        // Merge with defaults
+        this.federatedConfig = {
+            ...types_1.DEFAULT_FEDERATED_CONFIG,
+            ...config.federatedConfig,
+        };
+        // Initialize state
+        this.state = {
+            sessionId: this.federatedConfig.sessionId,
+            isTraining: false,
+            currentRound: 0,
+            totalRounds: this.federatedConfig.totalRounds,
+            activeRound: null,
+            convergenceStatus: types_1.ConvergenceStatus.NOT_STARTED,
+            startTime: null,
+            endTime: null,
+            roundsWithoutImprovement: 0,
+            bestLoss: Infinity,
+            bestRound: 0,
+        };
+        // Initialize components
+        this.modelManager = new ModelManager_1.ModelManager(config.modelConfig);
+        this.aggregator = new GradientAggregator_1.GradientAggregator({
+            strategy: this.federatedConfig.aggregationStrategy,
+            enableClipping: this.federatedConfig.enableGradientClipping,
+            clipNorm: this.federatedConfig.gradientClipNorm,
+            differentialPrivacy: this.federatedConfig.differentialPrivacy,
+            secureAggregation: this.federatedConfig.secureAggregation,
+            proximalMu: this.federatedConfig.proximalMu,
+            ...config.aggregatorConfig,
+        });
+        this.transport = config.transport ?? null;
+        // Set initial weights if provided
+        if (config.initialWeights) {
+            this.modelManager.setWeights(config.initialWeights);
+        }
+        // Setup message handling if transport provided
+        if (this.transport) {
+            this.setupMessageHandling();
+        }
+    }
+    // ============================================
+    // Training Lifecycle
+    // ============================================
+    /**
+     * Start federated training
+     */
+    async startTraining() {
+        if (this.state.isTraining) {
+            throw new types_1.FederatedError('Training already in progress', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        // Validate configuration
+        this.validateConfiguration();
+        // Initialize state
+        this.state.isTraining = true;
+        this.state.startTime = Date.now();
+        this.state.currentRound = 0;
+        this.state.convergenceStatus = types_1.ConvergenceStatus.TRAINING;
+        this.errors = [];
+        this.lossHistory = [];
+        this.accuracyHistory = [];
+        this.roundHistory = [];
+        this.checkpointIds = [];
+        this.emitEvent({
+            type: types_1.FederatedEventType.SESSION_STARTED,
+            timestamp: Date.now(),
+            sessionId: this.state.sessionId,
+            details: {
+                totalRounds: this.state.totalRounds,
+                config: this.federatedConfig,
+            },
+        });
+        try {
+            // Run training rounds
+            await this.runTrainingLoop();
+            // Training completed
+            this.state.isTraining = false;
+            this.state.endTime = Date.now();
+            const result = this.buildTrainingResult(true);
+            this.emitEvent({
+                type: types_1.FederatedEventType.SESSION_ENDED,
+                timestamp: Date.now(),
+                sessionId: this.state.sessionId,
+                details: { result },
+            });
+            return result;
+        }
+        catch (error) {
+            this.state.isTraining = false;
+            this.state.endTime = Date.now();
+            this.state.convergenceStatus = types_1.ConvergenceStatus.DIVERGING;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.errors.push(errorMessage);
+            this.emitEvent({
+                type: types_1.FederatedEventType.SESSION_ENDED,
+                timestamp: Date.now(),
+                sessionId: this.state.sessionId,
+                details: { error: errorMessage },
+            });
+            return this.buildTrainingResult(false);
+        }
+    }
+    /**
+     * Stop training
+     */
+    stopTraining(reason = 'Training stopped by user') {
+        if (!this.state.isTraining)
+            return;
+        if (this.state.activeRound) {
+            this.state.activeRound.cancel(reason);
+        }
+        this.state.isTraining = false;
+        this.state.endTime = Date.now();
+        this.errors.push(reason);
+        this.emitEvent({
+            type: types_1.FederatedEventType.SESSION_ENDED,
+            timestamp: Date.now(),
+            sessionId: this.state.sessionId,
+            details: { reason, stopped: true },
+        });
+    }
+    /**
+     * Pause training (can be resumed)
+     */
+    pauseTraining() {
+        if (!this.state.isTraining)
+            return;
+        // Mark as paused - training loop will check this
+        this.state.isTraining = false;
+    }
+    /**
+     * Resume training after pause
+     */
+    async resumeTraining() {
+        if (this.state.isTraining) {
+            throw new types_1.FederatedError('Training is already active', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        if (this.state.currentRound >= this.state.totalRounds) {
+            throw new types_1.FederatedError('Training already completed', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        this.state.isTraining = true;
+        this.state.convergenceStatus = types_1.ConvergenceStatus.TRAINING;
+        try {
+            await this.runTrainingLoop();
+            this.state.isTraining = false;
+            this.state.endTime = Date.now();
+            return this.buildTrainingResult(true);
+        }
+        catch (error) {
+            this.state.isTraining = false;
+            this.errors.push(error instanceof Error ? error.message : String(error));
+            return this.buildTrainingResult(false);
+        }
+    }
+    // ============================================
+    // Training Loop
+    // ============================================
+    /**
+     * Main training loop
+     */
+    async runTrainingLoop() {
+        while (this.state.isTraining &&
+            this.state.currentRound < this.state.totalRounds &&
+            !this.shouldStopEarly()) {
+            // Check privacy budget
+            if (this.federatedConfig.differentialPrivacy?.enabled) {
+                if (this.aggregator.isPrivacyBudgetExhausted()) {
+                    this.emitEvent({
+                        type: types_1.FederatedEventType.PRIVACY_BUDGET_EXHAUSTED,
+                        timestamp: Date.now(),
+                        sessionId: this.state.sessionId,
+                        details: { budget: this.aggregator.getPrivacyBudget() },
+                    });
+                    break;
+                }
+            }
+            // Run a round
+            await this.runRound();
+            // Check for convergence
+            this.updateConvergenceStatus();
+            // Create checkpoint if needed
+            if (this.state.currentRound % this.federatedConfig.checkpointInterval === 0) {
+                await this.createCheckpoint();
+            }
+        }
+    }
+    /**
+     * Run a single training round
+     */
+    async runRound() {
+        const roundNumber = this.state.currentRound;
+        // Get available participants
+        const participants = await this.getAvailableParticipants();
+        if (participants.size < this.getMinParticipants()) {
+            throw new types_1.FederatedError('Insufficient participants available', types_1.FederatedErrorCode.INSUFFICIENT_PARTICIPANTS);
+        }
+        // Get current model
+        const globalModel = this.modelManager.getWeights();
+        if (!globalModel) {
+            throw new types_1.FederatedError('No model weights available', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        // Create round configuration
+        const roundConfig = {
+            sessionId: this.state.sessionId,
+            roundNumber,
+            federatedConfig: this.federatedConfig,
+            globalModel,
+            availableParticipants: participants,
+            aggregator: this.aggregator,
+            sendMessage: this.sendMessage.bind(this),
+            broadcastMessage: this.broadcastMessage.bind(this),
+        };
+        // Create and start round
+        const round = new FederatedRound_1.FederatedRound(roundConfig);
+        this.state.activeRound = round;
+        // Setup round event forwarding
+        round.on((event) => {
+            this.handleRoundEvent(event, round);
+        });
+        this.emitEvent({
+            type: types_1.FederatedEventType.ROUND_STARTED,
+            timestamp: Date.now(),
+            sessionId: this.state.sessionId,
+            roundId: round.getRoundId(),
+            details: { roundNumber },
+        });
+        try {
+            await round.start();
+            const result = await round.waitForCompletion();
+            // Apply aggregated model
+            this.modelManager.applyUpdate(result.aggregatedWeights);
+            // Update metrics
+            const metrics = round.getMetrics();
+            this.lossHistory.push(metrics.aggregatedLoss);
+            if (metrics.aggregatedAccuracy !== undefined) {
+                this.accuracyHistory.push(metrics.aggregatedAccuracy);
+            }
+            this.roundHistory.push(metrics);
+            // Update best
+            if (metrics.aggregatedLoss < this.state.bestLoss) {
+                this.state.bestLoss = metrics.aggregatedLoss;
+                this.state.bestRound = roundNumber;
+                this.state.roundsWithoutImprovement = 0;
+            }
+            else {
+                this.state.roundsWithoutImprovement++;
+            }
+            this.emitEvent({
+                type: types_1.FederatedEventType.ROUND_COMPLETED,
+                timestamp: Date.now(),
+                sessionId: this.state.sessionId,
+                roundId: round.getRoundId(),
+                details: { metrics, result },
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.errors.push(`Round ${roundNumber}: ${errorMessage}`);
+            this.emitEvent({
+                type: types_1.FederatedEventType.ROUND_FAILED,
+                timestamp: Date.now(),
+                sessionId: this.state.sessionId,
+                roundId: round.getRoundId(),
+                details: { error: errorMessage },
+            });
+            // Don't throw - continue to next round if possible
+        }
+        this.state.activeRound = null;
+        this.state.currentRound++;
+    }
+    // ============================================
+    // Convergence Monitoring
+    // ============================================
+    /**
+     * Update convergence status based on training progress
+     */
+    updateConvergenceStatus() {
+        const criteria = this.federatedConfig.convergence ?? types_1.DEFAULT_CONVERGENCE_CRITERIA;
+        // Check if target accuracy reached
+        if (criteria.targetAccuracy !== undefined && this.accuracyHistory.length > 0) {
+            const latestAccuracy = this.accuracyHistory[this.accuracyHistory.length - 1];
+            if (latestAccuracy >= criteria.targetAccuracy) {
+                this.state.convergenceStatus = types_1.ConvergenceStatus.CONVERGED;
+                this.emitEvent({
+                    type: types_1.FederatedEventType.CONVERGENCE_DETECTED,
+                    timestamp: Date.now(),
+                    sessionId: this.state.sessionId,
+                    details: {
+                        reason: 'target_accuracy_reached',
+                        accuracy: latestAccuracy,
+                    },
+                });
+                return;
+            }
+        }
+        // Check loss improvement
+        if (this.lossHistory.length >= 2) {
+            const prevLoss = this.lossHistory[this.lossHistory.length - 2];
+            const currLoss = this.lossHistory[this.lossHistory.length - 1];
+            const improvement = (prevLoss - currLoss) / prevLoss;
+            if (improvement < criteria.minLossImprovement) {
+                // Not improving much
+                if (this.state.roundsWithoutImprovement >= criteria.patience) {
+                    this.state.convergenceStatus = types_1.ConvergenceStatus.PLATEAUED;
+                }
+            }
+            else if (currLoss > prevLoss * 1.5) {
+                // Loss increasing significantly - diverging
+                this.state.convergenceStatus = types_1.ConvergenceStatus.DIVERGING;
+            }
+            else {
+                // Making progress
+                this.state.convergenceStatus = types_1.ConvergenceStatus.CONVERGING;
+            }
+        }
+        // Check if converged (no improvement for extended period with low variance)
+        if (this.state.roundsWithoutImprovement >= criteria.patience * 2) {
+            const recentLosses = this.lossHistory.slice(-criteria.patience);
+            const variance = this.computeVariance(recentLosses);
+            if (variance < 0.001) {
+                this.state.convergenceStatus = types_1.ConvergenceStatus.CONVERGED;
+                this.emitEvent({
+                    type: types_1.FederatedEventType.CONVERGENCE_DETECTED,
+                    timestamp: Date.now(),
+                    sessionId: this.state.sessionId,
+                    details: {
+                        reason: 'loss_stabilized',
+                        variance,
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Check if early stopping should trigger
+     */
+    shouldStopEarly() {
+        const criteria = this.federatedConfig.convergence ?? types_1.DEFAULT_CONVERGENCE_CRITERIA;
+        if (!criteria.earlyStoppingEnabled)
+            return false;
+        // Stop if converged
+        if (this.state.convergenceStatus === types_1.ConvergenceStatus.CONVERGED) {
+            return true;
+        }
+        // Stop if diverging badly
+        if (this.state.convergenceStatus === types_1.ConvergenceStatus.DIVERGING) {
+            return true;
+        }
+        // Stop if no improvement for too long
+        if (this.state.roundsWithoutImprovement >= criteria.maxRoundsWithoutImprovement) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Compute variance of an array of numbers
+     */
+    computeVariance(values) {
+        if (values.length < 2)
+            return 0;
+        const mean = values.reduce((a, b) => a + b, 0) / values.length;
+        const squaredDiffs = values.map((v) => (v - mean) ** 2);
+        return squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
+    }
+    // ============================================
+    // Participant Management
+    // ============================================
+    /**
+     * Get available participants
+     */
+    async getAvailableParticipants() {
+        if (this.transport) {
+            return await this.transport.getAvailableParticipants();
+        }
+        // Return empty map if no transport
+        return new Map();
+    }
+    /**
+     * Get minimum required participants
+     */
+    getMinParticipants() {
+        return Math.max(1, Math.ceil(this.federatedConfig.maxParticipants * this.federatedConfig.minParticipation));
+    }
+    // ============================================
+    // Message Handling
+    // ============================================
+    /**
+     * Setup message handling from transport
+     */
+    setupMessageHandling() {
+        this.transport.onMessage((participantId, message) => {
+            this.handleIncomingMessage(participantId, message);
+        });
+    }
+    /**
+     * Handle incoming message
+     */
+    handleIncomingMessage(participantId, message) {
+        const msg = message;
+        switch (msg.type) {
+            case 'join_request':
+                this.handleJoinRequest(participantId, msg);
+                break;
+            case 'update_submission':
+                this.handleUpdateSubmission(participantId, msg);
+                break;
+            default:
+                // Unknown message type
+                break;
+        }
+    }
+    /**
+     * Handle join request
+     */
+    async handleJoinRequest(participantId, request) {
+        if (!this.state.activeRound)
+            return;
+        const response = await this.state.activeRound.handleJoinRequest(request);
+        await this.sendMessage(participantId, response);
+    }
+    /**
+     * Handle update submission
+     */
+    async handleUpdateSubmission(participantId, submission) {
+        if (!this.state.activeRound)
+            return;
+        await this.state.activeRound.handleUpdateSubmission(submission);
+    }
+    /**
+     * Send message to participant
+     */
+    async sendMessage(participantId, message) {
+        if (this.transport) {
+            await this.transport.send(participantId, message);
+        }
+    }
+    /**
+     * Broadcast message to all participants
+     */
+    async broadcastMessage(message) {
+        if (this.transport) {
+            await this.transport.broadcast(message);
+        }
+    }
+    // ============================================
+    // Checkpointing
+    // ============================================
+    /**
+     * Create a checkpoint of current state
+     */
+    async createCheckpoint() {
+        const metrics = this.buildTrainingMetrics();
+        const checkpoint = this.modelManager.checkpoint(this.state.sessionId, this.state.currentRound, metrics);
+        this.checkpointIds.push(checkpoint.checkpointId);
+        this.emitEvent({
+            type: types_1.FederatedEventType.CHECKPOINT_SAVED,
+            timestamp: Date.now(),
+            sessionId: this.state.sessionId,
+            details: {
+                checkpointId: checkpoint.checkpointId,
+                roundNumber: checkpoint.roundNumber,
+            },
+        });
+    }
+    /**
+     * Restore from checkpoint
+     */
+    restoreFromCheckpoint(checkpointId) {
+        this.modelManager.restoreCheckpoint(checkpointId);
+        const checkpoints = this.modelManager.getCheckpoints();
+        const restored = checkpoints.find((c) => c.checkpointId === checkpointId);
+        if (restored) {
+            this.state.currentRound = restored.roundNumber;
+            this.lossHistory = restored.metrics.lossHistory;
+            this.accuracyHistory = restored.metrics.accuracyHistory ?? [];
+        }
+    }
+    /**
+     * Rollback to previous round
+     */
+    rollback() {
+        return this.modelManager.rollback();
+    }
+    // ============================================
+    // Event Handling
+    // ============================================
+    /**
+     * Handle round events
+     */
+    handleRoundEvent(event, round) {
+        // Forward relevant events
+        switch (event.type) {
+            case FederatedRound_1.RoundEventType.PARTICIPANT_JOINED:
+                this.emitEvent({
+                    type: types_1.FederatedEventType.PARTICIPANT_JOINED,
+                    timestamp: event.timestamp,
+                    sessionId: this.state.sessionId,
+                    roundId: round.getRoundId(),
+                    details: event.details,
+                });
+                break;
+            case FederatedRound_1.RoundEventType.UPDATE_RECEIVED:
+                this.emitEvent({
+                    type: types_1.FederatedEventType.UPDATE_RECEIVED,
+                    timestamp: event.timestamp,
+                    sessionId: this.state.sessionId,
+                    roundId: round.getRoundId(),
+                    details: event.details,
+                });
+                break;
+            case FederatedRound_1.RoundEventType.AGGREGATION_STARTED:
+                this.emitEvent({
+                    type: types_1.FederatedEventType.AGGREGATION_STARTED,
+                    timestamp: event.timestamp,
+                    sessionId: this.state.sessionId,
+                    roundId: round.getRoundId(),
+                    details: event.details,
+                });
+                break;
+            case FederatedRound_1.RoundEventType.AGGREGATION_COMPLETED:
+                this.emitEvent({
+                    type: types_1.FederatedEventType.AGGREGATION_COMPLETED,
+                    timestamp: event.timestamp,
+                    sessionId: this.state.sessionId,
+                    roundId: round.getRoundId(),
+                    details: event.details,
+                });
+                break;
+            case FederatedRound_1.RoundEventType.PARTICIPANT_DROPPED:
+                this.emitEvent({
+                    type: types_1.FederatedEventType.PARTICIPANT_DROPPED,
+                    timestamp: event.timestamp,
+                    sessionId: this.state.sessionId,
+                    roundId: round.getRoundId(),
+                    details: event.details,
+                });
+                break;
+            case FederatedRound_1.RoundEventType.ROUND_TIMED_OUT:
+                this.emitEvent({
+                    type: types_1.FederatedEventType.ROUND_TIMED_OUT,
+                    timestamp: event.timestamp,
+                    sessionId: this.state.sessionId,
+                    roundId: round.getRoundId(),
+                    details: event.details,
+                });
+                break;
+        }
+    }
+    /**
+     * Add event handler
+     */
+    on(handler) {
+        this.eventHandlers.push(handler);
+    }
+    /**
+     * Remove event handler
+     */
+    off(handler) {
+        const index = this.eventHandlers.indexOf(handler);
+        if (index !== -1) {
+            this.eventHandlers.splice(index, 1);
+        }
+    }
+    /**
+     * Emit event to handlers
+     */
+    emitEvent(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch {
+                // Ignore handler errors
+            }
+        }
+    }
+    // ============================================
+    // Result Building
+    // ============================================
+    /**
+     * Build training result
+     */
+    buildTrainingResult(success) {
+        return {
+            success,
+            finalModel: this.modelManager.getWeights(),
+            metrics: this.buildTrainingMetrics(),
+            privacyBudget: this.federatedConfig.differentialPrivacy?.enabled
+                ? this.aggregator.getPrivacyBudget()
+                : undefined,
+            checkpoints: this.checkpointIds,
+            errors: this.errors,
+        };
+    }
+    /**
+     * Build training metrics summary
+     */
+    buildTrainingMetrics() {
+        const avgParticipation = this.roundHistory.length > 0
+            ? this.roundHistory.reduce((sum, r) => sum + r.participationRate, 0) / this.roundHistory.length
+            : 0;
+        const totalCommBytes = this.roundHistory.reduce((sum, r) => sum + r.communicationBytes, 0);
+        return {
+            currentRound: this.state.currentRound,
+            totalRounds: this.state.totalRounds,
+            bestLoss: this.state.bestLoss,
+            bestRound: this.state.bestRound,
+            lossHistory: this.lossHistory,
+            accuracyHistory: this.accuracyHistory.length > 0 ? this.accuracyHistory : undefined,
+            convergenceStatus: this.state.convergenceStatus,
+            startTime: this.state.startTime ?? Date.now(),
+            totalTrainingTime: this.state.endTime
+                ? this.state.endTime - (this.state.startTime ?? 0)
+                : Date.now() - (this.state.startTime ?? Date.now()),
+            totalCommunicationBytes: totalCommBytes,
+            avgParticipationRate: avgParticipation,
+        };
+    }
+    // ============================================
+    // Validation
+    // ============================================
+    /**
+     * Validate configuration
+     */
+    validateConfiguration() {
+        if (!this.federatedConfig.sessionId) {
+            throw new types_1.FederatedError('Session ID is required', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        if (!this.federatedConfig.modelId) {
+            throw new types_1.FederatedError('Model ID is required', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        if (this.federatedConfig.totalRounds < 1) {
+            throw new types_1.FederatedError('Total rounds must be at least 1', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+        if (this.federatedConfig.minParticipation < 0 || this.federatedConfig.minParticipation > 1) {
+            throw new types_1.FederatedError('Min participation must be between 0 and 1', types_1.FederatedErrorCode.INVALID_CONFIG);
+        }
+    }
+    // ============================================
+    // Getters
+    // ============================================
+    /**
+     * Get session ID
+     */
+    getSessionId() {
+        return this.state.sessionId;
+    }
+    /**
+     * Check if training is active
+     */
+    isTraining() {
+        return this.state.isTraining;
+    }
+    /**
+     * Get current round number
+     */
+    getCurrentRound() {
+        return this.state.currentRound;
+    }
+    /**
+     * Get convergence status
+     */
+    getConvergenceStatus() {
+        return this.state.convergenceStatus;
+    }
+    /**
+     * Get current model weights
+     */
+    getModel() {
+        return this.modelManager.getWeights();
+    }
+    /**
+     * Get model manager
+     */
+    getModelManager() {
+        return this.modelManager;
+    }
+    /**
+     * Get aggregator
+     */
+    getAggregator() {
+        return this.aggregator;
+    }
+    /**
+     * Get active round
+     */
+    getActiveRound() {
+        return this.state.activeRound;
+    }
+    /**
+     * Get training metrics
+     */
+    getMetrics() {
+        return this.buildTrainingMetrics();
+    }
+    /**
+     * Get privacy budget
+     */
+    getPrivacyBudget() {
+        if (!this.federatedConfig.differentialPrivacy?.enabled) {
+            return null;
+        }
+        return this.aggregator.getPrivacyBudget();
+    }
+    /**
+     * Get checkpoints
+     */
+    getCheckpoints() {
+        return this.modelManager.getCheckpoints();
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.federatedConfig };
+    }
+    /**
+     * Reset coordinator state
+     */
+    reset() {
+        if (this.state.isTraining) {
+            this.stopTraining('Reset requested');
+        }
+        this.state = {
+            sessionId: this.federatedConfig.sessionId,
+            isTraining: false,
+            currentRound: 0,
+            totalRounds: this.federatedConfig.totalRounds,
+            activeRound: null,
+            convergenceStatus: types_1.ConvergenceStatus.NOT_STARTED,
+            startTime: null,
+            endTime: null,
+            roundsWithoutImprovement: 0,
+            bestLoss: Infinity,
+            bestRound: 0,
+        };
+        this.modelManager.reset();
+        this.aggregator.reset();
+        this.checkpointIds = [];
+        this.errors = [];
+        this.lossHistory = [];
+        this.accuracyHistory = [];
+        this.roundHistory = [];
+    }
+}
+exports.FederatedCoordinator = FederatedCoordinator;
+// ============================================
+// Factory Functions
+// ============================================
+/**
+ * Create a new federated coordinator
+ */
+function createFederatedCoordinator(config) {
+    return new FederatedCoordinator(config);
+}
+/**
+ * Create a minimal federated config
+ */
+function createFederatedConfig(sessionId, modelId, totalRounds, options) {
+    return {
+        ...types_1.DEFAULT_FEDERATED_CONFIG,
+        ...options,
+        sessionId,
+        modelId,
+        totalRounds,
+    };
+}
+//# sourceMappingURL=FederatedCoordinator.js.map