@backendkit-labs/auto-learning 0.1.1 → 0.1.2

package/dist/{index-DnQ9xssn.d.cts → index-CtdA-dkB.d.cts}

@@ -36,11 +36,17 @@ type AnomalyReport$1 = {
     detectedAt: Date;
 };
 type TunableConfig = {
-    timeoutMs: number;
-    maxRetries: number;
-    circuitBreakerThreshold: number;
-    circuitBreakerHalfOpenAfterMs: number;
-    bulkheadMaxConcurrent: number;
+    circuitBreaker: {
+        failureThreshold: number;
+        openTimeoutMs: number;
+    };
+    bulkhead: {
+        maxConcurrentCalls: number;
+    };
+    httpClient: {
+        timeoutMs: number;
+        maxRetries: number;
+    };
 };
 type LearningCycleEvent = {
     cycleId: string;
@@ -189,6 +195,10 @@ type AutoLearningModuleOptions = {
         };
     };
     coreOptions?: Omit<AutoLearningCoreOptions, 'storage' | 'observability'>;
+    adapters?: {
+        circuitBreaker?: boolean;
+        bulkhead?: boolean;
+    };
 };
 declare class AutoLearningModule {
     static forRoot(options?: AutoLearningModuleOptions): DynamicModule;

package/dist/{index-DnQ9xssn.d.ts → index-CtdA-dkB.d.ts}

@@ -36,11 +36,17 @@ type AnomalyReport$1 = {
     detectedAt: Date;
 };
 type TunableConfig = {
-    timeoutMs: number;
-    maxRetries: number;
-    circuitBreakerThreshold: number;
-    circuitBreakerHalfOpenAfterMs: number;
-    bulkheadMaxConcurrent: number;
+    circuitBreaker: {
+        failureThreshold: number;
+        openTimeoutMs: number;
+    };
+    bulkhead: {
+        maxConcurrentCalls: number;
+    };
+    httpClient: {
+        timeoutMs: number;
+        maxRetries: number;
+    };
 };
 type LearningCycleEvent = {
     cycleId: string;
@@ -189,6 +195,10 @@ type AutoLearningModuleOptions = {
         };
     };
     coreOptions?: Omit<AutoLearningCoreOptions, 'storage' | 'observability'>;
+    adapters?: {
+        circuitBreaker?: boolean;
+        bulkhead?: boolean;
+    };
 };
 declare class AutoLearningModule {
     static forRoot(options?: AutoLearningModuleOptions): DynamicModule;

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
@@ -249,11 +259,9 @@ var DEFAULT_TUNER_CONFIG = {
 // src/core/config-tuner/config-tuner.ts
 var import_result3 = require("@backendkit-labs/result");
 var DEFAULT_CONFIG = {
-  timeoutMs: 1e4,
-  maxRetries: 3,
-  circuitBreakerThreshold: 0.5,
-  circuitBreakerHalfOpenAfterMs: 3e4,
-  bulkheadMaxConcurrent: 10
+  circuitBreaker: { failureThreshold: 50, openTimeoutMs: 3e4 },
+  bulkhead: { maxConcurrentCalls: 10 },
+  httpClient: { timeoutMs: 1e4, maxRetries: 3 }
 };
 var ConfigTuner = class {
   constructor(storage, observability, tunerConfig) {
@@ -270,51 +278,56 @@ var ConfigTuner = class {
   listeners = [];
   lastChangeAt = 0;
   getCurrentConfig() {
-    return { ...this.currentConfig };
+    return {
+      circuitBreaker: { ...this.currentConfig.circuitBreaker },
+      bulkhead: { ...this.currentConfig.bulkhead },
+      httpClient: { ...this.currentConfig.httpClient }
+    };
   }
   tune(aggregates, anomalies) {
     if (aggregates.length === 0) {
       return (0, import_result3.ok)(this.getCurrentConfig());
     }
-    const newConfig = { ...this.currentConfig };
-    const changes = {};
+    const newConfig = {
+      circuitBreaker: { ...this.currentConfig.circuitBreaker },
+      bulkhead: { ...this.currentConfig.bulkhead },
+      httpClient: { ...this.currentConfig.httpClient }
+    };
+    const changedSections = /* @__PURE__ */ new Set();
     const maxP95 = Math.max(...aggregates.map((a) => a.p95Ms));
     const targetTimeout = Math.min(
       Math.max(maxP95 * 2, this.config.minTimeoutMs),
       this.config.maxTimeoutMs
     );
-    if (Math.abs(targetTimeout - newConfig.timeoutMs) > this.config.adjustmentStepMs) {
-      newConfig.timeoutMs = this.smoothValue(
-        newConfig.timeoutMs,
-        targetTimeout
-      );
-      changes.timeoutMs = newConfig.timeoutMs;
+    if (Math.abs(targetTimeout - newConfig.httpClient.timeoutMs) > this.config.adjustmentStepMs) {
+      newConfig.httpClient.timeoutMs = this.smoothValue(newConfig.httpClient.timeoutMs, targetTimeout);
+      changedSections.add("httpClient");
     }
     const avgErrorRate = aggregates.reduce((sum, a) => sum + a.errorRate, 0) / aggregates.length;
     if (avgErrorRate > 0.1) {
-      newConfig.maxRetries = Math.min(newConfig.maxRetries + 1, 5);
-      changes.maxRetries = newConfig.maxRetries;
-    } else if (avgErrorRate < 0.01 && newConfig.maxRetries > 1) {
-      newConfig.maxRetries = Math.max(newConfig.maxRetries - 1, 0);
-      changes.maxRetries = newConfig.maxRetries;
+      newConfig.httpClient.maxRetries = Math.min(newConfig.httpClient.maxRetries + 1, 5);
+      changedSections.add("httpClient");
+    } else if (avgErrorRate < 0.01 && newConfig.httpClient.maxRetries > 1) {
+      newConfig.httpClient.maxRetries = Math.max(newConfig.httpClient.maxRetries - 1, 0);
+      changedSections.add("httpClient");
     }
     const criticalAnomalies = anomalies.filter(
       (a) => a.severity === "critical" || a.severity === "high"
     ).length;
     if (criticalAnomalies > 0) {
-      newConfig.circuitBreakerThreshold = Math.max(
-        this.currentConfig.circuitBreakerThreshold - 0.1 * criticalAnomalies,
-        0.1
+      newConfig.circuitBreaker.failureThreshold = Math.max(
+        this.currentConfig.circuitBreaker.failureThreshold - 10 * criticalAnomalies,
+        10
       );
-      changes.circuitBreakerThreshold = newConfig.circuitBreakerThreshold;
+      changedSections.add("circuitBreaker");
     } else if (anomalies.length === 0) {
-      newConfig.circuitBreakerThreshold = Math.min(
-        this.currentConfig.circuitBreakerThreshold + 0.05,
-        0.8
+      newConfig.circuitBreaker.failureThreshold = Math.min(
+        this.currentConfig.circuitBreaker.failureThreshold + 5,
+        80
       );
-      changes.circuitBreakerThreshold = newConfig.circuitBreakerThreshold;
+      changedSections.add("circuitBreaker");
     }
-    if (Object.keys(changes).length > 0) {
+    if (changedSections.size > 0) {
       const now = Date.now();
       if (now - this.lastChangeAt > 6e4) {
         this.currentConfig = newConfig;
@@ -323,6 +336,9 @@ var ConfigTuner = class {
         if (!saveResult.ok) {
           return (0, import_result3.fail)(storageError("Failed to save config", saveResult.error));
         }
+        const changes = Object.fromEntries(
+          [...changedSections].map((s) => [s, newConfig[s]])
+        );
         this.observability.info("Config tuned", { changes });
         this.observability.incrementMetric("config.changes", 1);
         for (const listener of this.listeners) {
@@ -333,7 +349,11 @@ var ConfigTuner = class {
     return (0, import_result3.ok)(this.getCurrentConfig());
   }
   reset() {
-    this.currentConfig = { ...DEFAULT_CONFIG };
+    this.currentConfig = {
+      circuitBreaker: { ...DEFAULT_CONFIG.circuitBreaker },
+      bulkhead: { ...DEFAULT_CONFIG.bulkhead },
+      httpClient: { ...DEFAULT_CONFIG.httpClient }
+    };
     const saveResult = this.storage.saveConfig(this.currentConfig);
     if (!saveResult.ok) {
       return (0, import_result3.fail)(storageError("Failed to reset config", saveResult.error));
@@ -465,9 +485,8 @@ var FeedbackLoop = class {
     const newConfig = tuneResult.value;
     const previousConfig = this.configTuner.getCurrentConfig();
     const configChanges = {};
-    const configKeys = Object.keys(newConfig);
-    for (const key of configKeys) {
-      if (newConfig[key] !== previousConfig[key]) {
+    for (const key of Object.keys(newConfig)) {
+      if (JSON.stringify(newConfig[key]) !== JSON.stringify(previousConfig[key])) {
         configChanges[key] = newConfig[key];
       }
     }
@@ -505,11 +524,9 @@ var FeedbackLoop = class {
 // src/core/persistence/in-memory-storage.ts
 var import_result5 = require("@backendkit-labs/result");
 var DEFAULT_CONFIG2 = {
-  timeoutMs: 1e4,
-  maxRetries: 3,
-  circuitBreakerThreshold: 0.5,
-  circuitBreakerHalfOpenAfterMs: 3e4,
-  bulkheadMaxConcurrent: 10
+  circuitBreaker: { failureThreshold: 50, openTimeoutMs: 3e4 },
+  bulkhead: { maxConcurrentCalls: 10 },
+  httpClient: { timeoutMs: 1e4, maxRetries: 3 }
 };
 function percentile(sorted, p) {
   if (sorted.length === 0) return 0;
@@ -591,7 +608,11 @@ var InMemoryStorage = class {
   }
   saveConfig(config) {
     try {
-      this.config = { ...config };
+      this.config = {
+        circuitBreaker: { ...config.circuitBreaker },
+        bulkhead: { ...config.bulkhead },
+        httpClient: { ...config.httpClient }
+      };
       return (0, import_result5.ok)(void 0);
     } catch (e) {
       return (0, import_result5.fail)(storageError("Failed to save config", e));
@@ -599,7 +620,11 @@ var InMemoryStorage = class {
   }
   loadConfig() {
     try {
-      return (0, import_result5.ok)(this.config);
+      return (0, import_result5.ok)({
+        circuitBreaker: { ...this.config.circuitBreaker },
+        bulkhead: { ...this.config.bulkhead },
+        httpClient: { ...this.config.httpClient }
+      });
     } catch (e) {
       return (0, import_result5.fail)(storageError("Failed to load config", e));
     }
@@ -737,7 +762,7 @@ var AutoLearningCore = class _AutoLearningCore {
 };
 
 // src/nestjs/auto-learning.module.ts
-var import_common2 = require("@nestjs/common");
+var import_common3 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
 
 // src/nestjs/auto-learning.interceptor.ts
@@ -794,6 +819,83 @@ AutoLearningInterceptor = __decorateClass([
   __decorateParam(1, (0, import_common.Inject)(AUTO_LEARNING_INSTANCE))
 ], AutoLearningInterceptor);
 
+// src/nestjs/auto-learning-adapters.service.ts
+var import_common2 = require("@nestjs/common");
+var AutoLearningAdaptersService = class {
+  constructor(core, options, moduleRef) {
+    this.core = core;
+    this.options = options;
+    this.moduleRef = moduleRef;
+  }
+  core;
+  options;
+  moduleRef;
+  cbRegistry = null;
+  bhRegistry = null;
+  async onModuleInit() {
+    await this.resolveRegistries();
+    if (this.cbRegistry || this.bhRegistry) {
+      this.core.onConfigChange((config) => this.applyConfig(config));
+    }
+  }
+  async resolveRegistries() {
+    if (this.options.adapters?.circuitBreaker) {
+      try {
+        const mod = await import("@backendkit-labs/circuit-breaker");
+        this.cbRegistry = this.moduleRef.get(mod.CircuitBreakerRegistry, { strict: false });
+        this.core.observability.info("CircuitBreakerRegistry adapter connected");
+      } catch {
+        this.core.observability.warn(
+          "adapters.circuitBreaker=true but CircuitBreakerModule is not imported \u2014 adapter skipped"
+        );
+      }
+    }
+    if (this.options.adapters?.bulkhead) {
+      try {
+        const mod = await import("@backendkit-labs/bulkhead");
+        this.bhRegistry = this.moduleRef.get(mod.BulkheadRegistry, { strict: false });
+        this.core.observability.info("BulkheadRegistry adapter connected");
+      } catch {
+        this.core.observability.warn(
+          "adapters.bulkhead=true but BulkheadModule is not imported \u2014 adapter skipped"
+        );
+      }
+    }
+  }
+  applyConfig(config) {
+    if (this.cbRegistry) {
+      const allMetrics = this.cbRegistry.getAllMetrics();
+      for (const name of Object.keys(allMetrics)) {
+        const cb = this.cbRegistry.getOrCreate({ name });
+        cb.updateConfig({
+          failureThreshold: config.circuitBreaker.failureThreshold,
+          openTimeoutMs: config.circuitBreaker.openTimeoutMs
+        });
+      }
+      this.core.observability.debug("Circuit breaker config updated", {
+        ...config.circuitBreaker,
+        affected: Object.keys(allMetrics).length
+      });
+    }
+    if (this.bhRegistry) {
+      const allMetrics = this.bhRegistry.getAllMetrics();
+      for (const name of Object.keys(allMetrics)) {
+        const bh = this.bhRegistry.getOrCreate({ name });
+        bh.updateConfig({ maxConcurrentCalls: config.bulkhead.maxConcurrentCalls });
+      }
+      this.core.observability.debug("Bulkhead config updated", {
+        ...config.bulkhead,
+        affected: Object.keys(allMetrics).length
+      });
+    }
+  }
+};
+AutoLearningAdaptersService = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_common2.Inject)(AUTO_LEARNING_INSTANCE)),
+  __decorateParam(1, (0, import_common2.Inject)(AUTO_LEARNING_OPTIONS))
+], AutoLearningAdaptersService);
+
 // src/nestjs/backend-kit-observability-adapter.ts
 var BackendKitObservabilityAdapter = class {
   constructor(logger, metrics) {
@@ -854,7 +956,8 @@ var AutoLearningModule = class {
       {
         provide: import_core.APP_INTERCEPTOR,
         useClass: AutoLearningInterceptor
-      }
+      },
+      AutoLearningAdaptersService
     ];
     return {
       module: AutoLearningModule,
@@ -865,12 +968,12 @@ var AutoLearningModule = class {
   }
 };
 AutoLearningModule = __decorateClass([
-  (0, import_common2.Module)({})
+  (0, import_common3.Module)({})
 ], AutoLearningModule);
 
 // src/nestjs/auto-learning.decorator.ts
-var import_common3 = require("@nestjs/common");
-var AutoLearn = (options) => (0, import_common3.SetMetadata)(AUTO_LEARN_METADATA, options ?? {});
+var import_common4 = require("@nestjs/common");
+var AutoLearn = (options) => (0, import_common4.SetMetadata)(AUTO_LEARN_METADATA, options ?? {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AUTO_LEARNING_INSTANCE,