@mxf-dev/core 2.0.0 → 2.0.2

package/src/services/MemoryService.ts

@@ -552,7 +552,14 @@ export class MemoryService {
                         // Handle agent memory UPDATE
                         if (typeof memoryEventData.id === 'string' && memoryEventData.data) {
                             // CRITICAL: Must subscribe to Observable to trigger execution!
-                            this.updateAgentMemory(memoryEventData.id, memoryEventData.data).subscribe({
+                            // The request context routes the UPDATE_RESULT back to the
+                            // requesting agent with its own operationId — without it the
+                            // SDK's pending save can never observe its result.
+                            this.updateAgentMemory(memoryEventData.id, memoryEventData.data, {
+                                operationId: memoryEventData.operationId,
+                                requesterAgentId: event.agentId,
+                                requesterChannelId: event.channelId
+                            }).subscribe({
                                 next: () => null,
                                 error: (err) => this.logger.error(`Agent memory update failed for ${memoryEventData.id}: ${err}`)
                             });
@@ -702,11 +709,27 @@ export class MemoryService {
     
     /**
      * Update agent memory
+     *
+     * When the update was requested over the wire (SDK → Events.Memory.UPDATE),
+     * requestContext carries the requester's operationId and identity. The
+     * UPDATE_RESULT emitted here must echo that operationId and be addressed to
+     * the requesting agent: the SDK matches results by operationId, and event
+     * forwarding routes them by payload.agentId. Before this parameter existed,
+     * agent-scope results were emitted with a freshly generated operationId under
+     * SYSTEM_AGENT — no SDK save round-trip could ever observe its own result, so
+     * every awaited save hung forever and every fire-and-forget save leaked its
+     * result listener.
+     *
      * @param pAgentId Agent ID
      * @param updates Memory updates
+     * @param requestContext Requester identity for result routing (wire requests only)
      * @returns Observable of updated agent memory
      */
-    public updateAgentMemory(pAgentId: string, updates: Partial<IEnhancedAgentMemory>): Observable<IEnhancedAgentMemory> {
+    public updateAgentMemory(
+        pAgentId: string,
+        updates: Partial<IEnhancedAgentMemory>,
+        requestContext?: { operationId: string; requesterAgentId: AgentId; requesterChannelId: ChannelId }
+    ): Observable<IEnhancedAgentMemory> {
         this.validator.assertIsNonEmptyString(pAgentId, 'Agent ID must be a non-empty string');
         this.validator.assertIsObject(updates, 'Updates must be an object');
         
@@ -777,8 +800,11 @@ export class MemoryService {
                     }
                 }
 
-                // Emit update event through EventBus
-                const operationId = uuidv4(); // Generate operationId for the event data
+                // Emit update event through EventBus. Echo the requester's
+                // operationId and address the result to the requesting agent so
+                // the SDK's pending save resolves; internal callers (no
+                // requestContext) keep the system-level identity.
+                const operationId = requestContext?.operationId ?? uuidv4();
                 const updateResultData: MemoryUpdateResultEventData = {
                     operationId,
                     scope: MemoryScope.AGENT,
@@ -786,14 +812,13 @@ export class MemoryService {
                     memory: updatedMemory
                 };
 
-                // Define standard agentId and channelId for system-level memory events
-                const systemAgentId: AgentId = 'SYSTEM_AGENT'; // Or a more specific system agent ID
-                const noChannelId: ChannelId = 'NO_CHANNEL';   // Or a more specific system channel ID or null if appropriate
+                const resultAgentId: AgentId = requestContext?.requesterAgentId ?? 'SYSTEM_AGENT';
+                const resultChannelId: ChannelId = requestContext?.requesterChannelId ?? 'NO_CHANNEL';
 
                 const payload = createMemoryUpdateResultEventPayload(
                     Events.Memory.UPDATE_RESULT,
-                    systemAgentId,
-                    noChannelId,
+                    resultAgentId,
+                    resultChannelId,
                     updateResultData
                 );
                 EventBus.server.emit(Events.Memory.UPDATE_RESULT, payload);
@@ -801,22 +826,21 @@ export class MemoryService {
                 observer.next(updatedMemory);
                 observer.complete();
             }, error => {
-                const operationId_agent_update_error = uuidv4();
+                // Errors must reach the requester too — a save whose failure is
+                // only logged server-side leaves the requesting SDK waiting forever.
                 const updateResultData_agent_update_error: MemoryUpdateResultEventData = {
-                    operationId: operationId_agent_update_error,
+                    operationId: requestContext?.operationId ?? uuidv4(),
                     scope: MemoryScope.AGENT,
                     id: pAgentId,
                     memory: null,
                     error: (error as Error).message
                 };
-                const systemAgentId_agent_update_error: AgentId = 'SYSTEM_AGENT'; // Or a more specific system agent ID
-                const noChannelId_agent_update_error: ChannelId = 'NO_CHANNEL';   // Or a more specific system channel ID or null if appropriate
                 EventBus.server.emit(
-                    Events.Memory.UPDATE_RESULT, 
+                    Events.Memory.UPDATE_RESULT,
                     createMemoryUpdateResultEventPayload(
                         Events.Memory.UPDATE_RESULT,
-                        systemAgentId_agent_update_error,
-                        noChannelId_agent_update_error,
+                        requestContext?.requesterAgentId ?? 'SYSTEM_AGENT',
+                        requestContext?.requesterChannelId ?? 'NO_CHANNEL',
                         updateResultData_agent_update_error
                     )
                 );

package/src/services/MxfMLService.ts

@@ -480,6 +480,16 @@ export class MxfMLService {
             throw new Error(`[MxfMLService] Model "${modelId}" has not been built yet`);
         }
 
+        // Fail fast on concurrent training: TF.js rejects overlapping fit() calls
+        // on a single model, and two callers would race on this entry's status
+        // and metrics. Callers must serialize training per model.
+        if (entry.status === ModelStatus.TRAINING) {
+            throw new Error(
+                `[MxfMLService] Model "${modelId}" is already training — ` +
+                `concurrent training on the same model is not allowed`
+            );
+        }
+
         if (xData.length < entry.config.minTrainingSamples) {
             throw new Error(
                 `[MxfMLService] Insufficient training data for "${modelId}": ` +
@@ -497,10 +507,14 @@ export class MxfMLService {
         entry.status = ModelStatus.TRAINING;
         const startTime = Date.now();
 
+        // fit() is async, so tf.tidy() cannot wrap it — create the tensors
+        // eagerly and dispose them in finally so a failed fit() does not leak.
+        let xs: import('@tensorflow/tfjs').Tensor2D | undefined;
+        let ys: import('@tensorflow/tfjs').Tensor2D | undefined;
+
         try {
-            // Create tensors inside tidy to prevent leaks during training setup
-            const xs = tfRef.tensor2d(xData);
-            const ys = tfRef.tensor2d(yData);
+            xs = tfRef.tensor2d(xData);
+            ys = tfRef.tensor2d(yData);
 
             const layersModel = entry.model as any;
             const result = await layersModel.fit(xs, ys, {
@@ -524,10 +538,6 @@ export class MxfMLService {
                 samplesUsed: xData.length,
             };
 
-            // Clean up tensors
-            xs.dispose();
-            ys.dispose();
-
             // Update model state
             entry.status = ModelStatus.TRAINED;
             entry.lastTrainingMetrics = metrics;
@@ -554,6 +564,9 @@ export class MxfMLService {
 
             this.logger.error(`[MxfMLService] Training failed for ${modelId}: ${errorMsg}`);
             throw error;
+        } finally {
+            xs?.dispose();
+            ys?.dispose();
         }
     }
 
@@ -586,6 +599,14 @@ export class MxfMLService {
             throw new Error(`[MxfMLService] Model "${modelId}" has not been built yet`);
         }
 
+        // Fail fast on concurrent training (same contract as train())
+        if (entry.status === ModelStatus.TRAINING) {
+            throw new Error(
+                `[MxfMLService] Model "${modelId}" is already training — ` +
+                `concurrent training on the same model is not allowed`
+            );
+        }
+
         // Emit training started (we don't know sample count upfront for custom training)
         this.emitTrainingStarted(modelId, 0, entry.config.epochs);
 
@@ -1067,6 +1088,11 @@ export class MxfMLService {
      *
      * Calls the provided trainCallback at the model's retrainIntervalMs.
      * The callback is responsible for collecting training data and calling train().
+     * No-ops when auto-training is disabled (autoTrainEnabled=false).
+     *
+     * A model must have exactly one retraining owner: either a timer registered
+     * here or a consumer-managed schedule — never both. Overlapping schedules
+     * train on the same data twice and collide on TF.js fit() calls.
      *
      * @param modelId - ID of a registered model
      * @param trainCallback - Function to call when retraining is due
@@ -1077,6 +1103,14 @@ export class MxfMLService {
     ): void {
         const entry = this.getModelEntry(modelId);
 
+        if (!getTensorFlowConfig().autoTrainEnabled) {
+            this.logger.info(
+                `[MxfMLService] Auto-training disabled (autoTrainEnabled=false), ` +
+                `not scheduling retrain for ${modelId}`
+            );
+            return;
+        }
+
         // Clear any existing timer for this model
         const existingTimer = this.retrainTimers.get(modelId);
         if (existingTimer) {

package/src/services/PredictiveAnalyticsService.ts

@@ -460,13 +460,10 @@ export class PredictiveAnalyticsService extends EventEmitter {
             );
         }
 
-        // Schedule automatic retraining with MxfMLService
-        const config = getTensorFlowConfig();
-        if (config.autoTrainEnabled) {
-            mlService.scheduleRetrain(TF_ERROR_PREDICTION_MODEL_ID, async () => {
-                await this.trainErrorPredictionModel();
-            });
-        }
+        // Retraining is owned by this service's own interval (startRetrainSchedule),
+        // which trains both models sequentially. Do NOT also register an
+        // MxfMLService.scheduleRetrain() timer — a second schedule for the same
+        // model trains twice per interval and collides on concurrent fit() calls.
     }
 
     // =============================================================================
@@ -563,13 +560,8 @@ export class PredictiveAnalyticsService extends EventEmitter {
             );
         }
 
-        // Schedule automatic retraining with MxfMLService
-        const config = getTensorFlowConfig();
-        if (config.autoTrainEnabled) {
-            mlService.scheduleRetrain(TF_ANOMALY_AUTOENCODER_MODEL_ID, async () => {
-                await this.trainAnomalyDetectionModel();
-            });
-        }
+        // Retraining is owned by this service's own interval (startRetrainSchedule) —
+        // see the note in initializeTfErrorPrediction().
     }
 
     // =============================================================================
@@ -1739,6 +1731,8 @@ export class PredictiveAnalyticsService extends EventEmitter {
      *
      * When TF.js is enabled and sufficient training samples exist:
      * - Vectorizes features and binary labels from collected training data
+     * - Requires both label classes to be present (see the class-balance guard
+     *   below) — one-class data cannot train a discriminator
      * - Calls MxfMLService.train() to run supervised training on the Dense classifier
      * - Updates internal model metadata with real training metrics
      * - Saves the trained model to persistent storage (GridFS)
@@ -1794,6 +1788,28 @@ export class PredictiveAnalyticsService extends EventEmitter {
                     return;
                 }
 
+                // One-class data cannot train a discriminator: binary crossentropy
+                // drives the sigmoid to a constant, reporting perfect accuracy while
+                // learning nothing. Require both classes, each meeting a minority
+                // floor that scales with the sample count.
+                const positives = labels.reduce((sum, label) => sum + label, 0);
+                const negatives = labels.length - positives;
+                const minorityFloor = Math.max(3, Math.ceil(labels.length * 0.02));
+                if (positives < minorityFloor || negatives < minorityFloor) {
+                    this.logger.info(
+                        `[PredictiveAnalyticsService] Skipping TF.js error prediction training — ` +
+                        `class balance too skewed (positives=${positives}, negatives=${negatives}, ` +
+                        `minority floor=${minorityFloor}). Heuristic prediction remains active.`
+                    );
+                    if (!this.tfErrorPredictionReady) {
+                        // No usable TF model — keep heuristic bookkeeping current
+                        this.updateHeuristicMetadata(features.length);
+                    }
+                    // A previously trained model (this session or loaded from storage)
+                    // keeps serving; skipping retraining must not clobber its metadata.
+                    return;
+                }
+
                 // Format labels as 2D array for MxfMLService.train()
                 const yData = labels.map(l => [l]);
 
@@ -1811,10 +1827,11 @@ export class PredictiveAnalyticsService extends EventEmitter {
                     modelMeta.type = ModelType.NEURAL_NETWORK;
                     modelMeta.trainedAt = Date.now();
                     modelMeta.trainingDataSize = features.length;
+                    // Prefer validation accuracy — training accuracy overstates fit.
                     // If training reported no accuracy, we do not know the accuracy. Say so.
                     // This previously fell back to 0.75 — an invented figure indistinguishable
                     // from a measured one.
-                    modelMeta.accuracy = metrics.accuracy ?? metrics.valAccuracy ?? null;
+                    modelMeta.accuracy = metrics.valAccuracy ?? metrics.accuracy ?? null;
                     modelMeta.validationMetrics = {
                         accuracy: metrics.accuracy ?? 0,
                         val_accuracy: metrics.valAccuracy ?? 0,
@@ -2254,13 +2271,23 @@ export class PredictiveAnalyticsService extends EventEmitter {
     /**
      * Start retrain schedule.
      *
-     * When TF.js is enabled, both error prediction and anomaly detection
-     * retraining are managed by MxfMLService.scheduleRetrain() (configured
-     * in initializeTfErrorPrediction() and initializeTfAnomalyAutoencoder()).
-     * This interval serves as the retraining path when TF.js is disabled
-     * and as a fallback when MxfMLService scheduling is not active.
+     * This interval is the single owner of scheduled retraining. trainModels()
+     * trains the error predictor and the anomaly autoencoder sequentially —
+     * TF.js rejects overlapping fit() calls on one model, and a single timer
+     * avoids overlapping training cycles entirely. Registering per-model
+     * MxfMLService.scheduleRetrain() timers alongside this interval caused
+     * duplicate hourly training and fit() collisions.
+     *
+     * When TF.js is enabled, autoTrainEnabled gates scheduled retraining.
+     * When TF.js is disabled, the interval refreshes heuristic metadata.
      */
     private startRetrainSchedule(): void {
+        if (isTensorFlowEnabled() && !getTensorFlowConfig().autoTrainEnabled) {
+            this.logger.info(
+                '[PredictiveAnalyticsService] TF.js auto-training disabled, not scheduling model retraining'
+            );
+            return;
+        }
         this.retrainInterval = setInterval(() => {
             this.trainModels();
         }, this.config.retrainInterval);

package/src/types/NetworkRecoveryTypes.ts

@@ -34,6 +34,13 @@ export enum NetworkErrorType {
     NETWORK_CONNECTION_REFUSED = 'NETWORK_CONNECTION_REFUSED',
     NETWORK_DNS_RESOLUTION = 'NETWORK_DNS_RESOLUTION',
     NETWORK_SOCKET_ERROR = 'NETWORK_SOCKET_ERROR',
+
+    // Hard per-request timeout: the request ran for the full configured bound
+    // (requestTimeoutMs / a stream idle bound) without completing. Deliberately
+    // NOT retryable — retrying a request that just consumed the entire timeout
+    // budget would multiply the silence the timeout exists to end. The caller
+    // gets the failure immediately.
+    REQUEST_TIMEOUT = 'REQUEST_TIMEOUT',
     
     // API service issues
     API_BAD_GATEWAY = 'API_BAD_GATEWAY',              // 502
@@ -205,9 +212,18 @@ export function classifyNetworkError(
         }
     }
     
+    // Hard request timeouts are marked explicitly: either by AbortSignal.timeout()
+    // (DOMException named 'TimeoutError' in both Node and Bun) or by the
+    // isRequestTimeout flag set where the timeout is enforced. Checked before the
+    // message heuristics below so a hard timeout is never misclassified as a
+    // retryable NETWORK_TIMEOUT.
+    if (error?.isRequestTimeout === true || error?.name === 'TimeoutError') {
+        return NetworkErrorType.REQUEST_TIMEOUT;
+    }
+
     // Check error message for network issues
     const errorMessage = error?.message?.toLowerCase() || '';
-    
+
     if (errorMessage.includes('timeout')) {
         return NetworkErrorType.NETWORK_TIMEOUT;
     }