@juspay/neurolink/dist/proxy/providerTransportCoordinator.js

The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002

import { TimeoutError, withTimeout } from "../utils/async/withTimeout.js";
const SHARED_TRANSPORT_BACKOFF_MS = 250;
const RECOVERY_PROBE_WAIT_TIMEOUT_MS = 30_000;
export class ProviderTransportCoordinator {
    generation = 0;
    degraded = false;
    backoffUntil = 0;
    lastErrorCode = null;
    lastTransportScope = "shared_provider_transport";
    /** Whether the failure that degraded the transport happened before any
     *  request byte was sent. Waiters use it to pick their retry budget. */
    lastFailureConnectPhase = false;
    probe;
    async acquire(signal) {
        if (!this.degraded) {
            return { allowed: true, probe: false, generation: this.generation };
        }
        const waitMs = Math.max(0, this.backoffUntil - Date.now());
        if (waitMs > 0) {
            await this.wait(waitMs, signal);
        }
        if (!this.degraded) {
            return { allowed: true, probe: false, generation: this.generation };
        }
        if (this.probe) {
            const outcome = await this.waitForProbe(this.probe.promise, signal);
            if (outcome === "recovered") {
                return { allowed: true, probe: false, generation: this.generation };
            }
            if (outcome === "abandoned") {
                return this.acquire(signal);
            }
            return {
                allowed: false,
                errorCode: this.lastErrorCode,
                transportScope: this.lastTransportScope,
                connectPhase: this.lastFailureConnectPhase,
            };
        }
        let resolveProbe;
        const promise = new Promise((resolve) => {
            resolveProbe = resolve;
        });
        this.probe = {
            generation: this.generation,
            promise,
            resolve: resolveProbe,
        };
        return { allowed: true, probe: true, generation: this.generation };
    }
    reportSuccess(permit) {
        if (!permit.allowed || permit.generation !== this.generation) {
            return;
        }
        if (permit.probe && this.probe?.generation !== permit.generation) {
            return;
        }
        this.degraded = false;
        this.backoffUntil = 0;
        this.lastErrorCode = null;
        this.lastTransportScope = "shared_provider_transport";
        this.lastFailureConnectPhase = false;
        if (permit.probe && this.probe?.generation === permit.generation) {
            this.probe.resolve("recovered");
            this.probe = undefined;
        }
    }
    reportTransportFailure(errorCode, transportScope, permit, connectPhase = false) {
        if (!permit.allowed || permit.generation !== this.generation) {
            return;
        }
        if (permit.probe && this.probe?.generation !== permit.generation) {
            return;
        }
        this.degraded = true;
        this.backoffUntil = Date.now() + SHARED_TRANSPORT_BACKOFF_MS;
        this.lastErrorCode = errorCode ?? null;
        this.lastTransportScope = transportScope;
        this.lastFailureConnectPhase = connectPhase;
        if (permit.probe && this.probe?.generation === permit.generation) {
            this.probe.resolve("failed");
            this.probe = undefined;
        }
        this.generation += 1;
    }
    reportProbeAbandoned(permit) {
        if (!permit.allowed ||
            !permit.probe ||
            permit.generation !== this.generation ||
            this.probe?.generation !== permit.generation) {
            return;
        }
        this.probe.resolve("abandoned");
        this.probe = undefined;
        this.generation += 1;
    }
    clear() {
        this.probe?.resolve("failed");
        this.probe = undefined;
        this.generation += 1;
        this.degraded = false;
        this.backoffUntil = 0;
        this.lastErrorCode = null;
        this.lastTransportScope = "shared_provider_transport";
        this.lastFailureConnectPhase = false;
    }
    async wait(ms, signal) {
        if (signal?.aborted) {
            throw signal.reason;
        }
        await new Promise((resolve, reject) => {
            const timeoutRef = {};
            const onAbort = () => {
                if (timeoutRef.current) {
                    clearTimeout(timeoutRef.current);
                }
                reject(signal?.reason);
            };
            timeoutRef.current = setTimeout(() => {
                signal?.removeEventListener("abort", onAbort);
                resolve();
            }, ms);
            timeoutRef.current.unref?.();
            signal?.addEventListener("abort", onAbort, { once: true });
        });
    }
    async waitForProbe(probe, signal) {
        const boundedProbe = withTimeout(probe, RECOVERY_PROBE_WAIT_TIMEOUT_MS, "Anthropic transport recovery probe timed out");
        try {
            return await this.waitForProbeOrAbort(boundedProbe, signal);
        }
        catch (error) {
            if (error instanceof TimeoutError && this.probe?.promise === probe) {
                this.probe.resolve("failed");
                this.probe = undefined;
                this.generation += 1;
                this.backoffUntil = Date.now() + SHARED_TRANSPORT_BACKOFF_MS;
                return "failed";
            }
            throw error;
        }
    }
    waitForProbeOrAbort(probe, signal) {
        if (!signal) {
            return probe;
        }
        if (signal.aborted) {
            throw signal.reason;
        }
        return new Promise((resolve, reject) => {
            const onAbort = () => reject(signal.reason);
            signal.addEventListener("abort", onAbort, { once: true });
            probe.then((result) => {
                signal.removeEventListener("abort", onAbort);
                resolve(result);
            }, (error) => {
                signal.removeEventListener("abort", onAbort);
                reject(error);
            });
        });
    }
}