@ai-matrx/api 0.0.0-stage → 0.1.1

package/dist/chunk-KIEAFMKB.js

@@ -0,0 +1,264 @@
+// src/net/errors.ts
+var NetError = class extends Error {
+  code;
+  cause;
+  status;
+  retryable;
+  constructor(code, message, opts = {}) {
+    super(message);
+    this.name = "NetError";
+    this.code = code;
+    this.cause = opts.cause;
+    if (opts.status !== void 0) this.status = opts.status;
+    this.retryable = opts.retryable ?? false;
+  }
+};
+var ConnectTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super("connect-timeout", `Connection timed out after ${ms}ms`, {
+      cause,
+      retryable: true
+    });
+    this.name = "ConnectTimeoutError";
+  }
+};
+var TotalTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super("total-timeout", `Request exceeded ${ms}ms total budget`, {
+      cause,
+      retryable: false
+    });
+    this.name = "TotalTimeoutError";
+  }
+};
+var HeartbeatTimeoutError = class extends NetError {
+  constructor(ms, cause) {
+    super(
+      "heartbeat-timeout",
+      `No server activity for ${ms}ms \u2014 stream considered dead`,
+      { cause, retryable: false }
+    );
+    this.name = "HeartbeatTimeoutError";
+  }
+};
+var NetworkError = class extends NetError {
+  constructor(message, cause) {
+    super("network", message, { cause, retryable: true });
+    this.name = "NetworkError";
+  }
+};
+var HttpError = class extends NetError {
+  constructor(status, message, cause) {
+    const retryable = status === 408 || status === 429 || status >= 500;
+    super("http", message, { cause, status, retryable });
+    this.name = "HttpError";
+  }
+};
+var AbortedError = class extends NetError {
+  constructor(cause) {
+    super("aborted", "Request was aborted", { cause, retryable: false });
+    this.name = "AbortedError";
+  }
+};
+var OfflineError = class extends NetError {
+  constructor() {
+    super("offline", "Browser is offline", { retryable: true });
+    this.name = "OfflineError";
+  }
+};
+function isNetError(err) {
+  return err instanceof NetError;
+}
+function extractErrorMessage(err, fallback = "An unexpected error occurred") {
+  if (!err) return "Unknown error";
+  if (typeof err === "string") return err;
+  if (err instanceof Error) return err.message;
+  if (typeof err === "object") {
+    const e = err;
+    const parts = [];
+    if (typeof e.message === "string" && e.message) parts.push(e.message);
+    if (parts.length === 0) {
+      if (typeof e.detail === "string" && e.detail) parts.push(e.detail);
+      else if (e.detail && typeof e.detail === "object") {
+        const d = e.detail;
+        if (typeof d.message === "string" && d.message) parts.push(d.message);
+      }
+    }
+    if (typeof e.details === "string" && e.details) parts.push(e.details);
+    if (typeof e.hint === "string" && e.hint) parts.push(`Hint: ${e.hint}`);
+    if (typeof e.code === "string" && e.code) parts.push(`Code: ${e.code}`);
+    if (parts.length > 0) return parts.join(" \xB7 ");
+    const nested = extractNestedErrorMessage(e, 0);
+    if (nested !== null) return nested;
+    try {
+      const s = JSON.stringify(err);
+      if (s && s !== "{}") return s;
+    } catch {
+    }
+  }
+  return fallback;
+}
+function extractNestedErrorMessage(e, depth) {
+  if (depth > 4) return null;
+  for (const key of ["error", "exception", "cause"]) {
+    const value = e[key];
+    if (typeof value === "string" && value) return value;
+    if (value && typeof value === "object") {
+      const inner = value;
+      if (typeof inner.message === "string" && inner.message) return inner.message;
+      if (typeof inner.detail === "string" && inner.detail) return inner.detail;
+      const deeper = extractNestedErrorMessage(inner, depth + 1);
+      if (deeper !== null) return deeper;
+    }
+  }
+  return null;
+}
+function isTransportFailure(err) {
+  if (err instanceof NetworkError || err instanceof OfflineError) return true;
+  if (typeof navigator !== "undefined" && navigator.onLine === false) return true;
+  if (err instanceof TypeError) return true;
+  if (err && typeof err === "object") {
+    const e = err;
+    if (e.code || e.status) return false;
+    const text = `${typeof e.name === "string" ? e.name : ""} ${typeof e.message === "string" ? e.message : ""}`.toLowerCase();
+    return text.includes("failed to fetch") || text.includes("networkerror") || text.includes("network request failed") || text.includes("load failed") || // Safari's wording for the same condition
+    text.includes("upstream connect error or disconnect/reset before headers");
+  }
+  return false;
+}
+function toNetError(err) {
+  if (isNetError(err)) return err;
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return new AbortedError(err);
+  }
+  if (err instanceof TypeError) {
+    return new NetworkError(err.message || "Network request failed", err);
+  }
+  return new NetError(
+    "unknown",
+    extractErrorMessage(err),
+    { cause: err }
+  );
+}
+
+// src/net/resilient-fetch.ts
+var DEFAULTS = {
+  connectTimeoutMs: 15e3,
+  totalTimeoutMs: 12e4
+};
+function linkAbort(target, signal) {
+  if (signal.aborted) {
+    target.abort(signal.reason);
+    return () => {
+    };
+  }
+  const onAbort = () => target.abort(signal.reason);
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
+}
+async function resilientFetch(url, init = {}, opts = {}) {
+  const connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULTS.connectTimeoutMs;
+  const totalTimeoutMs = opts.totalTimeoutMs === void 0 ? DEFAULTS.totalTimeoutMs : opts.totalTimeoutMs;
+  const throwOnHttpError = opts.throwOnHttpError ?? true;
+  const controller = new AbortController();
+  const unlinkCaller = opts.signal ? linkAbort(controller, opts.signal) : () => {
+  };
+  let connectTimedOut = false;
+  let totalTimedOut = false;
+  const connectTimer = setTimeout(() => {
+    connectTimedOut = true;
+    controller.abort("connect-timeout");
+  }, connectTimeoutMs);
+  const totalTimer = totalTimeoutMs !== null ? setTimeout(() => {
+    totalTimedOut = true;
+    controller.abort("total-timeout");
+  }, totalTimeoutMs) : null;
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    clearTimeout(connectTimer);
+    if (totalTimer !== null) clearTimeout(totalTimer);
+    if (throwOnHttpError && !response.ok) {
+      throw new HttpError(
+        response.status,
+        `HTTP ${response.status} ${response.statusText}`
+      );
+    }
+    return { response, controller };
+  } catch (err) {
+    clearTimeout(connectTimer);
+    if (totalTimer !== null) clearTimeout(totalTimer);
+    if (connectTimedOut) throw new ConnectTimeoutError(connectTimeoutMs, err);
+    if (totalTimedOut)
+      throw new TotalTimeoutError(totalTimeoutMs, err);
+    if (err instanceof DOMException && err.name === "AbortError") {
+      throw new AbortedError(err);
+    }
+    if (opts.signal?.aborted) {
+      throw new AbortedError(err);
+    }
+    if (err instanceof TypeError) {
+      if (typeof navigator !== "undefined" && navigator.onLine === false) {
+        throw new OfflineError();
+      }
+      throw new NetworkError(err.message || "Network request failed", err);
+    }
+    if (err instanceof HttpError) throw err;
+    throw new NetworkError(extractErrorMessage(err), err);
+  } finally {
+    unlinkCaller();
+  }
+}
+
+// src/net/retry.ts
+function defaultRetryOn(err) {
+  return isNetError(err) && err.retryable;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      resolve();
+      if (signal) signal.removeEventListener("abort", onAbort);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Aborted"));
+    };
+    if (signal) {
+      if (signal.aborted) {
+        clearTimeout(timer);
+        reject(signal.reason);
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+  });
+}
+async function withRetry(fn, opts = {}) {
+  const attempts = Math.max(1, opts.attempts ?? 3);
+  const initialDelayMs = opts.initialDelayMs ?? 250;
+  const maxDelayMs = opts.maxDelayMs ?? 4e3;
+  const factor = opts.backoffFactor ?? 2;
+  const jitter = Math.max(0, Math.min(1, opts.jitter ?? 0.25));
+  const retryOn = opts.retryOn ?? defaultRetryOn;
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (opts.signal?.aborted) throw opts.signal.reason;
+    try {
+      return await fn(attempt);
+    } catch (err) {
+      lastErr = err;
+      if (attempt === attempts || !retryOn(err)) throw err;
+      const base = Math.min(
+        maxDelayMs,
+        initialDelayMs * Math.pow(factor, attempt - 1)
+      );
+      const jitterAmount = base * jitter * (Math.random() * 2 - 1);
+      const delayMs = Math.max(0, Math.round(base + jitterAmount));
+      opts.onRetry?.(attempt, err, delayMs);
+      await sleep(delayMs, opts.signal);
+    }
+  }
+  throw lastErr;
+}
+
+export { AbortedError, ConnectTimeoutError, HeartbeatTimeoutError, HttpError, NetError, NetworkError, OfflineError, TotalTimeoutError, extractErrorMessage, isNetError, isTransportFailure, resilientFetch, toNetError, withRetry };