@splashcodex/api-key-manager 4.0.0 → 5.0.0

package/README.md

@@ -1,9 +1,17 @@
-# @splashcodex/ApiKeyManager v4.0 — Mastermind Edition
+# @splashcodex/ApiKeyManager v5.0 — Ecosystem Edition
 
-> Universal API Key Rotation System with Resilience, Load Balancing, Semantic Caching & AI Gateway Features
+> Universal API Key Management Gateway with Provider Presets, Built-in Persistence, and Multi-Provider Vault.
 
 [![npm version](https://img.shields.io/npm/v/@splashcodex/ApiKeyManager)](https://www.npmjs.com/package/@splashcodex/ApiKeyManager)
 
+## New in v5.0 (Ecosystem Edition)
+
+- **Provider Presets** — One-line setup for `GeminiManager`, `OpenAIManager`, and `MultiManager`.
+- **Automatic Env Parsing** — Reads `GOOGLE_GEMINI_API_KEY`, `OPENAI_API_KEY`, etc. (supports JSON arrays and comma-separated strings).
+- **Built-in Persistence** — `FileStorage` (survives restarts) and `MemoryStorage` included.
+- **Singleton Pattern** — Thread-safe singletons with `getInstance()` and `Result<T>` pattern.
+- **Multi-Provider Vault** — Manage multiple providers (`gemini`, `openai`, `anthropic`) from a single entry point.
+
 ## Features
 
 - **Circuit Breaker** — Keys transition through `CLOSED → OPEN → HALF_OPEN → DEAD`
@@ -12,15 +20,9 @@
 - **`execute()` Wrapper** — Single method: get key → call → latency → retry → fallback
 - **Event Emitter** — Typed lifecycle hooks for monitoring & alerting
 - **Auto-Retry with Backoff** — Built-in retry loop with exponential backoff + jitter
-- **Request Timeout** — `AbortController`-based timeout per attempt
-- **Fallback Function** — Graceful degradation when all keys fail
-- **Provider Tagging** — Multi-provider routing (`openai`, `gemini`, etc.)
-- **Health Checks** — Periodic key validation and auto-recovery
-- **Bulkhead / Concurrency** — Limits concurrent `execute()` calls
-- **Semantic Cache** *(v4 NEW)* — Cosine-similarity cache with pluggable embeddings
-- **Recursion Guard** *(v4 NEW)* — Prevents infinite loops when `getEmbedding` calls `execute()`
-- **State Persistence** — Survives restarts via pluggable storage
-- **100% Backward Compatible** — v1.x, v2.x, and v3.x code works without changes
+- **Semantic Cache** — Cosine-similarity cache with pluggable embeddings
+- **Streaming Support** — `executeStream()` with initial retry + cache replay
+- **100% Backward Compatible** — v1.x through v4.x code works without changes
 
 ## Installation
 
@@ -28,230 +30,142 @@
 npm install @splashcodex/api-key-manager
 ```
 
-## Quick Start
+## Quick Start (v5 Presets)
+
+The fastest way to get started in any CodeDex repository.
+
+### Gemini Preset
+Reads `GOOGLE_GEMINI_API_KEY` or `GEMINI_API_KEY` from environment.
 
 ```typescript
-import { ApiKeyManager } from '@splashcodex/api-key-manager';
+import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
 
-// Simple (v1/v2 compatible)
-const manager = new ApiKeyManager(['key1', 'key2', 'key3']);
-const key = manager.getKey();
-manager.markSuccess(key!);
+const result = GeminiManager.getInstance();
+if (!result.success) throw result.error;
 
-// v3+ — Full power
-const result = await manager.execute(
-  (key) => fetch(`https://api.example.com?key=${key}`),
-  { maxRetries: 3, timeoutMs: 5000 }
-);
+const gemini = result.data;
+const response = await gemini.execute(async (key) => {
+    // result.data is the underlying ApiKeyManager
+    return await callGemini(key, "Hello!");
+});
 ```
 
-## v4.0 — Semantic Cache (Mastermind Edition)
-
-Automatically cache API responses by semantic similarity. Identical or near-identical prompts return cached results without consuming API quota.
+### Multi-Provider Vault
+Perfect for gateways or complex bots handling multiple models.
 
 ```typescript
-import { ApiKeyManager } from '@splashcodex/api-key-manager';
+import { MultiManager } from '@splashcodex/api-key-manager/presets/multi';
 
-const manager = new ApiKeyManager(['key1', 'key2'], {
-  semanticCache: {
-    threshold: 0.92,  // 92% cosine similarity to match
-    ttlMs: 86400000,  // 24-hour TTL (default)
-    getEmbedding: async (text) => {
-      // Your embedding function (e.g. OpenAI, Gemini, local model)
-      return await myEmbeddingModel.embed(text);
+const vault = MultiManager.getInstance({
+    providers: {
+        gemini: { envKeys: ['GOOGLE_GEMINI_API_KEY'] },
+        openai: { envKeys: ['OPENAI_API_KEY'] }
     }
-  }
-});
+}).data!;
 
-// First call → API hit, cached
-const r1 = await manager.execute(apiFn, { prompt: 'What is the weather?' });
-
-// Second call → Semantic Cache HIT (no API call)
-const r2 = await manager.execute(apiFn, { prompt: 'How is the weather today?' });
+// Route by provider
+const res = await vault.execute(fn, { provider: 'gemini' });
 ```
 
-> **Recursion Guard**: If your `getEmbedding` callback internally calls `execute()`,
-> the cache automatically skips on nested calls to prevent infinite recursion.
+---
 
-## execute() Wrapper
+## v5.0 — Architecture & Persistence
 
-Wraps the entire lifecycle into one method:
+### Built-in Persistence
+State (cooling down keys, dead keys) now survives application restarts by default.
 
 ```typescript
+import { FileStorage } from '@splashcodex/api-key-manager/persistence/file';
+
 const manager = new ApiKeyManager(keys, {
-  storage: localStorage,
-  strategy: new WeightedStrategy(),
-  fallbackFn: () => cachedResponse,
-  concurrency: 10
+    storage: new FileStorage({
+        filePath: './api_state.json'
+    })
 });
-
-const result = await manager.execute(
-  async (key, signal) => {
-    const res = await fetch(url, { headers: { 'x-api-key': key }, signal });
-    return res.json();
-  },
-  { maxRetries: 3, timeoutMs: 10000 }
-);
-// Handles: key selection → cache → timeout → retry → fallback → latency tracking
 ```
 
-## Event Emitter
-
-Monitor every state change:
+### Subpath Imports
+To keep your bundles small, you can import only what you need:
 
 ```typescript
-manager.on('keyDead', (key) => alertTeam(`Key ${key} permanently dead`));
-manager.on('circuitOpen', (key) => metrics.increment('circuit_opens'));
-manager.on('keyRecovered', (key) => log(`Key ${key} recovered`));
-manager.on('retry', (key, attempt, delay) => log(`Retry #${attempt} in ${delay}ms`));
-manager.on('fallback', (reason) => log(`Fallback triggered: ${reason}`));
-manager.on('allKeysExhausted', () => alert('No healthy keys!'));
-manager.on('bulkheadRejected', () => metrics.increment('rejected'));
-manager.on('healthCheckPassed', (key) => log(`${key} healthy`));
-manager.on('healthCheckFailed', (key, err) => log(`${key} unhealthy`));
+import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
+import { FileStorage } from '@splashcodex/api-key-manager/persistence/file';
 ```
 
-## Load Balancing Strategies
+---
 
-### Weighted (Cost Optimization)
-
-```typescript
-import { ApiKeyManager, WeightedStrategy } from '@splashcodex/api-key-manager';
-
-const manager = new ApiKeyManager(
-  [
-    { key: 'free-key-1', weight: 1.0 },
-    { key: 'free-key-2', weight: 1.0 },
-    { key: 'paid-backup', weight: 0.1 },
-  ],
-  { strategy: new WeightedStrategy() }
-);
-```
+## v4.0 — Semantic Cache
 
-### Latency (Performance)
+Automatically cache API responses by semantic similarity.
 
 ```typescript
-import { ApiKeyManager, LatencyStrategy } from '@splashcodex/api-key-manager';
+const manager = new ApiKeyManager(['key1', 'key2'], {
+  semanticCache: {
+    threshold: 0.92,
+    getEmbedding: async (text) => await myModel.embed(text)
+  }
+});
 
-const manager = new ApiKeyManager(keys, { strategy: new LatencyStrategy() });
-// After execute(), latency is tracked automatically
+// Cache HIT if prompt is semantically similar
+const r1 = await manager.execute(apiFn, { prompt: 'What is the weather?' });
+const r2 = await manager.execute(apiFn, { prompt: 'How is the weather today?' });
 ```
 
-## Provider Tagging
-
-Route requests to specific providers:
+### v4.1 — Streaming Support
+Real-time response handling with the same resilience as `execute()`.
 
 ```typescript
-const manager = new ApiKeyManager([
-  { key: 'sk-openai-1', weight: 1.0, provider: 'openai' },
-  { key: 'sk-openai-2', weight: 1.0, provider: 'openai' },
-  { key: 'AIza-gemini',  weight: 0.5, provider: 'gemini' },
-]);
-
-const openaiKey = manager.getKeyByProvider('openai');
-const geminiKey = manager.getKeyByProvider('gemini');
-```
+const stream = await manager.executeStream(async (key) => {
+    return await gemini.generateContentStream({ prompt: "..." });
+}, { prompt: "..." });
 
-## Health Checks
+for await (const chunk of stream) {
+    console.log(chunk.text());
+}
+```
 
-Proactively detect recovered keys:
+---
 
-```typescript
-manager.setHealthCheck(async (key) => {
-  const res = await fetch(`https://api.openai.com/v1/models`, {
-    headers: { Authorization: `Bearer ${key}` }
-  });
-  return res.ok;
-});
-
-manager.startHealthChecks(60_000); // Check every 60 seconds
-// manager.stopHealthChecks();     // Stop when done
-```
+## execute() Wrapper
 
-## Error Handling
+Wraps the entire lifecycle into one method:
 
 ```typescript
-try {
-  const result = await callApi(key);
-  manager.markSuccess(key, duration);
-} catch (error) {
-  const classification = manager.classifyError(error);
-  manager.markFailed(key, classification);
-
-  if (classification.retryable) {
-    const delay = manager.calculateBackoff(attempt);
-    await sleep(delay);
-  }
-}
+const result = await manager.execute(
+  async (key, signal) => {
+    const res = await fetch(url, { headers: { 'x-api-key': key }, signal });
+    return res.json();
+  },
+  { maxRetries: 3, timeoutMs: 10000 }
+);
 ```
 
 ## API Reference
 
-### Constructor
+### Presets
 
-```typescript
-// Legacy (v1/v2)
-new ApiKeyManager(keys, storage?, strategy?)
-
-// v3+ Options
-new ApiKeyManager(keys, {
-  storage?,        // Pluggable storage { getItem, setItem }
-  strategy?,       // LoadBalancingStrategy instance
-  fallbackFn?,     // () => any — called when all keys exhausted
-  concurrency?,    // Max concurrent execute() calls
-  semanticCache?,  // v4: { threshold, ttlMs, getEmbedding }
-})
-```
+| Class | Env Vars | Description |
+|-------|----------|-------------|
+| `GeminiManager` | `GOOGLE_GEMINI_API_KEY`, `GEMINI_API_KEY` | Gemini-optimized singleton |
+| `OpenAIManager` | `OPENAI_API_KEY` | OpenAI-optimized singleton |
+| `MultiManager` | Custom | Vault for multiple provider pools |
+
+### Persistence
+
+| Class | Description |
+|-------|-------------|
+| `FileStorage` | Persists to a JSON file (recommended for servers) |
+| `MemoryStorage` | In-memory only (best for serverless/short-lived) |
 
-### Methods
+### Core Methods
 
 | Method | Description |
 |--------|-------------|
-| `getKey()` | Returns best available key via strategy |
-| `getKeyByProvider(provider)` | Get key filtered by provider tag |
-| `markSuccess(key, durationMs?)` | Report success + optional latency |
-| `markFailed(key, classification)` | Report failure with error type |
-| `classifyError(error, finishReason?)` | Classify an error automatically |
-| `execute(fn, options?)` | Full lifecycle wrapper with retry/timeout |
-| `calculateBackoff(attempt)` | Get backoff delay with jitter |
-| `getStats()` | Get pool health statistics |
-| `getKeyCount()` | Count of non-DEAD keys |
-| `setHealthCheck(fn)` | Set health check function |
-| `startHealthChecks(ms)` | Start periodic health checks |
-| `stopHealthChecks()` | Stop health checks |
-
-### Events
-
-| Event | Payload | Trigger |
-|-------|---------|---------|
-| `keyDead` | `key: string` | Key marked as permanently dead |
-| `circuitOpen` | `key: string` | Key circuit opened (cooldown) |
-| `circuitHalfOpen` | `key: string` | Key entering test phase |
-| `keyRecovered` | `key: string` | Key recovered from failure |
-| `fallback` | `reason: string` | Fallback function invoked |
-| `allKeysExhausted` | — | All keys dead, no fallback |
-| `retry` | `key, attempt, delayMs` | Retry attempt starting |
-| `executeSuccess` | `key, durationMs` | execute() completed successfully |
-| `executeFailed` | `key, error` | execute() attempt failed |
-| `bulkheadRejected` | — | Concurrency limit reached |
-| `healthCheckPassed` | `key: string` | Health check succeeded |
-| `healthCheckFailed` | `key, error` | Health check failed |
-
-### Custom Errors
-
-| Error | When |
-|-------|------|
-| `TimeoutError` | Request exceeded `timeoutMs` |
-| `BulkheadRejectionError` | Concurrency limit exceeded |
-| `AllKeysExhaustedError` | All keys dead, no fallback |
-
-### Strategies
-
-| Strategy | Algorithm | Best For |
-|----------|-----------|----------|
-| `StandardStrategy` | Least Failures → LRU | General use |
-| `WeightedStrategy` | Probabilistic by weight | Cost optimization |
-| `LatencyStrategy` | Lowest avg latency | Performance |
+| `execute(fn, opts)` | Standard wrapper |
+| `executeStream(fn, opts)` | Streaming wrapper |
+| `getStats()` | Get pool health |
+| `getKey()` | Manual key rotation |
+| `markFailed(key, err)` | Manual failure reporting |
 
 ## License
 

package/dist/index.d.ts

@@ -1,11 +1,16 @@
 /**
- * Universal ApiKeyManager v4.0 — Mastermind Edition
+ * Universal ApiKeyManager v5.0 — Ecosystem Edition
  * Implements: Rotation, Circuit Breaker, Persistence, Exponential Backoff, Strategies,
  *             Event Emitter, Fallback, execute(), Timeout, Auto-Retry, Provider Tags,
  *             Health Checks, Bulkhead/Concurrency
+ * NEW in v5.0: Provider Presets (GeminiManager, OpenAIManager, MultiManager),
+ *              Built-in Persistence (FileStorage, MemoryStorage)
  * Gemini-Specific: finishReason handling, Safety blocks, RECITATION detection
  */
 import { EventEmitter } from 'events';
+export { FileStorage } from './persistence/file';
+export type { FileStorageOptions } from './persistence/file';
+export { MemoryStorage } from './persistence/memory';
 export interface KeyState {
     key: string;
     failCount: number;
@@ -103,7 +108,7 @@ export declare class WeightedStrategy implements LoadBalancingStrategy {
     next(candidates: KeyState[]): KeyState | null;
 }
 /**
- * Latency Strategy: Pick lowest average latency
+ * Latency Strategy: Pick lowest average latency with LRU tie-break
  */
 export declare class LatencyStrategy implements LoadBalancingStrategy {
     next(candidates: KeyState[]): KeyState | null;
@@ -185,6 +190,21 @@ export declare class ApiKeyManager extends EventEmitter {
     execute<T>(fn: (key: string, signal?: AbortSignal) => Promise<T>, options?: ExecuteOptions & {
         prompt?: string;
     }): Promise<T>;
+    /**
+     * Executes a streaming function (AsyncGenerator) with retry logic and semantic caching.
+     *
+     * @example
+     *   const stream = await manager.executeStream(async (key) => {
+     *     return await gemini.generateContentStream({ prompt: "..." });
+     *   }, { prompt: "..." });
+     *
+     *   for await (const chunk of stream) {
+     *     console.log(chunk.text());
+     *   }
+     */
+    executeStream<T>(fn: (key: string, signal?: AbortSignal) => AsyncGenerator<T, any, unknown>, options?: ExecuteOptions & {
+        prompt?: string;
+    }): AsyncGenerator<T, any, unknown>;
     private _executeWithRetry;
     private _executeWithTimeout;
     private _sleep;

package/dist/index.js

@@ -1,14 +1,22 @@
 "use strict";
 /**
- * Universal ApiKeyManager v4.0 — Mastermind Edition
+ * Universal ApiKeyManager v5.0 — Ecosystem Edition
  * Implements: Rotation, Circuit Breaker, Persistence, Exponential Backoff, Strategies,
  *             Event Emitter, Fallback, execute(), Timeout, Auto-Retry, Provider Tags,
  *             Health Checks, Bulkhead/Concurrency
+ * NEW in v5.0: Provider Presets (GeminiManager, OpenAIManager, MultiManager),
+ *              Built-in Persistence (FileStorage, MemoryStorage)
  * Gemini-Specific: finishReason handling, Safety blocks, RECITATION detection
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiKeyManager = exports.SemanticCache = exports.LatencyStrategy = exports.WeightedStrategy = exports.StandardStrategy = exports.AllKeysExhaustedError = exports.BulkheadRejectionError = exports.TimeoutError = void 0;
+exports.ApiKeyManager = exports.SemanticCache = exports.LatencyStrategy = exports.WeightedStrategy = exports.StandardStrategy = exports.AllKeysExhaustedError = exports.BulkheadRejectionError = exports.TimeoutError = exports.MemoryStorage = exports.FileStorage = void 0;
 const events_1 = require("events");
+// ─── Re-exports: Persistence ─────────────────────────────────────────────────
+// Persistence adapters can be imported from root or via subpath
+var file_1 = require("./persistence/file");
+Object.defineProperty(exports, "FileStorage", { enumerable: true, get: function () { return file_1.FileStorage; } });
+var memory_1 = require("./persistence/memory");
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return memory_1.MemoryStorage; } });
 // ─── Config ──────────────────────────────────────────────────────────────────
 const CONFIG = {
     MAX_CONSECUTIVE_FAILURES: 5,
@@ -83,13 +91,17 @@ class WeightedStrategy {
 }
 exports.WeightedStrategy = WeightedStrategy;
 /**
- * Latency Strategy: Pick lowest average latency
+ * Latency Strategy: Pick lowest average latency with LRU tie-break
  */
 class LatencyStrategy {
     next(candidates) {
         if (candidates.length === 0)
             return null;
-        candidates.sort((a, b) => a.averageLatency - b.averageLatency);
+        candidates.sort((a, b) => {
+            if (a.averageLatency !== b.averageLatency)
+                return a.averageLatency - b.averageLatency;
+            return a.lastUsed - b.lastUsed; // LRU tie-break
+        });
         return candidates[0];
     }
 }
@@ -501,6 +513,127 @@ class ApiKeyManager extends events_1.EventEmitter {
             this.activeCalls--;
         }
     }
+    /**
+     * Executes a streaming function (AsyncGenerator) with retry logic and semantic caching.
+     *
+     * @example
+     *   const stream = await manager.executeStream(async (key) => {
+     *     return await gemini.generateContentStream({ prompt: "..." });
+     *   }, { prompt: "..." });
+     *
+     *   for await (const chunk of stream) {
+     *     console.log(chunk.text());
+     *   }
+     */
+    async *executeStream(fn, options) {
+        const maxRetries = options?.maxRetries ?? 0;
+        const timeoutMs = options?.timeoutMs;
+        const finishReason = options?.finishReason;
+        const prompt = options?.prompt;
+        const provider = options?.provider;
+        // 1. Semantic Cache Check
+        let currentPromptVector = null;
+        if (this.semanticCache && this.getEmbeddingFn && prompt && !this._isResolvingEmbedding) {
+            try {
+                this._isResolvingEmbedding = true;
+                currentPromptVector = await this.getEmbeddingFn(prompt);
+                const cachedResponse = this.semanticCache.get(currentPromptVector);
+                if (cachedResponse !== null) {
+                    console.log(`[Semantic Cache HIT] Streaming cached response for prompt: "${prompt.slice(0, 30)}..."`);
+                    this.emit('executeSuccess', 'CACHE_HIT_STREAM', 0);
+                    // Replay full response as a single chunk (or iterate if it's an array)
+                    if (Array.isArray(cachedResponse)) {
+                        for (const chunk of cachedResponse)
+                            yield chunk;
+                    }
+                    else {
+                        yield cachedResponse;
+                    }
+                    return;
+                }
+            }
+            catch (e) {
+                console.warn('[Semantic Cache Check Failed] Proceeding to live stream', e);
+            }
+            finally {
+                this._isResolvingEmbedding = false;
+            }
+        }
+        // 2. Bulkhead check
+        if (this.activeCalls >= this.maxConcurrency) {
+            this.emit('bulkheadRejected');
+            throw new BulkheadRejectionError();
+        }
+        this.activeCalls++;
+        const accumulatedChunks = [];
+        let lastError;
+        try {
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                const key = provider ? this.getKeyByProvider(provider) : this.getKey();
+                if (!key) {
+                    if (this.fallbackFn) {
+                        this.emit('fallback', 'all keys exhausted (stream)');
+                        yield this.fallbackFn();
+                        return;
+                    }
+                    throw new AllKeysExhaustedError();
+                }
+                let iterator;
+                try {
+                    // Start the generator
+                    iterator = fn(key);
+                    // PRIME THE ITERATOR:
+                    // Try to get the first chunk. This forces the generator body to
+                    // execute until the first 'yield' or until it throws.
+                    const firstResult = await iterator.next();
+                    // If we got here, the INITIAL connection/logic succeeded!
+                    if (firstResult.done)
+                        return;
+                    // Yield first chunk
+                    yield firstResult.value;
+                    if (this.semanticCache && prompt)
+                        accumulatedChunks.push(firstResult.value);
+                    // Yield rest of chunks
+                    for await (const chunk of iterator) {
+                        yield chunk;
+                        if (this.semanticCache && prompt)
+                            accumulatedChunks.push(chunk);
+                    }
+                    // Success! Store in cache
+                    if (this.semanticCache && prompt && currentPromptVector && accumulatedChunks.length > 0) {
+                        this.semanticCache.set(prompt, currentPromptVector, accumulatedChunks);
+                    }
+                    return; // Full success, exit retry loop
+                }
+                catch (error) {
+                    lastError = error;
+                    const classification = this.classifyError(error, finishReason);
+                    this.markFailed(key, classification);
+                    this.emit('executeFailed', key, error);
+                    // Note: If we already yielded the FIRST chunk, we CANNOT retry the connection
+                    // because the user has already received data. Mid-stream failures propagate.
+                    if (accumulatedChunks.length > 0) {
+                        throw error;
+                    }
+                    if (!classification.retryable || attempt >= maxRetries) {
+                        if (this.fallbackFn && attempt >= maxRetries) {
+                            this.emit('fallback', 'max retries exceeded (stream)');
+                            yield this.fallbackFn();
+                            return;
+                        }
+                        throw error;
+                    }
+                    const delay = this.calculateBackoff(attempt);
+                    this.emit('retry', key, attempt + 1, delay);
+                    await this._sleep(delay);
+                }
+            }
+        }
+        finally {
+            this.activeCalls--;
+        }
+        throw lastError;
+    }
     async _executeWithRetry(fn, maxRetries, timeoutMs, finishReason, provider) {
         let lastError;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -568,7 +701,11 @@ class ApiKeyManager extends events_1.EventEmitter {
         }
     }
     _sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return new Promise(resolve => {
+            const timer = setTimeout(resolve, ms);
+            if (timer.unref)
+                timer.unref();
+        });
     }
     // ─── Health Checks ───────────────────────────────────────────────────────
     /**
@@ -584,6 +721,8 @@ class ApiKeyManager extends events_1.EventEmitter {
     startHealthChecks(intervalMs = 60_000) {
         this.stopHealthChecks(); // Clear any existing interval
         this.healthCheckInterval = setInterval(() => this._runHealthChecks(), intervalMs);
+        if (this.healthCheckInterval.unref)
+            this.healthCheckInterval.unref();
     }
     /**
      * Stop periodic health checks