@infersec/conduit 1.16.1 → 1.17.1

package/dist/apiClient/index.d.ts

@@ -5,7 +5,7 @@ export interface APIClient {
     reportMachineMetadata: (payload: InferenceAgentMachineReportPayload) => Promise<void>;
     reportPromptMetrics: (payload: InferenceAgentLLMMetricsPayload) => Promise<void>;
 }
-export declare function createAPIClient({ apiURL, inferenceSourceID }: {
+export declare function createAPIClient({ apiKey, apiURL, inferenceSourceID }: {
     apiKey: string;
     apiURL: string;
     inferenceSourceID: ULID;

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-Xtxz-3k5.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-Xtxz-3k5.js';
+import { s as startInferenceAgent, a as asError } from './start-Cf1W68Pz.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';

package/dist/{start-Xtxz-3k5.js → start-Cf1W68Pz.js}

@@ -52625,6 +52625,19 @@ function requireUndici () {
 
 var undiciExports = requireUndici();
 
+function createFetchWithHeaders({ fetchFn = undiciExports.fetch, headers }) {
+    function fetchWithHeaders(url, options) {
+        const mergedHeaders = new Headers(options.headers);
+        for (const [key, value] of Object.entries(headers)) {
+            mergedHeaders.set(key, value);
+        }
+        return fetchFn(url, {
+            ...options,
+            headers: mergedHeaders
+        });
+    }
+    return fetchWithHeaders;
+}
 async function fetchByReference(options) {
     const { baseURL, body, fetch: fetchFn = undiciExports.fetch, parameters = {}, query = {}, reference, route, method } = options;
     if (!reference[route]) {
@@ -97906,11 +97919,17 @@ function implementAPIReference({ api, logger, mount, reference }) {
     }
 }
 
-function createAPIClient({ apiURL, inferenceSourceID }) {
+function createAPIClient({ apiKey, apiURL, inferenceSourceID }) {
+    const fetchWithAPIKey = createFetchWithHeaders({
+        headers: {
+            "x-api-key": apiKey
+        }
+    });
     return {
         getConduitConfiguration: async () => {
             const result = await fetchByReference({
                 baseURL: apiURL,
+                fetch: fetchWithAPIKey,
                 reference: API_SERVICE_CONDUIT_API_REFERENCE,
                 route: "/conduit/api/v1/source/:sourceID/configuration",
                 method: "GET",
@@ -97924,6 +97943,7 @@ function createAPIClient({ apiURL, inferenceSourceID }) {
             await fetchByReference({
                 baseURL: apiURL,
                 body: payload,
+                fetch: fetchWithAPIKey,
                 method: "POST",
                 parameters: {
                     sourceID: inferenceSourceID
@@ -97936,6 +97956,7 @@ function createAPIClient({ apiURL, inferenceSourceID }) {
             await fetchByReference({
                 baseURL: apiURL,
                 body: state,
+                fetch: fetchWithAPIKey,
                 method: "POST",
                 parameters: {
                     sourceID: inferenceSourceID
@@ -97948,6 +97969,7 @@ function createAPIClient({ apiURL, inferenceSourceID }) {
             await fetchByReference({
                 baseURL: apiURL,
                 body: payload,
+                fetch: fetchWithAPIKey,
                 method: "POST",
                 parameters: {
                     sourceID: inferenceSourceID
@@ -108485,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 }) {
@@ -118001,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;
@@ -118022,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
@@ -118086,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({
@@ -118203,6 +118300,7 @@ async function startInferenceAgent({ configurationOverrides }) {
         agentEngineType: configuration.agentEngineType
     });
     const apiClient = createAPIClient({
+        apiKey: configuration.apiKey,
         apiURL: configuration.apiURL,
         inferenceSourceID: configuration.inferenceSourceID
     });

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.16.1",
+  "version": "1.17.1",
   "bin": {
     "infersec-conduit": "./dist/cli.js"
   },