@infersec/conduit 1.46.0 → 1.46.1

package/dist/cli.js

@@ -112782,6 +112782,7 @@ class ModelManager extends EventEmitter {
     contextLength;
     logger;
     engineProcess = null;
+    healthPollInterval = null;
     lifecycleState = "stopped";
     stopRequested = false;
     modelsDirectory;
@@ -112919,6 +112920,9 @@ class ModelManager extends EventEmitter {
             }
             this.lifecycleState = "errored";
             this.emit("engineError", err);
+            if (this.engineProcess) {
+                this.startHealthPoll();
+            }
             throw err;
         }
         this.lifecycleState = "running";
@@ -112930,16 +112934,18 @@ class ModelManager extends EventEmitter {
                 message: "Cannot stop LLM engine: already stopping"
             });
         }
-        if (this.lifecycleState !== "running" && this.lifecycleState !== "starting") {
+        if (this.lifecycleState !== "running" &&
+            this.lifecycleState !== "starting" &&
+            this.lifecycleState !== "errored") {
             throw new UnknownError({
                 message: `Cannot stop LLM engine: Invalid state: ${this.lifecycleState}`
             });
         }
+        this.clearHealthPoll();
         const processManager = this.engineProcess;
         if (!processManager) {
-            throw new UnknownError({
-                message: "Cannot stop LLM engine: engine process not running"
-            });
+            this.lifecycleState = "stopped";
+            return;
         }
         this.lifecycleState = "stopping";
         this.stopRequested = true;
@@ -112949,32 +112955,63 @@ class ModelManager extends EventEmitter {
         return this.lifecycleState === "stopped";
     }
     get canStop() {
-        return this.lifecycleState === "running" || this.lifecycleState === "starting";
+        return (this.lifecycleState === "running" ||
+            this.lifecycleState === "starting" ||
+            this.lifecycleState === "errored");
     }
     get state() {
         return this.lifecycleState;
     }
-    async isEngineReady() {
+    async checkEngineReadiness() {
         switch (this.engine) {
-            case "llama.cpp":
+            case "llama.cpp": {
+                return this.checkLlamacppReadiness();
+            }
             case "vllm": {
-                try {
-                    const response = await this.fetchOpenAI("/v1/models", {
-                        method: "GET",
-                        signal: AbortSignal.timeout(5000)
-                    });
-                    return response.ok;
-                }
-                catch (_error) {
-                    return false;
-                }
+                return this.checkVLLMReadiness();
             }
             default:
-                return true;
+                return "ready";
+        }
+    }
+    async checkLlamacppReadiness() {
+        try {
+            const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, "/health"), {
+                method: "GET",
+                signal: AbortSignal.timeout(5000)
+            });
+            if (response.status === 503) {
+                return "loading";
+            }
+            if (response.ok) {
+                return "ready";
+            }
+            return "loading";
+        }
+        catch (_error) {
+            return "unreachable";
+        }
+    }
+    async checkVLLMReadiness() {
+        try {
+            const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, "/v1/models"), {
+                method: "GET",
+                signal: AbortSignal.timeout(5000)
+            });
+            if (response.status === 503) {
+                return "loading";
+            }
+            if (response.ok) {
+                return "ready";
+            }
+            return "loading";
+        }
+        catch (_error) {
+            return "unreachable";
         }
     }
     async waitForEngineReady() {
-        const maxWaitMs = 5 * 60 * 1000;
+        const maxWaitMs = 15 * 60 * 1000;
         const pollIntervalMs = 2000;
         const start = Date.now();
         while (Date.now() - start < maxWaitMs) {
@@ -112984,14 +113021,41 @@ class ModelManager extends EventEmitter {
             if (!this.engineProcess) {
                 throw new Error("LLM engine process exited before readiness checks completed");
             }
-            const ready = await this.isEngineReady();
-            if (ready) {
+            const readiness = await this.checkEngineReadiness();
+            if (readiness === "ready") {
                 return;
             }
             await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
         }
         throw new Error("LLM engine failed readiness checks within timeout");
     }
+    clearHealthPoll() {
+        if (this.healthPollInterval) {
+            clearInterval(this.healthPollInterval);
+            this.healthPollInterval = null;
+        }
+    }
+    startHealthPoll() {
+        this.clearHealthPoll();
+        this.logger.info("Starting background health poll for errored engine");
+        this.healthPollInterval = setInterval(() => {
+            if (!this.engineProcess) {
+                this.clearHealthPoll();
+                return;
+            }
+            this.checkEngineReadiness()
+                .then(readiness => {
+                if (readiness === "ready") {
+                    this.clearHealthPoll();
+                    this.lifecycleState = "running";
+                    this.emit("engineReady");
+                }
+            })
+                .catch(() => {
+                // keep polling
+            });
+        }, 15_000);
+    }
     bindEngineProcessEvents(processManager) {
         let hasTerminated = false;
         processManager.on("stderr", line => {
@@ -113005,6 +113069,7 @@ class ModelManager extends EventEmitter {
                 return;
             }
             hasTerminated = true;
+            this.clearHealthPoll();
             if (this.stopRequested) {
                 this.engineProcess = null;
                 this.lifecycleState = "stopped";
@@ -113026,6 +113091,7 @@ class ModelManager extends EventEmitter {
                 return;
             }
             hasTerminated = true;
+            this.clearHealthPoll();
             this.engineProcess = null;
             if (this.stopRequested) {
                 this.lifecycleState = "stopped";

package/dist/modelManagement/ModelManager.d.ts

@@ -18,6 +18,7 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     readonly contextLength: number | null;
     protected readonly logger: Logger;
     private engineProcess;
+    private healthPollInterval;
     private lifecycleState;
     private stopRequested;
     protected readonly modelsDirectory: string;
@@ -39,8 +40,12 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     get canStart(): boolean;
     get canStop(): boolean;
     get state(): EngineLifecycleState;
-    private isEngineReady;
+    private checkEngineReadiness;
+    private checkLlamacppReadiness;
+    private checkVLLMReadiness;
     private waitForEngineReady;
+    private clearHealthPoll;
+    private startHealthPoll;
     private bindEngineProcessEvents;
     private startEngineProcess;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infersec/conduit",
   "description": "End user conduit agent for connecting local LLMs to the cloud.",
-  "version": "1.46.0",
+  "version": "1.46.1",
   "bin": {
     "infersec-conduit": "./dist/cli.js"
   },