@routstr/sdk 0.3.7 → 0.3.9

package/dist/discovery/index.mjs

@@ -0,0 +1,891 @@
+import { RelayPool, onlyEvents } from 'applesauce-relay';
+import { EventStore } from 'applesauce-core';
+import { tap } from '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";
+  }
+};
+function isBunRuntime() {
+  return typeof Bun !== "undefined";
+}
+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");
+    this.eventStoreDbPath = config.eventStoreDbPath;
+  }
+  adapter;
+  cacheTTL;
+  providerDirectoryUrl;
+  includeProviderUrls;
+  excludeProviderUrls;
+  routstrPubkey;
+  logger;
+  providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+  /** Persistent event store for relay-fetched events (null if not configured/initialized) */
+  eventStore = null;
+  eventStoreDb = null;
+  eventStoreInitPromise = null;
+  eventStoreDbPath;
+  /**
+   * Get the list of bootstrapped provider base URLs
+   * @returns Array of provider base URLs
+   */
+  getBaseUrls() {
+    return this.adapter.getBaseUrlsList();
+  }
+  /**
+   * Lazily initialize the persistent event store.
+   * Returns null if no eventStoreDbPath was provided.
+   */
+  async ensureEventStore() {
+    if (!this.eventStoreDbPath) return null;
+    if (this.eventStore) return this.eventStore;
+    if (!this.eventStoreInitPromise) {
+      this.eventStoreInitPromise = (async () => {
+        try {
+          const db = await this.createPersistentEventDatabase();
+          this.eventStoreDb = db;
+          this.eventStore = new EventStore({ database: db });
+          this.initializeEventStoreMetadata();
+          this.logger.log(
+            `Persistent event store initialized at ${this.eventStoreDbPath}`
+          );
+          return this.eventStore;
+        } catch (error) {
+          this.eventStoreInitPromise = null;
+          throw new Error(
+            `applesauce-sqlite with a supported SQLite driver is required for persistent Nostr event storage. Bun uses bun:sqlite; Node.js uses better-sqlite3. Install optional dependencies or omit eventStoreDbPath. (${error})`
+          );
+        }
+      })();
+    }
+    return this.eventStoreInitPromise;
+  }
+  /**
+   * Get the persistent event store, initializing it if configured.
+   * Returns null if no eventStoreDbPath was provided.
+   */
+  async getEventStore() {
+    return this.ensureEventStore();
+  }
+  async createPersistentEventDatabase() {
+    if (isBunRuntime()) {
+      const { BunSqliteEventDatabase } = await import('applesauce-sqlite/bun');
+      return new BunSqliteEventDatabase(
+        this.eventStoreDbPath
+      );
+    }
+    const { BetterSqlite3EventDatabase } = await import('applesauce-sqlite/better-sqlite3');
+    return new BetterSqlite3EventDatabase(
+      this.eventStoreDbPath
+    );
+  }
+  /** Close the persistent event store database handle, if configured. */
+  closeEventStore() {
+    this.eventStoreDb?.close?.();
+    this.eventStore = null;
+    this.eventStoreDb = null;
+    this.eventStoreInitPromise = null;
+  }
+  initializeEventStoreMetadata() {
+    this.eventStoreDb?.db?.exec(
+      `CREATE TABLE IF NOT EXISTS routstr_event_cache_metadata (
+        event_id TEXT PRIMARY KEY,
+        fetched_at INTEGER NOT NULL
+      )`
+    );
+  }
+  markEventFetched(event, fetchedAt = Date.now()) {
+    const db = this.eventStoreDb?.db;
+    if (!db) return;
+    db.prepare(
+      `INSERT INTO routstr_event_cache_metadata (event_id, fetched_at)
+       VALUES (?, ?)
+       ON CONFLICT(event_id) DO UPDATE SET fetched_at = excluded.fetched_at`
+    ).run?.(event.id, fetchedAt);
+  }
+  getEventFetchedAt(event) {
+    const db = this.eventStoreDb?.db;
+    if (!db) return void 0;
+    const row = db.prepare(
+      `SELECT fetched_at FROM routstr_event_cache_metadata WHERE event_id = ?`
+    ).get?.(event.id);
+    return typeof row?.fetched_at === "number" ? row.fetched_at : void 0;
+  }
+  /**
+   * Check the persistent event store for fresh cached events.
+   * Returns events from SQLite if they were fetched within `maxAge`, otherwise
+   * returns empty array (caller should hit relays). Events without local fetch
+   * metadata fall back to Nostr created_at for backwards compatibility.
+   */
+  async getCachedNostrEvents(filter, maxAge, forceRefresh = false) {
+    const eventStore = await this.ensureEventStore();
+    if (forceRefresh) return [];
+    if (!eventStore) return [];
+    const timeline = eventStore.getTimeline(filter);
+    if (timeline.length === 0) return [];
+    const cutoff = Date.now() - maxAge;
+    const freshest = Math.max(
+      ...timeline.map((e) => this.getEventFetchedAt(e) ?? e.created_at * 1e3)
+    );
+    if (freshest < cutoff) return [];
+    return timeline;
+  }
+  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,
+            this.providerNodePubkeysByUrl,
+            forceRefresh
+          );
+          return filteredCachedUrls;
+        }
+      }
+    }
+    try {
+      const nostrProviders = await this.bootstrapFromNostr(
+        38421,
+        torMode,
+        forceRefresh
+      );
+      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,
+          this.providerNodePubkeysByUrl,
+          forceRefresh
+        );
+        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 38421)
+   * @param kind The Nostr kind to fetch
+   * @param torMode Whether running in Tor context
+   * @returns Array of provider base URLs
+   */
+  async bootstrapFromNostr(kind, torMode, forceRefresh = false) {
+    const DEFAULT_RELAYS = [
+      "wss://relay.primal.net",
+      "wss://nos.lol",
+      "wss://relay.damus.io"
+    ];
+    const cached = await this.getCachedNostrEvents(
+      { kinds: [kind] },
+      this.cacheTTL,
+      forceRefresh
+    );
+    let sessionEvents = cached;
+    if (cached.length === 0) {
+      const pool = new RelayPool();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(DEFAULT_RELAYS, {
+          kinds: [kind],
+          limit: 100
+        }).pipe(
+          onlyEvents(),
+          tap((event) => {
+            sessionEvents.push(event);
+            this.eventStore?.add(event);
+            this.markEventFetched(event);
+          })
+        ).subscribe({
+          complete: () => {
+            resolve();
+          }
+        });
+        setTimeout(() => {
+          resolve();
+        }, timeoutMs);
+      });
+    } else {
+      this.logger.log(`Using ${cached.length} cached kind ${kind} events from persistent store`);
+    }
+    const bases = /* @__PURE__ */ new Set();
+    this.providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+    for (const event of sessionEvents) {
+      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,
+          this.providerNodePubkeysByUrl,
+          forceRefresh
+        );
+      }
+      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, forceRefresh = false) {
+    if (baseUrls.length === 0) return [];
+    if (!this.adapter.setDisabledProviders) {
+      this.logger.warn(
+        "NostrReviews: adapter does not support setDisabledProviders; skipping provider disable sync"
+      );
+      return [];
+    }
+    const reviewedNodePubkeys = /* @__PURE__ */ new Set();
+    {
+      const cached = await this.getCachedNostrEvents(
+        { kinds: [38425], "#t": ["lgtm"], authors: [this.routstrPubkey] },
+        this.cacheTTL,
+        forceRefresh
+      );
+      let sessionEvents = cached;
+      if (cached.length === 0) {
+        const LGTM_RELAYS = [
+          "wss://relay.primal.net",
+          "wss://nos.lol",
+          "wss://relay.damus.io",
+          "wss://relay.routstr.com"
+        ];
+        const pool = new RelayPool();
+        const timeoutMs = 5e3;
+        await new Promise((resolve) => {
+          pool.req(LGTM_RELAYS, {
+            kinds: [38425],
+            "#t": ["lgtm"],
+            limit: 500,
+            authors: [this.routstrPubkey]
+          }).pipe(
+            onlyEvents(),
+            tap((event) => {
+              sessionEvents.push(event);
+              this.eventStore?.add(event);
+              this.markEventFetched(event);
+            })
+          ).subscribe({ complete: () => resolve() });
+          setTimeout(() => resolve(), timeoutMs);
+        });
+      } else {
+        this.logger.log(`Using ${cached.length} cached kind 38425 events from persistent store`);
+      }
+      for (const event of sessionEvents) {
+        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(`Provider ${base} unreachable: ${error.message}`);
+        }
+        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 cached = await this.getCachedNostrEvents(
+      { kinds: [38423], "#d": ["routstr-21-models"], authors: [this.routstrPubkey] },
+      this.cacheTTL,
+      forceRefresh
+    );
+    let sessionEvents = cached;
+    if (cached.length === 0) {
+      const pool = new RelayPool();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(DEFAULT_RELAYS, {
+          kinds: [38423],
+          "#d": ["routstr-21-models"],
+          limit: 1,
+          authors: [this.routstrPubkey]
+        }).pipe(
+          onlyEvents(),
+          tap((event2) => {
+            sessionEvents.push(event2);
+            this.eventStore?.add(event2);
+            this.markEventFetched(event2);
+          })
+        ).subscribe({
+          complete: () => {
+            resolve();
+          }
+        });
+        setTimeout(() => {
+          resolve();
+        }, timeoutMs);
+      });
+    } else {
+      this.logger.log(`Using ${cached.length} cached kind 38423 events from persistent store`);
+    }
+    if (sessionEvents.length === 0) {
+      return cachedModels.length > 0 ? cachedModels : [];
+    }
+    const event = sessionEvents[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;
+  }
+};
+
+export { MintDiscovery, ModelManager };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map