@routstr/sdk 0.3.7 → 0.3.8

package/dist/discovery/index.js

@@ -0,0 +1,738 @@
+'use strict';
+
+var applesauceRelay = require('applesauce-relay');
+var applesauceCore = require('applesauce-core');
+var rxjs = require('rxjs');
+
+// core/types.ts
+function makeConsoleLogger(prefix) {
+  const fmt = (args) => prefix ? [prefix, ...args] : args;
+  return {
+    log: (...args) => console.log(...fmt(args)),
+    warn: (...args) => console.warn(...fmt(args)),
+    error: (...args) => console.error(...fmt(args)),
+    debug: (...args) => console.log(...fmt(args)),
+    child: (p) => makeConsoleLogger(prefix ? `${prefix}:${p}` : p)
+  };
+}
+var consoleLogger = makeConsoleLogger();
+
+// core/errors.ts
+var ProviderBootstrapError = class extends Error {
+  constructor(failedProviders, message) {
+    super(
+      message || `Failed to bootstrap providers. Tried: ${failedProviders.join(", ")}`
+    );
+    this.failedProviders = failedProviders;
+    this.name = "ProviderBootstrapError";
+  }
+  failedProviders;
+};
+var NoProvidersAvailableError = class extends Error {
+  constructor() {
+    super("No providers are available for model discovery");
+    this.name = "NoProvidersAvailableError";
+  }
+};
+var ModelManager = class _ModelManager {
+  constructor(adapter, config = {}) {
+    this.adapter = adapter;
+    this.providerDirectoryUrl = config.providerDirectoryUrl || "https://api.routstr.com/v1/providers/";
+    this.cacheTTL = config.cacheTTL || 210 * 60 * 1e3;
+    this.includeProviderUrls = config.includeProviderUrls || [];
+    this.excludeProviderUrls = config.excludeProviderUrls || [];
+    this.routstrPubkey = config.routstrPubkey || "4ad6fa2d16e2a9b576c863b4cf7404a70d4dc320c0c447d10ad6ff58993eacc8";
+    this.logger = (config.logger ?? consoleLogger).child("ModelManager");
+  }
+  adapter;
+  cacheTTL;
+  providerDirectoryUrl;
+  includeProviderUrls;
+  excludeProviderUrls;
+  routstrPubkey;
+  logger;
+  providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+  /**
+   * Get the list of bootstrapped provider base URLs
+   * @returns Array of provider base URLs
+   */
+  getBaseUrls() {
+    return this.adapter.getBaseUrlsList();
+  }
+  static async init(adapter, config = {}, options = {}) {
+    const manager = new _ModelManager(adapter, config);
+    const torMode = options.torMode ?? false;
+    const forceRefresh = options.forceRefresh ?? false;
+    const providers = await manager.bootstrapProviders(torMode, forceRefresh);
+    await manager.fetchModels(providers, forceRefresh);
+    return manager;
+  }
+  /**
+   * Bootstrap provider list from the provider directory
+   * First tries to fetch from Nostr (kind 30421), falls back to HTTP
+   * @param torMode Whether running in Tor context
+   * @param forceRefresh Ignore provider cache and refresh provider sources
+   * @returns Array of provider base URLs
+   * @throws ProviderBootstrapError if all providers fail to fetch
+   */
+  async bootstrapProviders(torMode = false, forceRefresh = false) {
+    if (!forceRefresh) {
+      const cachedUrls = this.adapter.getBaseUrlsList();
+      if (cachedUrls.length > 0) {
+        const lastUpdate = this.adapter.getBaseUrlsLastUpdate();
+        const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+        if (cacheValid) {
+          const filteredCachedUrls = this.filterBaseUrlsForTor(
+            cachedUrls,
+            torMode
+          );
+          await this.fetchRoutstr21Models(forceRefresh);
+          await this.syncReviewedProvidersFromNostr(filteredCachedUrls);
+          return filteredCachedUrls;
+        }
+      }
+    }
+    try {
+      const nostrProviders = await this.bootstrapFromNostr(38421, torMode);
+      if (nostrProviders.length > 0) {
+        const filtered = this.filterBaseUrlsForTor(nostrProviders, torMode);
+        this.adapter.setBaseUrlsList(filtered);
+        this.adapter.setBaseUrlsLastUpdate(Date.now());
+        await this.fetchRoutstr21Models(forceRefresh);
+        await this.syncReviewedProvidersFromNostr(filtered);
+        return filtered;
+      }
+    } catch (e) {
+      this.logger.warn("Nostr bootstrap failed, falling back to HTTP:", e);
+    }
+    return this.bootstrapFromHttp(torMode, forceRefresh);
+  }
+  /**
+   * Bootstrap providers from Nostr network (kind 30421)
+   * @param kind The Nostr kind to fetch
+   * @param torMode Whether running in Tor context
+   * @returns Array of provider base URLs
+   */
+  async bootstrapFromNostr(kind, torMode) {
+    const DEFAULT_RELAYS = [
+      "wss://relay.primal.net",
+      "wss://nos.lol",
+      "wss://relay.damus.io"
+    ];
+    const pool = new applesauceRelay.RelayPool();
+    const localEventStore = new applesauceCore.EventStore();
+    const timeoutMs = 5e3;
+    await new Promise((resolve) => {
+      pool.req(DEFAULT_RELAYS, {
+        kinds: [kind],
+        limit: 100
+      }).pipe(
+        applesauceRelay.onlyEvents(),
+        rxjs.tap((event) => {
+          localEventStore.add(event);
+        })
+      ).subscribe({
+        complete: () => {
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+    });
+    const timeline = localEventStore.getTimeline({ kinds: [kind] });
+    const bases = /* @__PURE__ */ new Set();
+    this.providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+    for (const event of timeline) {
+      const eventUrls = [];
+      for (const tag of event.tags) {
+        if (tag[0] === "u" && typeof tag[1] === "string") {
+          eventUrls.push(tag[1]);
+        }
+      }
+      if (eventUrls.length > 0) {
+        for (const url of eventUrls) {
+          const normalized = this.normalizeUrl(url);
+          if (!torMode || normalized.includes(".onion")) {
+            bases.add(normalized);
+            this.addProviderNode(
+              this.providerNodePubkeysByUrl,
+              normalized,
+              event.pubkey
+            );
+          }
+        }
+        continue;
+      }
+      try {
+        const content = JSON.parse(event.content);
+        const providers = Array.isArray(content) ? content : content.providers || [];
+        for (const p of providers) {
+          const endpoints = this.getProviderEndpoints(p, torMode);
+          for (const endpoint of endpoints) {
+            bases.add(endpoint);
+            this.addProviderNode(
+              this.providerNodePubkeysByUrl,
+              endpoint,
+              p?.pubkey || event.pubkey
+            );
+          }
+        }
+      } catch {
+        try {
+          const providers = JSON.parse(event.content);
+          if (Array.isArray(providers)) {
+            for (const p of providers) {
+              const endpoints = this.getProviderEndpoints(p, torMode);
+              for (const endpoint of endpoints) {
+                bases.add(endpoint);
+                this.addProviderNode(
+                  this.providerNodePubkeysByUrl,
+                  endpoint,
+                  p?.pubkey || event.pubkey
+                );
+              }
+            }
+          }
+        } catch {
+          this.logger.warn(
+            "NostrBootstrap: failed to parse event content:",
+            event.id
+          );
+        }
+      }
+    }
+    for (const url of this.includeProviderUrls) {
+      const normalized = this.normalizeUrl(url);
+      if (!torMode || normalized.includes(".onion")) {
+        bases.add(normalized);
+      }
+    }
+    const excluded = new Set(
+      this.excludeProviderUrls.map((url) => this.normalizeUrl(url))
+    );
+    const result = Array.from(bases).filter((base) => !excluded.has(base));
+    return result;
+  }
+  /**
+   * Bootstrap providers from HTTP endpoint
+   * @param torMode Whether running in Tor context
+   * @param forceRefresh Ignore routstr21 cache and fetch fresh data
+   * @returns Array of provider base URLs
+   */
+  async bootstrapFromHttp(torMode, forceRefresh = false) {
+    try {
+      const res = await fetch(this.providerDirectoryUrl);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch providers: ${res.status}`);
+      }
+      const data = await res.json();
+      const providers = Array.isArray(data?.providers) ? data.providers : [];
+      const bases = /* @__PURE__ */ new Set();
+      this.providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+      for (const p of providers) {
+        const endpoints = this.getProviderEndpoints(p, torMode);
+        for (const endpoint of endpoints) {
+          bases.add(endpoint);
+          this.addProviderNode(this.providerNodePubkeysByUrl, endpoint, p?.pubkey);
+        }
+      }
+      for (const url of this.includeProviderUrls) {
+        const normalized = this.normalizeUrl(url);
+        if (!torMode || normalized.includes(".onion")) {
+          bases.add(normalized);
+        }
+      }
+      const excluded = new Set(
+        this.excludeProviderUrls.map((url) => this.normalizeUrl(url))
+      );
+      const list = Array.from(bases).filter((base) => !excluded.has(base));
+      if (list.length > 0) {
+        this.adapter.setBaseUrlsList(list);
+        this.adapter.setBaseUrlsLastUpdate(Date.now());
+        await this.fetchRoutstr21Models(forceRefresh);
+        await this.syncReviewedProvidersFromNostr(list);
+      }
+      return list;
+    } catch (e) {
+      this.logger.error("Failed to bootstrap providers", e);
+      throw new ProviderBootstrapError([], `Provider bootstrap failed: ${e}`);
+    }
+  }
+  /**
+   * Fetch Routstr review events from Nostr (kind 38425) and disable providers
+   * whose 38421 node pubkey does not have at least one review tagged `t=lgtm`.
+   *
+   * Review events are expected to have:
+   * - `node`: the reviewed 38421 provider event pubkey
+   * - `t`: review label, where `lgtm` means the node looks good
+   *
+   * @param baseUrls Current provider base URLs to evaluate
+   * @returns Array of provider base URLs disabled by the review set
+   */
+  async syncReviewedProvidersFromNostr(baseUrls = this.adapter.getBaseUrlsList(), providerNodes = this.providerNodePubkeysByUrl) {
+    if (baseUrls.length === 0) return [];
+    if (!this.adapter.setDisabledProviders) {
+      this.logger.warn(
+        "NostrReviews: adapter does not support setDisabledProviders; skipping provider disable sync"
+      );
+      return [];
+    }
+    const LGTM_RELAYS = [
+      "wss://relay.primal.net",
+      "wss://nos.lol",
+      "wss://relay.damus.io",
+      "wss://relay.routstr.com"
+    ];
+    const reviewedNodePubkeys = /* @__PURE__ */ new Set();
+    {
+      const pool = new applesauceRelay.RelayPool();
+      const store = new applesauceCore.EventStore();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(LGTM_RELAYS, {
+          kinds: [38425],
+          "#t": ["lgtm"],
+          limit: 500,
+          authors: [this.routstrPubkey]
+        }).pipe(
+          applesauceRelay.onlyEvents(),
+          rxjs.tap((event) => store.add(event))
+        ).subscribe({ complete: () => resolve() });
+        setTimeout(() => resolve(), timeoutMs);
+      });
+      for (const event of store.getTimeline({ kinds: [38425] })) {
+        const hasLgtmTag = event.tags.some(
+          (tag) => tag[0] === "t" && tag[1]?.toLowerCase() === "lgtm"
+        );
+        if (!hasLgtmTag) continue;
+        for (const tag of event.tags) {
+          if (tag[0] === "node" && typeof tag[1] === "string" && tag[1]) {
+            reviewedNodePubkeys.add(tag[1]);
+          }
+        }
+      }
+    }
+    if (reviewedNodePubkeys.size === 0) {
+      this.logger.warn(
+        "NostrReviews: no kind 38425 lgtm reviews found; keeping disabled providers unchanged"
+      );
+      return [];
+    }
+    if (providerNodes.size === 0) {
+      this.logger.warn(
+        "NostrReviews: no kind 38421 provider node metadata found; keeping disabled providers unchanged"
+      );
+      return [];
+    }
+    const disabledByReview = [];
+    for (const url of baseUrls) {
+      const normalized = this.normalizeUrl(url);
+      const nodePubkeys = providerNodes.get(normalized) || /* @__PURE__ */ new Set();
+      const hasLgtmReview = Array.from(nodePubkeys).some(
+        (pubkey) => reviewedNodePubkeys.has(pubkey)
+      );
+      if (!hasLgtmReview) {
+        disabledByReview.push(normalized);
+      }
+    }
+    this.adapter.setDisabledProviders(Array.from(new Set(disabledByReview)));
+    return disabledByReview;
+  }
+  addProviderNode(map, url, pubkey) {
+    if (!pubkey) return;
+    const normalized = this.normalizeUrl(url);
+    const existing = map.get(normalized) || /* @__PURE__ */ new Set();
+    existing.add(pubkey);
+    map.set(normalized, existing);
+  }
+  /**
+   * Fetch models from all providers and select best-priced options
+   * Uses cache if available and not expired
+   * @param baseUrls List of provider base URLs to fetch from
+   * @param forceRefresh Ignore cache and fetch fresh data
+   * @param onProgress Callback fired after each provider completes with current combined models
+   * @returns Array of unique models with best prices selected
+   */
+  async fetchModels(baseUrls, forceRefresh = false, onProgress) {
+    if (baseUrls.length === 0) {
+      throw new NoProvidersAvailableError();
+    }
+    const bestById = /* @__PURE__ */ new Map();
+    const modelsFromAllProviders = {};
+    const disabledProviders = this.adapter.getDisabledProviders();
+    const estimateMinCost = (m) => {
+      return m?.sats_pricing?.completion ?? 0;
+    };
+    const emitProgress = () => {
+      if (onProgress) {
+        const currentModels = Array.from(bestById.values()).map((v) => v.model);
+        onProgress(currentModels);
+      }
+    };
+    const fetchPromises = baseUrls.map(async (url) => {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      try {
+        let list;
+        if (!forceRefresh) {
+          const lastUpdate = this.adapter.getProviderLastUpdate(base);
+          const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+          if (cacheValid) {
+            const cachedModels = this.adapter.getCachedModels();
+            const cachedList = cachedModels[base] || [];
+            list = cachedList;
+          } else {
+            list = await this.fetchModelsFromProvider(base);
+          }
+        } else {
+          list = await this.fetchModelsFromProvider(base);
+        }
+        modelsFromAllProviders[base] = list;
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        if (!disabledProviders.includes(base)) {
+          for (const m of list) {
+            const existing = bestById.get(m.id);
+            if (!m.sats_pricing) continue;
+            if (!existing) {
+              bestById.set(m.id, { model: m, base });
+              continue;
+            }
+            const currentCost = estimateMinCost(m);
+            const existingCost = estimateMinCost(existing.model);
+            if (currentCost < existingCost && m.sats_pricing) {
+              bestById.set(m.id, { model: m, base });
+            }
+          }
+        }
+        emitProgress();
+        return { success: true, base, list };
+      } catch (error) {
+        if (this.isProviderDownError(error)) {
+          this.logger.warn(`Provider ${base} is down right now.`);
+        } else {
+          this.logger.warn(`Failed to fetch models from ${base}:`, error);
+        }
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        return { success: false, base };
+      }
+    });
+    await Promise.allSettled(fetchPromises);
+    const existingCache = this.adapter.getCachedModels();
+    this.adapter.setCachedModels({
+      ...existingCache,
+      ...modelsFromAllProviders
+    });
+    return Array.from(bestById.values()).map((v) => v.model);
+  }
+  /**
+   * Fetch models from a single provider
+   * @param baseUrl Provider base URL
+   * @returns Array of models from provider
+   */
+  async fetchModelsFromProvider(baseUrl) {
+    const res = await fetch(`${baseUrl}v1/models`);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch models: ${res.status}`);
+    }
+    const json = await res.json();
+    const list = Array.isArray(json?.data) ? json.data : [];
+    return list;
+  }
+  isProviderDownError(error) {
+    if (!(error instanceof Error)) return false;
+    const msg = error.message.toLowerCase();
+    if (msg.includes("fetch failed")) return true;
+    if (msg.includes("429")) return true;
+    if (msg.includes("502")) return true;
+    if (msg.includes("503")) return true;
+    if (msg.includes("504")) return true;
+    const cause = error.cause;
+    return cause?.code === "ENOTFOUND";
+  }
+  /**
+   * Get all cached models from all providers
+   * @returns Record mapping baseUrl -> models
+   */
+  getAllCachedModels() {
+    return this.adapter.getCachedModels();
+  }
+  /**
+   * Clear cache for a specific provider
+   * @param baseUrl Provider base URL
+   */
+  clearProviderCache(baseUrl) {
+    const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const cached = this.adapter.getCachedModels();
+    delete cached[base];
+    this.adapter.setCachedModels(cached);
+    this.adapter.setProviderLastUpdate(base, 0);
+  }
+  /**
+   * Clear all model caches
+   */
+  clearAllCache() {
+    this.adapter.setCachedModels({});
+  }
+  /**
+   * Filter base URLs based on Tor context
+   * @param baseUrls Provider URLs to filter
+   * @param torMode Whether in Tor context
+   * @returns Filtered URLs appropriate for Tor mode
+   */
+  filterBaseUrlsForTor(baseUrls, torMode) {
+    if (!torMode) {
+      return baseUrls.filter((url) => !url.includes(".onion"));
+    }
+    return baseUrls.filter((url) => url.includes(".onion"));
+  }
+  /**
+   * Get provider endpoints from provider info
+   * @param provider Provider object from directory
+   * @param torMode Whether in Tor context
+   * @returns Array of endpoint URLs
+   */
+  getProviderEndpoints(provider, torMode) {
+    const endpoints = [];
+    if (torMode && provider.onion_url) {
+      endpoints.push(this.normalizeUrl(provider.onion_url));
+    } else if (provider.endpoint_url) {
+      endpoints.push(this.normalizeUrl(provider.endpoint_url));
+    }
+    return endpoints;
+  }
+  /**
+   * Normalize provider URL with trailing slash
+   * @param url URL to normalize
+   * @returns Normalized URL
+   */
+  normalizeUrl(url) {
+    if (!url.startsWith("http")) {
+      url = `https://${url}`;
+    }
+    return url.endsWith("/") ? url : `${url}/`;
+  }
+  /**
+   * Fetch routstr21 models from Nostr network (kind 38423)
+   * Uses cache if available and not expired
+   * @returns Array of model IDs or empty array if not found
+   */
+  async fetchRoutstr21Models(forceRefresh = false) {
+    const cachedModels = this.adapter.getRoutstr21Models();
+    if (!forceRefresh && cachedModels.length > 0) {
+      const lastUpdate = this.adapter.getRoutstr21ModelsLastUpdate();
+      const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+      if (cacheValid) {
+        return cachedModels;
+      }
+    }
+    const DEFAULT_RELAYS = [
+      "wss://relay.damus.io",
+      "wss://nos.lol",
+      "wss://relay.routstr.com"
+    ];
+    const pool = new applesauceRelay.RelayPool();
+    const localEventStore = new applesauceCore.EventStore();
+    const timeoutMs = 5e3;
+    await new Promise((resolve) => {
+      pool.req(DEFAULT_RELAYS, {
+        kinds: [38423],
+        "#d": ["routstr-21-models"],
+        limit: 1,
+        authors: [this.routstrPubkey]
+      }).pipe(
+        applesauceRelay.onlyEvents(),
+        rxjs.tap((event2) => {
+          localEventStore.add(event2);
+        })
+      ).subscribe({
+        complete: () => {
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+    });
+    const timeline = localEventStore.getTimeline({ kinds: [38423] });
+    if (timeline.length === 0) {
+      return cachedModels.length > 0 ? cachedModels : [];
+    }
+    const event = timeline[0];
+    try {
+      const content = JSON.parse(event.content);
+      const models = Array.isArray(content?.models) ? content.models : [];
+      this.adapter.setRoutstr21Models(models);
+      this.adapter.setRoutstr21ModelsLastUpdate(Date.now());
+      return models;
+    } catch {
+      this.logger.warn(
+        "Routstr21Models: failed to parse Nostr event content:",
+        event.id
+      );
+      return cachedModels.length > 0 ? cachedModels : [];
+    }
+  }
+};
+
+// discovery/MintDiscovery.ts
+var MintDiscovery = class {
+  constructor(adapter, config = {}) {
+    this.adapter = adapter;
+    this.cacheTTL = config.cacheTTL || 21 * 60 * 1e3;
+    this.logger = (config.logger ?? consoleLogger).child("MintDiscovery");
+  }
+  adapter;
+  cacheTTL;
+  logger;
+  /**
+   * Fetch mints from all providers via their /v1/info endpoints
+   * Caches mints and full provider info for later access
+   * @param baseUrls List of provider base URLs to fetch from
+   * @returns Object with mints and provider info from all providers
+   */
+  async discoverMints(baseUrls, options = {}) {
+    if (baseUrls.length === 0) {
+      return { mintsFromProviders: {}, infoFromProviders: {} };
+    }
+    const mintsFromAllProviders = {};
+    const infoFromAllProviders = {};
+    const forceRefresh = options.forceRefresh ?? false;
+    const fetchPromises = baseUrls.map(async (url) => {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      try {
+        if (!forceRefresh) {
+          const lastUpdate = this.adapter.getProviderLastUpdate(base);
+          const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+          if (cacheValid) {
+            const cachedMints = this.adapter.getCachedMints()[base] || [];
+            const cachedInfo = this.adapter.getCachedProviderInfo()[base];
+            mintsFromAllProviders[base] = cachedMints;
+            if (cachedInfo) {
+              infoFromAllProviders[base] = cachedInfo;
+            }
+            return {
+              success: true,
+              base,
+              mints: cachedMints,
+              info: cachedInfo
+            };
+          }
+        }
+        const res = await fetch(`${base}v1/info`);
+        if (!res.ok) {
+          throw new Error(`Failed to fetch info: ${res.status}`);
+        }
+        const json = await res.json();
+        const mints = Array.isArray(json?.mints) ? json.mints : [];
+        const normalizedMints = mints.map(
+          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+        );
+        mintsFromAllProviders[base] = normalizedMints;
+        infoFromAllProviders[base] = json;
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        return { success: true, base, mints: normalizedMints, info: json };
+      } catch (error) {
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        if (this.isProviderDownError(error)) {
+          this.logger.warn(`Provider ${base} is down right now.`);
+        } else {
+          this.logger.warn(`Failed to fetch mints from ${base}:`, error);
+        }
+        return { success: false, base, mints: [], info: null };
+      }
+    });
+    const results = await Promise.allSettled(fetchPromises);
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const { base, mints, info } = result.value;
+        mintsFromAllProviders[base] = mints;
+        if (info) {
+          infoFromAllProviders[base] = info;
+        }
+      } else {
+        this.logger.error("Mint discovery error:", result.reason);
+      }
+    }
+    try {
+      this.adapter.setCachedMints(mintsFromAllProviders);
+      this.adapter.setCachedProviderInfo(infoFromAllProviders);
+    } catch (error) {
+      this.logger.error("Error caching mint discovery results:", error);
+    }
+    return {
+      mintsFromProviders: mintsFromAllProviders,
+      infoFromProviders: infoFromAllProviders
+    };
+  }
+  /**
+   * Get cached mints from all providers
+   * @returns Record mapping baseUrl -> mint URLs
+   */
+  getCachedMints() {
+    return this.adapter.getCachedMints();
+  }
+  /**
+   * Get cached provider info from all providers
+   * @returns Record mapping baseUrl -> provider info
+   */
+  getCachedProviderInfo() {
+    return this.adapter.getCachedProviderInfo();
+  }
+  /**
+   * Get mints for a specific provider
+   * @param baseUrl Provider base URL
+   * @returns Array of mint URLs for the provider
+   */
+  getProviderMints(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const allMints = this.getCachedMints();
+    return allMints[normalized] || [];
+  }
+  /**
+   * Get info for a specific provider
+   * @param baseUrl Provider base URL
+   * @returns Provider info object or null if not found
+   */
+  getProviderInfo(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const allInfo = this.getCachedProviderInfo();
+    return allInfo[normalized] || null;
+  }
+  /**
+   * Clear mint cache for a specific provider
+   * @param baseUrl Provider base URL
+   */
+  clearProviderMintCache(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const mints = this.getCachedMints();
+    delete mints[normalized];
+    this.adapter.setCachedMints(mints);
+    const info = this.getCachedProviderInfo();
+    delete info[normalized];
+    this.adapter.setCachedProviderInfo(info);
+  }
+  /**
+   * Clear all mint caches
+   */
+  clearAllCache() {
+    this.adapter.setCachedMints({});
+    this.adapter.setCachedProviderInfo({});
+  }
+  isProviderDownError(error) {
+    if (!(error instanceof Error)) return false;
+    const msg = error.message.toLowerCase();
+    if (msg.includes("fetch failed")) return true;
+    if (msg.includes("429")) return true;
+    if (msg.includes("502")) return true;
+    if (msg.includes("503")) return true;
+    if (msg.includes("504")) return true;
+    const cause = error.cause;
+    if (cause?.code === "ENOTFOUND") return true;
+    return false;
+  }
+};
+
+exports.MintDiscovery = MintDiscovery;
+exports.ModelManager = ModelManager;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map