@infersec/conduit 1.17.0 → 1.17.1

package/dist/cli.js

@@ -6,7 +6,7 @@ const __dirname = __pathDirname(__filename);
 
 import { parseArgs } from 'node:util';
 import 'node:crypto';
-import { a as asError, s as startInferenceAgent } from './start-CCmUbFoS.js';
+import { a as asError, s as startInferenceAgent } from './start-Cf1W68Pz.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';

package/dist/index.js

@@ -5,7 +5,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 
 import 'node:crypto';
-import { s as startInferenceAgent, a as asError } from './start-CCmUbFoS.js';
+import { s as startInferenceAgent, a as asError } from './start-Cf1W68Pz.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';

package/dist/{start-CCmUbFoS.js → start-Cf1W68Pz.js}

@@ -108507,6 +108507,91 @@ async function proxyRequest({ configuration, request }) {
     };
 }
 
+class ConduitStateReportManager {
+    apiClient;
+    conduitStateManager;
+    downloadProgressReportIntervalMs;
+    logger;
+    stateIntervalMs;
+    conduitStateReportInFlight = false;
+    lastConduitStateReportAt = 0;
+    pendingConduitStateReport = null;
+    stateInterval = null;
+    constructor({ apiClient, conduitStateManager, downloadProgressReportIntervalMs, logger, stateIntervalMs }) {
+        this.apiClient = apiClient;
+        this.conduitStateManager = conduitStateManager;
+        this.downloadProgressReportIntervalMs = downloadProgressReportIntervalMs;
+        this.logger = logger;
+        this.stateIntervalMs = stateIntervalMs;
+    }
+    async start() {
+        await this.sendConduitState();
+        this.stateInterval = setInterval(() => {
+            this.sendConduitState().catch(error => {
+                this.logger.error("Conduit state update failed", {
+                    error: asError(error)
+                });
+            });
+        }, this.stateIntervalMs);
+    }
+    stop() {
+        if (this.stateInterval) {
+            clearInterval(this.stateInterval);
+            this.stateInterval = null;
+        }
+        if (this.pendingConduitStateReport) {
+            clearTimeout(this.pendingConduitStateReport);
+            this.pendingConduitStateReport = null;
+        }
+    }
+    reportDownloadProgress() {
+        this.scheduleConduitStateReport();
+    }
+    async sendConduitState() {
+        try {
+            await this.apiClient.reportConduitState(this.conduitStateManager.touch());
+            this.lastConduitStateReportAt = Date.now();
+        }
+        catch (error) {
+            this.logger.error("Conduit state update failed", {
+                error: asError(error)
+            });
+        }
+    }
+    async triggerConduitStateReport() {
+        if (this.conduitStateReportInFlight) {
+            this.scheduleConduitStateReport();
+            return;
+        }
+        this.conduitStateReportInFlight = true;
+        await this.sendConduitState();
+        this.conduitStateReportInFlight = false;
+    }
+    scheduleConduitStateReport() {
+        const now = Date.now();
+        const elapsed = now - this.lastConduitStateReportAt;
+        if (elapsed >= this.downloadProgressReportIntervalMs && !this.conduitStateReportInFlight) {
+            this.triggerConduitStateReport().catch(error => {
+                this.logger.error("Conduit state update failed", {
+                    error: asError(error)
+                });
+            });
+            return;
+        }
+        if (this.pendingConduitStateReport)
+            return;
+        const delay = Math.max(this.downloadProgressReportIntervalMs - elapsed, 0);
+        this.pendingConduitStateReport = setTimeout(() => {
+            this.pendingConduitStateReport = null;
+            this.triggerConduitStateReport().catch(error => {
+                this.logger.error("Conduit state update failed", {
+                    error: asError(error)
+                });
+            });
+        }, delay);
+    }
+}
+
 class ConduitStateManager {
     currentState;
     constructor({ initialState }) {
@@ -118023,6 +118108,14 @@ async function createApplication({ abortController, apiClient, configuration, lo
             total: 0
         }
     });
+    const conduitStateReportManager = new ConduitStateReportManager({
+        apiClient,
+        conduitStateManager,
+        downloadProgressReportIntervalMs: 5000,
+        logger,
+        stateIntervalMs: 30000
+    });
+    await conduitStateReportManager.start();
     let lastDownloadKey = "";
     const reportDownloadProgress = (update) => {
         const filePercent = update.file.total > 0 ? Math.floor((update.file.bytes / update.file.total) * 100) : 0;
@@ -118044,6 +118137,7 @@ async function createApplication({ abortController, apiClient, configuration, lo
                 total: Math.max(0, Math.floor(update.total.total))
             }
         });
+        conduitStateReportManager.reportDownloadProgress();
     };
     await modelManager.prepare({
         onDownloadProgress: reportDownloadProgress
@@ -118108,25 +118202,6 @@ async function createApplication({ abortController, apiClient, configuration, lo
         mount: publicRouter,
         reference: API_CLIENT_INFERENCE_AGENT_API_REFERENCE
     });
-    const CONDUIT_STATE_INTERVAL_MS = 30000;
-    async function sendConduitState() {
-        try {
-            await apiClient.reportConduitState(conduitStateManager.touch());
-        }
-        catch (error) {
-            logger.error("Conduit state update failed", {
-                error: asError(error)
-            });
-        }
-    }
-    await sendConduitState();
-    setInterval(() => {
-        sendConduitState().catch(error => {
-            logger.error("Conduit state update failed", {
-                error: asError(error)
-            });
-        });
-    }, CONDUIT_STATE_INTERVAL_MS);
     let activeRequests = 0;
     const setOnlineState = () => {
         conduitStateManager.setState({

package/dist/state/ConduitStateReportManager.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from "@infersec/logger";
+import { APIClient } from "../apiClient/index.js";
+import { ConduitStateManager } from "./ConduitStateManager.js";
+export declare class ConduitStateReportManager {
+    private apiClient;
+    private conduitStateManager;
+    private downloadProgressReportIntervalMs;
+    private logger;
+    private stateIntervalMs;
+    private conduitStateReportInFlight;
+    private lastConduitStateReportAt;
+    private pendingConduitStateReport;
+    private stateInterval;
+    constructor({ apiClient, conduitStateManager, downloadProgressReportIntervalMs, logger, stateIntervalMs }: {
+        apiClient: APIClient;
+        conduitStateManager: ConduitStateManager;
+        downloadProgressReportIntervalMs: number;
+        logger: Logger;
+        stateIntervalMs: number;
+    });
+    start(): Promise<void>;
+    stop(): void;
+    reportDownloadProgress(): void;
+    private sendConduitState;
+    private triggerConduitStateReport;
+    private scheduleConduitStateReport;
+}

package/package.json

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