@dexto/core 1.5.7 → 1.5.8

package/dist/llm/registry/auto-update.js

@@ -0,0 +1,227 @@
+import "../../chunk-PTJYTZNU.js";
+import { promises as fs } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { getDextoGlobalPath } from "../../utils/path.js";
+import { logger as defaultLogger } from "../../logger/logger.js";
+import { LLM_PROVIDERS } from "../types.js";
+import { LLM_REGISTRY } from "./index.js";
+import { buildModelsByProviderFromRemote } from "./sync.js";
+const CACHE_SUBDIR = "cache";
+const CACHE_FILENAME = "llm-registry-models.json";
+const CACHE_SCHEMA_VERSION = 1;
+const DEFAULT_TTL_MS = 1e3 * 60 * 60;
+const MIN_REFRESH_INTERVAL_MS = 1e3 * 60 * 5;
+const UPDATABLE_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "google",
+  "groq",
+  "xai",
+  "cohere",
+  "minimax",
+  "glm",
+  "vertex",
+  "bedrock"
+];
+function truthyEnv(name) {
+  const v = process.env[name];
+  if (!v) return false;
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function getTtlMs() {
+  const raw = process.env.DEXTO_LLM_REGISTRY_TTL_MS;
+  if (!raw) return DEFAULT_TTL_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_TTL_MS;
+}
+function getCachePath() {
+  return getDextoGlobalPath(CACHE_SUBDIR, CACHE_FILENAME);
+}
+function isModelInfo(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const name = value.name;
+  return typeof name === "string" && name.trim() !== "";
+}
+function applyModelsByProvider(modelsByProvider) {
+  for (const provider of UPDATABLE_PROVIDERS) {
+    const incoming = modelsByProvider[provider] ?? [];
+    const existing = LLM_REGISTRY[provider].models ?? [];
+    const incomingByName = /* @__PURE__ */ new Map();
+    for (const m of incoming) {
+      incomingByName.set(m.name.toLowerCase(), m);
+    }
+    const existingDefault = existing.find((m) => m.default)?.name.toLowerCase();
+    const incomingDefault = incoming.find((m) => m.default)?.name.toLowerCase();
+    const merged = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const m of existing) {
+      const key = m.name.toLowerCase();
+      const updated = incomingByName.get(key);
+      if (!updated) {
+        merged.push(m);
+      } else {
+        const name = updated.name ?? m.name;
+        const maxInputTokens = typeof updated.maxInputTokens === "number" && updated.maxInputTokens > 0 ? updated.maxInputTokens : m.maxInputTokens;
+        const supportedFileTypes = Array.isArray(updated.supportedFileTypes) ? updated.supportedFileTypes : m.supportedFileTypes;
+        const displayName = updated.displayName ?? m.displayName;
+        const pricing = updated.pricing ?? m.pricing;
+        merged.push({
+          name,
+          maxInputTokens,
+          supportedFileTypes,
+          ...displayName ? { displayName } : {},
+          ...pricing ? { pricing } : {}
+        });
+      }
+      seen.add(key);
+    }
+    const newModels = incoming.filter((m) => !seen.has(m.name.toLowerCase()));
+    newModels.sort((a, b) => a.name.localeCompare(b.name));
+    merged.push(...newModels);
+    const chosenDefault = incomingDefault ?? existingDefault ?? merged[0]?.name.toLowerCase();
+    const finalMerged = merged.map((m) => {
+      const copy = { ...m };
+      delete copy.default;
+      return copy;
+    });
+    if (chosenDefault) {
+      const idx = finalMerged.findIndex((m) => m.name.toLowerCase() === chosenDefault);
+      if (idx >= 0) {
+        finalMerged[idx] = { ...finalMerged[idx], default: true };
+      }
+    }
+    LLM_REGISTRY[provider].models = finalMerged;
+  }
+}
+function normalizeModelsByProvider(raw) {
+  const out = {};
+  for (const p of LLM_PROVIDERS) {
+    const value = raw[p];
+    out[p] = Array.isArray(value) ? value.filter(isModelInfo) : [];
+  }
+  return out;
+}
+function tryLoadCacheFromDisk(log) {
+  const cachePath = getCachePath();
+  if (!existsSync(cachePath)) return null;
+  try {
+    const text = readFileSync(cachePath, "utf-8");
+    const parsed = JSON.parse(text);
+    if (parsed.schemaVersion !== CACHE_SCHEMA_VERSION) return null;
+    if (!parsed.fetchedAt || typeof parsed.fetchedAt !== "string") return null;
+    if (!parsed.modelsByProvider || typeof parsed.modelsByProvider !== "object") return null;
+    const fetchedAt = Date.parse(parsed.fetchedAt);
+    if (!Number.isFinite(fetchedAt)) return null;
+    const modelsByProvider = normalizeModelsByProvider(
+      parsed.modelsByProvider
+    );
+    return { fetchedAt, modelsByProvider };
+  } catch (e) {
+    log?.warn?.(
+      `Failed to load LLM registry cache (${cachePath}): ${e instanceof Error ? e.message : String(e)}`
+    );
+    return null;
+  }
+}
+let refreshPromise = null;
+let lastRefreshAttemptAt = null;
+let lastFetchedAt = null;
+let lastSource = "snapshot";
+let autoRefreshStarted = false;
+function isFresh(now, fetchedAt, ttlMs) {
+  return now - fetchedAt < ttlMs;
+}
+function getLlmRegistryAutoUpdateStatus() {
+  const cachePath = getCachePath();
+  const fetchedAt = lastFetchedAt ? new Date(lastFetchedAt) : null;
+  const now = Date.now();
+  return {
+    cachePath,
+    lastFetchedAt: fetchedAt,
+    isFresh: lastFetchedAt ? isFresh(now, lastFetchedAt, getTtlMs()) : false,
+    source: lastSource
+  };
+}
+function loadLlmRegistryCache(options) {
+  const cache = tryLoadCacheFromDisk(options?.logger);
+  if (!cache) return false;
+  applyModelsByProvider(cache.modelsByProvider);
+  lastFetchedAt = cache.fetchedAt;
+  lastSource = "cache";
+  return true;
+}
+async function writeCacheFile(cachePath, modelsByProvider) {
+  await fs.mkdir(path.dirname(cachePath), { recursive: true });
+  const payload = {
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    modelsByProvider
+  };
+  const tmpPath = `${cachePath}.tmp`;
+  await fs.writeFile(tmpPath, JSON.stringify(payload), "utf-8");
+  await fs.rename(tmpPath, cachePath);
+}
+async function refreshLlmRegistryCache(options) {
+  if (truthyEnv("DEXTO_LLM_REGISTRY_DISABLE_FETCH") || !options?.allowInTests && (process.env.NODE_ENV === "test" || truthyEnv("VITEST"))) {
+    return;
+  }
+  if (refreshPromise && !options?.force) {
+    await refreshPromise;
+    return;
+  }
+  const now = Date.now();
+  if (!options?.force && lastRefreshAttemptAt && now - lastRefreshAttemptAt < MIN_REFRESH_INTERVAL_MS) {
+    if (refreshPromise) await refreshPromise;
+    return;
+  }
+  lastRefreshAttemptAt = now;
+  const log = options?.logger ?? defaultLogger;
+  refreshPromise = (async () => {
+    const modelsByProvider = await buildModelsByProviderFromRemote({
+      userAgent: "dexto-llm-registry",
+      timeoutMs: 3e4
+    });
+    const cachePath = getCachePath();
+    await writeCacheFile(cachePath, modelsByProvider);
+    applyModelsByProvider(modelsByProvider);
+    lastFetchedAt = Date.now();
+    lastSource = "remote";
+    log?.debug?.(`Refreshed LLM registry cache (${cachePath})`);
+  })().catch((e) => {
+    log?.warn?.(
+      `Failed to refresh LLM registry cache: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }).finally(() => {
+    refreshPromise = null;
+  });
+  await refreshPromise;
+}
+function startLlmRegistryAutoUpdate(options) {
+  if (autoRefreshStarted) return;
+  autoRefreshStarted = true;
+  const log = options?.logger ?? defaultLogger;
+  const loaded = loadLlmRegistryCache({ logger: log });
+  if (loaded) {
+    log?.debug?.(`Loaded LLM registry cache from disk (${getCachePath()})`);
+  }
+  if (options?.refreshOnStart !== false) {
+    void refreshLlmRegistryCache({ logger: log });
+  }
+  const timer = setInterval(
+    () => {
+      const ttlMs = getTtlMs();
+      const now = Date.now();
+      if (lastFetchedAt && isFresh(now, lastFetchedAt, ttlMs)) return;
+      void refreshLlmRegistryCache({ logger: log });
+    },
+    Math.min(getTtlMs(), DEFAULT_TTL_MS)
+  );
+  timer.unref?.();
+}
+export {
+  getLlmRegistryAutoUpdateStatus,
+  loadLlmRegistryCache,
+  refreshLlmRegistryCache,
+  startLlmRegistryAutoUpdate
+};