@dexto/core 1.5.7 → 1.6.0

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

@@ -0,0 +1,263 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var auto_update_exports = {};
+__export(auto_update_exports, {
+  getLlmRegistryAutoUpdateStatus: () => getLlmRegistryAutoUpdateStatus,
+  loadLlmRegistryCache: () => loadLlmRegistryCache,
+  refreshLlmRegistryCache: () => refreshLlmRegistryCache,
+  startLlmRegistryAutoUpdate: () => startLlmRegistryAutoUpdate
+});
+module.exports = __toCommonJS(auto_update_exports);
+var import_node_fs = require("node:fs");
+var import_node_fs2 = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_path = require("../../utils/path.js");
+var import_logger = require("../../logger/logger.js");
+var import_types = require("../types.js");
+var import_index = require("./index.js");
+var import_sync = require("./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 (0, import_path.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 = import_index.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 };
+      }
+    }
+    import_index.LLM_REGISTRY[provider].models = finalMerged;
+  }
+}
+function normalizeModelsByProvider(raw) {
+  const out = {};
+  for (const p of import_types.LLM_PROVIDERS) {
+    const value = raw[p];
+    out[p] = Array.isArray(value) ? value.filter(isModelInfo) : [];
+  }
+  return out;
+}
+function tryLoadCacheFromDisk(log) {
+  const cachePath = getCachePath();
+  if (!(0, import_node_fs2.existsSync)(cachePath)) return null;
+  try {
+    const text = (0, import_node_fs2.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 import_node_fs.promises.mkdir(import_node_path.default.dirname(cachePath), { recursive: true });
+  const payload = {
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    modelsByProvider
+  };
+  const tmpPath = `${cachePath}.tmp`;
+  await import_node_fs.promises.writeFile(tmpPath, JSON.stringify(payload), "utf-8");
+  await import_node_fs.promises.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 ?? import_logger.logger;
+  refreshPromise = (async () => {
+    const modelsByProvider = await (0, import_sync.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 ?? import_logger.logger;
+  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?.();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLlmRegistryAutoUpdateStatus,
+  loadLlmRegistryCache,
+  refreshLlmRegistryCache,
+  startLlmRegistryAutoUpdate
+});

package/dist/llm/registry/auto-update.d.ts

@@ -0,0 +1,27 @@
+import type { Logger } from '../../logger/v2/types.js';
+type LogLike = Pick<Logger, 'debug' | 'info' | 'warn' | 'error'>;
+export type LlmRegistryAutoUpdateStatus = {
+    cachePath: string;
+    lastFetchedAt: Date | null;
+    isFresh: boolean;
+    source: 'snapshot' | 'cache' | 'remote';
+};
+export declare function getLlmRegistryAutoUpdateStatus(): LlmRegistryAutoUpdateStatus;
+export declare function loadLlmRegistryCache(options?: {
+    logger?: LogLike;
+}): boolean;
+export declare function refreshLlmRegistryCache(options?: {
+    logger?: LogLike;
+    force?: boolean;
+    /**
+     * Test-only escape hatch to validate refresh behavior with mocks while keeping
+     * network fetch disabled by default in CI/unit tests.
+     */
+    allowInTests?: boolean;
+}): Promise<void>;
+export declare function startLlmRegistryAutoUpdate(options?: {
+    logger?: LogLike;
+    refreshOnStart?: boolean;
+}): void;
+export {};
+//# sourceMappingURL=auto-update.d.ts.map

package/dist/llm/registry/auto-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-update.d.ts","sourceRoot":"","sources":["../../../src/llm/registry/auto-update.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAOvD,KAAK,OAAO,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAuKjE,MAAM,MAAM,2BAA2B,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,IAAI,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC;CAC3C,CAAC;AAMF,wBAAgB,8BAA8B,IAAI,2BAA2B,CAU5E;AAED,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAO5E;AAiBD,wBAAsB,uBAAuB,CAAC,OAAO,CAAC,EAAE;IACpD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CAC1B,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDhB;AAED,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE;IACjD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,IAAI,CA6BP"}

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
+};