@routstr/sdk 0.3.5 → 0.3.7

package/dist/discovery/index.mjs

@@ -1,613 +0,0 @@
-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";
-  }
-};
-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.logger = (config.logger ?? consoleLogger).child("ModelManager");
-  }
-  cacheTTL;
-  providerDirectoryUrl;
-  includeProviderUrls;
-  excludeProviderUrls;
-  logger;
-  /**
-   * 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) {
-          await this.fetchRoutstr21Models(forceRefresh);
-          return this.filterBaseUrlsForTor(cachedUrls, torMode);
-        }
-      }
-    }
-    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);
-        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 RelayPool();
-    const localEventStore = new EventStore();
-    const timeoutMs = 5e3;
-    await new Promise((resolve) => {
-      pool.req(DEFAULT_RELAYS, {
-        kinds: [kind],
-        limit: 100
-      }).pipe(
-        onlyEvents(),
-        tap((event) => {
-          localEventStore.add(event);
-        })
-      ).subscribe({
-        complete: () => {
-          resolve();
-        }
-      });
-      setTimeout(() => {
-        resolve();
-      }, timeoutMs);
-    });
-    const timeline = localEventStore.getTimeline({ kinds: [kind] });
-    const bases = /* @__PURE__ */ new Set();
-    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);
-          }
-        }
-        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);
-          }
-        }
-      } 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);
-              }
-            }
-          }
-        } 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();
-      for (const p of providers) {
-        const endpoints = this.getProviderEndpoints(p, torMode);
-        for (const endpoint of endpoints) {
-          bases.add(endpoint);
-        }
-      }
-      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);
-      }
-      return list;
-    } catch (e) {
-      this.logger.error("Failed to bootstrap providers", e);
-      throw new ProviderBootstrapError([], `Provider bootstrap failed: ${e}`);
-    }
-  }
-  /**
-   * 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 RelayPool();
-    const localEventStore = new EventStore();
-    const timeoutMs = 5e3;
-    await new Promise((resolve) => {
-      pool.req(DEFAULT_RELAYS, {
-        kinds: [38423],
-        "#d": ["routstr-21-models"],
-        limit: 1,
-        authors: [
-          "4ad6fa2d16e2a9b576c863b4cf7404a70d4dc320c0c447d10ad6ff58993eacc8"
-        ]
-      }).pipe(
-        onlyEvents(),
-        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");
-  }
-  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