@adaptic/utils 0.0.1005 → 0.0.1007

package/dist/test.js

@@ -1537,6 +1537,99 @@ function createTimeoutSignal(ms) {
     return AbortSignal.timeout(ms);
 }
 
+/**
+ * Node.js / undici / system error codes that represent transient network
+ * conditions. Present on `error.code` for net/http/dns/undici errors.
+ */
+const RETRYABLE_ERROR_CODES = new Set([
+    "ETIMEDOUT",
+    "ESOCKETTIMEDOUT",
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "EAI_AGAIN",
+    "EPIPE",
+    "ECONNABORTED",
+    "ENOTFOUND",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CLOSED",
+    "UND_ERR_REQ_CONTENT_LENGTH_MISMATCH",
+]);
+/**
+ * Error constructor names / `error.name` values that indicate transient
+ * abort / timeout conditions.
+ */
+const RETRYABLE_ERROR_NAMES = new Set([
+    "AbortError",
+    "TimeoutError",
+    "FetchError",
+    "RequestTimeoutError",
+    "ConnectTimeoutError",
+    "HeadersTimeoutError",
+    "BodyTimeoutError",
+]);
+/**
+ * Message-pattern fallback for libraries that discard error codes/names but
+ * preserve text (e.g., some Apollo/axios wrappers).
+ */
+const RETRYABLE_MESSAGE_PATTERNS = [
+    /aborted/i,
+    /timeout/i,
+    /timed out/i,
+    /network error/i,
+    /socket hang up/i,
+    /connection (reset|refused|closed)/i,
+    /ECONNRESET/,
+    /ETIMEDOUT/,
+    /ECONNREFUSED/,
+    /EAI_AGAIN/,
+    /UND_ERR_/,
+];
+/**
+ * Walks the `error.cause` chain (capped to avoid cycles) and tests whether
+ * any link along the chain looks like a transient network error. Modern APIs
+ * (undici, fetch, Apollo Client 3.8+) wrap the root network failure as a
+ * `.cause`, so the surface `Error` may report a generic message while the
+ * actionable signal lives one or more levels deeper.
+ *
+ * Exported for use by downstream consumers (engine services, per-call catch
+ * blocks, application-level loggers) that need to demote recoverable
+ * transient errors from ERROR to WARN. Aligns the whole stack on a single
+ * canonical classifier so MassiveAPI, AlpacaAPI, and application-layer
+ * retry handlers all treat the same network blips identically.
+ */
+function isTransientNetworkError(error) {
+    const MAX_CAUSE_DEPTH = 6;
+    let current = error;
+    for (let depth = 0; depth < MAX_CAUSE_DEPTH && current; depth++) {
+        if (current instanceof Error || typeof current === "object") {
+            const err = current;
+            if (typeof err.name === "string" && RETRYABLE_ERROR_NAMES.has(err.name)) {
+                return true;
+            }
+            if (typeof err.code === "string" && RETRYABLE_ERROR_CODES.has(err.code)) {
+                return true;
+            }
+            if (typeof err.message === "string") {
+                for (const pattern of RETRYABLE_MESSAGE_PATTERNS) {
+                    if (pattern.test(err.message)) {
+                        return true;
+                    }
+                }
+            }
+            current = err.cause;
+        }
+        else {
+            break;
+        }
+    }
+    return false;
+}
+
 /**
  * Structured error type hierarchy for all API integrations
  *
@@ -1912,6 +2005,32 @@ const rateLimiters = {
     }),
 };
 
+/**
+ * Bounded retry for TRANSIENT network faults on Alpaca market-data reads.
+ *
+ * 2026-07-30: the engine logged 637 `TypeError: fetch failed` / `read
+ * ECONNRESET` errors against `/v2/stocks/bars` in a single session (~4 per
+ * minute). Every OTHER Alpaca/Massive client in this package already routes
+ * transient faults through {@link isTransientNetworkError} — this client was
+ * the one that never adopted it, so a single reset socket killed the whole
+ * read. Those failures surface in the engine's market-tape prompt context and
+ * its intraday direction/path resolvers, so the decision model judged with a
+ * blind tape: raw confidence collapsed from a 0.677 median to a degenerate
+ * ~0.504 band, the entire distribution fell below the 0.55 admission floor,
+ * and live participation went to near zero.
+ *
+ * `ECONNRESET` on a keep-alive pool is the classic idle-socket race — the
+ * server closes a pooled connection while the client dispatches onto it. It
+ * is transient by construction and safe to retry on an idempotent GET.
+ */
+const TRANSIENT_NETWORK_RETRY_ATTEMPTS = 3;
+/** Base backoff (ms); doubled per attempt with full jitter. */
+const TRANSIENT_NETWORK_RETRY_BASE_MS = 120;
+/** Full-jitter backoff so concurrent fan-out retries do not resonate. */
+function transientRetryDelayMs(attempt) {
+    const ceiling = TRANSIENT_NETWORK_RETRY_BASE_MS * 2 ** attempt;
+    return Math.floor(Math.random() * ceiling);
+}
 const log$1 = (message, options = { type: "info" }) => {
     log$2(message, { ...options, source: "AlpacaMarketDataAPI" });
 };
@@ -2422,11 +2541,42 @@ class AlpacaMarketDataAPI extends EventEmitter {
             // can't overrun Alpaca's server-side rate limit. Prior to this, parallel
             // historical-bar fan-out produced ~125 server-side 429s per minute.
             await rateLimiters.alpaca.acquire();
-            const response = await fetch(url.toString(), {
-                method,
-                headers: this.headers,
-                signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
-            });
+            // Retry ONLY transient connection faults, and only on GET (every
+            // market-data read here is idempotent). A non-2xx response is a real
+            // answer from Alpaca and is never retried — that path still throws on
+            // the first attempt exactly as before.
+            let response;
+            let lastNetworkError;
+            for (let attempt = 0; attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS; attempt += 1) {
+                try {
+                    response = await fetch(url.toString(), {
+                        method,
+                        headers: this.headers,
+                        signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
+                    });
+                    break;
+                }
+                catch (networkErr) {
+                    lastNetworkError = networkErr;
+                    const retryable = method === "GET" &&
+                        isTransientNetworkError(networkErr) &&
+                        attempt < TRANSIENT_NETWORK_RETRY_ATTEMPTS - 1;
+                    if (!retryable) {
+                        throw networkErr;
+                    }
+                    const delayMs = transientRetryDelayMs(attempt);
+                    log$1(`Transient network fault on ${endpoint} (attempt ${attempt + 1}/${TRANSIENT_NETWORK_RETRY_ATTEMPTS}); retrying in ${delayMs}ms`, { type: "warn" });
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                    // Re-acquire the rate-limit token so a retry storm cannot overrun
+                    // Alpaca's server-side limit.
+                    await rateLimiters.alpaca.acquire();
+                }
+            }
+            if (!response) {
+                throw lastNetworkError instanceof Error
+                    ? lastNetworkError
+                    : new Error(`Market Data API request failed for ${endpoint}`);
+            }
             if (!response.ok) {
                 const errorText = await response.text();
                 log$1(`Market Data API error (${response.status}): ${errorText}`, {