@infersec/conduit 1.26.1 → 1.26.3

package/dist/apiClient/index.d.ts

@@ -1,12 +1,14 @@
 import { InferenceAgentConfiguration, InferenceAgentLLMMetricsPayload, InferenceAgentMachineReportPayload, ULID, type ConduitState } from "@infersec/definitions";
+import { Logger } from "@infersec/logger";
 export interface APIClient {
     getConduitConfiguration: () => Promise<InferenceAgentConfiguration>;
     reportConduitState: (state: ConduitState) => Promise<void>;
     reportMachineMetadata: (payload: InferenceAgentMachineReportPayload) => Promise<void>;
     reportPromptMetrics: (payload: InferenceAgentLLMMetricsPayload) => Promise<void>;
 }
-export declare function createAPIClient({ apiKey, apiURL, inferenceSourceID }: {
+export declare function createAPIClient({ apiKey, apiURL, inferenceSourceID, logger }: {
     apiKey: string;
     apiURL: string;
     inferenceSourceID: ULID;
+    logger: Logger;
 }): APIClient;

package/dist/cli.js

@@ -6,10 +6,11 @@ const __dirname = __pathDirname(__filename);
 
 import { parseArgs } from 'node:util';
 import 'node:crypto';
-import { a as asError, s as startInferenceAgent } from './start-PzV0cQI5.js';
+import { a as asError, s as startInferenceAgent } from './start-D4bpW8Ix.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';
+import 'node:dns';
 import 'os';
 import 'fs';
 import 'util';
@@ -34,7 +35,6 @@ import 'node:console';
 import 'node:fs/promises';
 import 'node:path';
 import 'node:timers';
-import 'node:dns';
 import 'path';
 import 'tty';
 import 'net';

package/dist/index.js

@@ -5,10 +5,11 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 
 import 'node:crypto';
-import { s as startInferenceAgent, a as asError } from './start-PzV0cQI5.js';
+import { s as startInferenceAgent, a as asError } from './start-D4bpW8Ix.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';
+import 'node:dns';
 import 'os';
 import 'fs';
 import 'util';
@@ -34,7 +35,6 @@ import 'node:console';
 import 'node:fs/promises';
 import 'node:path';
 import 'node:timers';
-import 'node:dns';
 import 'path';
 import 'tty';
 import 'net';

package/dist/{start-PzV0cQI5.js → start-D4bpW8Ix.js}

@@ -4,6 +4,7 @@ import { dirname as __pathDirname } from 'node:path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 
+import require$$1$6, { setDefaultResultOrder } from 'node:dns';
 import require$$0$5 from 'os';
 import require$$1$2, { realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$1, lstatSync } from 'fs';
 import require$$2$2 from 'util';
@@ -33,7 +34,6 @@ import require$$1$5 from 'node:console';
 import require$$0$b, { mkdir, readFile, writeFile, stat, unlink, rename, realpath, readlink, readdir, lstat } from 'node:fs/promises';
 import path$1, { join, dirname, win32, posix } from 'node:path';
 import require$$2$5 from 'node:timers';
-import require$$1$6 from 'node:dns';
 import require$$0$c from 'path';
 import require$$0$d from 'tty';
 import require$$4$3 from 'net';
@@ -98039,8 +98039,136 @@ function implementAPIReference({ api, logger, mount, reference }) {
     }
 }
 
-function createAPIClient({ apiKey, apiURL, inferenceSourceID }) {
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), ms);
+    });
+}
+
+async function fetchWithRetry(input, init, { baseDelayMs = 250, maxAttempts = 4, maxDelayMs = 2000, signal, timeoutMs = 10000 } = {}) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        if (signal?.aborted) {
+            throw asError(signal.reason);
+        }
+        const attemptController = new AbortController();
+        const timeout = setTimeout(() => {
+            attemptController.abort(new Error(`Request timeout (${timeoutMs}ms)`));
+        }, timeoutMs);
+        const composedSignal = composeAbortSignals({
+            primary: signal,
+            secondary: attemptController.signal
+        });
+        try {
+            return await fetch(input, {
+                ...init,
+                signal: composedSignal
+            });
+        }
+        catch (error) {
+            const parsedError = asError(error);
+            lastError = parsedError;
+            if (!isRetryableNetworkError(parsedError) || attempt >= maxAttempts) {
+                throw parsedError;
+            }
+            const delayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+            const jitterMs = Math.floor(Math.random() * 100);
+            await sleep(delayMs + jitterMs);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    throw lastError ?? new Error("Request failed");
+}
+function getNetworkErrorAttributes(error) {
+    const parsedError = asError(error);
+    const attributes = {};
+    let cursor = parsedError;
+    let depth = 0;
+    while (cursor && depth < 3) {
+        const networkCursor = cursor;
+        if (depth === 0) {
+            attributes.errorMessage = cursor.message;
+            attributes.errorName = cursor.name;
+        }
+        const prefix = depth === 0 ? "error" : `cause${String(depth)}`;
+        if (typeof networkCursor.code === "string") {
+            attributes[`${prefix}Code`] = networkCursor.code;
+        }
+        if (typeof networkCursor.errno === "string" || typeof networkCursor.errno === "number") {
+            attributes[`${prefix}Errno`] = networkCursor.errno;
+        }
+        if (typeof networkCursor.syscall === "string") {
+            attributes[`${prefix}Syscall`] = networkCursor.syscall;
+        }
+        if (typeof networkCursor.address === "string") {
+            attributes[`${prefix}Address`] = networkCursor.address;
+        }
+        if (typeof networkCursor.port === "number") {
+            attributes[`${prefix}Port`] = networkCursor.port;
+        }
+        cursor = cursor.cause instanceof Error ? cursor.cause : undefined;
+        depth += 1;
+    }
+    return attributes;
+}
+function composeAbortSignals({ primary, secondary }) {
+    if (!primary) {
+        return secondary;
+    }
+    if (primary.aborted) {
+        return primary;
+    }
+    const composedController = new AbortController();
+    const abort = (reason) => {
+        if (!composedController.signal.aborted) {
+            composedController.abort(reason);
+        }
+    };
+    const primaryListener = () => {
+        abort(primary.reason);
+    };
+    const secondaryListener = () => {
+        abort(secondary.reason);
+    };
+    primary.addEventListener("abort", primaryListener, { once: true });
+    secondary.addEventListener("abort", secondaryListener, { once: true });
+    return composedController.signal;
+}
+function isRetryableNetworkError(error) {
+    if (error.name === "AbortError") {
+        return true;
+    }
+    const message = error.message.toLowerCase();
+    if (message.includes("fetch failed") || message.includes("timeout")) {
+        return true;
+    }
+    const errorCode = error.code;
+    return (errorCode === "ECONNRESET" ||
+        errorCode === "ECONNREFUSED" ||
+        errorCode === "ETIMEDOUT" ||
+        errorCode === "EHOSTUNREACH" ||
+        errorCode === "ENETUNREACH" ||
+        errorCode === "ENOTFOUND" ||
+        errorCode === "EAI_AGAIN");
+}
+
+function createAPIClient({ apiKey, apiURL, inferenceSourceID, logger }) {
+    async function retryingFetch(input, init) {
+        try {
+            return await fetchWithRetry(input, init, {
+                maxAttempts: 4,
+                timeoutMs: 10000
+            });
+        }
+        catch (error) {
+            logger.warn("API request failed after retries", getNetworkErrorAttributes(error));
+            throw error;
+        }
+    }
     const fetchWithAPIKey = createFetchWithHeaders({
+        fetchFn: retryingFetch,
         headers: {
             "x-api-key": apiKey
         }
@@ -108454,12 +108582,6 @@ class ModelManager extends EventEmitter {
     }
 }
 
-function sleep(ms) {
-    return new Promise(resolve => {
-        setTimeout(() => resolve(), ms);
-    });
-}
-
 async function handleSSERequests({ apiURL, configuration, logger, modelID, onRequest, onRequestEnd, onRequestStart, reportMetrics, signal }) {
     const streamURL = `${apiURL}/conduit/api/v1/source/${configuration.inferenceSourceID}/requests/stream`;
     const maxReconnectDelayMs = 30000;
@@ -108509,6 +108631,7 @@ async function handleSSERequests({ apiURL, configuration, logger, modelID, onReq
             const isTerminated = isTerminatedError(error);
             if (!isTerminated) {
                 logger.error("SSE connection failed", {
+                    ...getNetworkErrorAttributes(error),
                     error: asError(error)
                 });
             }
@@ -108736,7 +108859,7 @@ async function sendChunkStream({ apiURL, configuration, requestID, logger }) {
         for (let attempt = 1; attempt <= maxFlushAttempts; attempt += 1) {
             try {
                 activeAbortController = new AbortController();
-                const response = await fetch(streamURL, {
+                const response = await fetchWithRetry(streamURL, {
                     body: body.toString(),
                     headers: {
                         "content-type": "application/json",
@@ -108744,6 +108867,9 @@ async function sendChunkStream({ apiURL, configuration, requestID, logger }) {
                     },
                     method: "POST",
                     signal: activeAbortController.signal
+                }, {
+                    maxAttempts: 2,
+                    timeoutMs: 15000
                 });
                 if (!response.ok) {
                     throw new Error(`Chunk stream flush failed with status ${response.status}`);
@@ -108759,6 +108885,7 @@ async function sendChunkStream({ apiURL, configuration, requestID, logger }) {
                     throw asError(error);
                 }
                 logger.warn("Failed to send chunk batch", {
+                    ...getNetworkErrorAttributes(error),
                     error: asError(error)
                 });
                 await sleep(100 * attempt);
@@ -108911,6 +109038,7 @@ class ConduitStateReportManager {
         }
         catch (error) {
             this.logger.error("Conduit state update failed", {
+                ...getNetworkErrorAttributes(error),
                 error: asError(error)
             });
         }
@@ -119191,6 +119319,7 @@ function getConfiguration({ overrides } = {}) {
 }
 
 async function startInferenceAgent({ configurationOverrides }) {
+    setDefaultResultOrder("ipv4first");
     const abortController = new AbortController();
     const configuration = getConfiguration({ overrides: configurationOverrides });
     const logger = createLogger({
@@ -119202,7 +119331,8 @@ async function startInferenceAgent({ configurationOverrides }) {
     const apiClient = createAPIClient({
         apiKey: configuration.apiKey,
         apiURL: configuration.apiURL,
-        inferenceSourceID: configuration.inferenceSourceID
+        inferenceSourceID: configuration.inferenceSourceID,
+        logger
     });
     logger.info("Starting web server");
     const { app, shutdown } = await createApplication({

package/dist/utils/network.d.ts

@@ -0,0 +1,8 @@
+export declare function fetchWithRetry(input: URL | string, init: RequestInit, { baseDelayMs, maxAttempts, maxDelayMs, signal, timeoutMs }?: {
+    baseDelayMs?: number;
+    maxAttempts?: number;
+    maxDelayMs?: number;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<Response>;
+export declare function getNetworkErrorAttributes(error: unknown): Record<string, unknown>;

package/package.json

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