@fallom/trace 0.2.15 → 0.2.16

package/dist/chunk-KFD5AQ7V.mjs

@@ -1,308 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/models.ts
-var models_exports = {};
-__export(models_exports, {
-  get: () => get,
-  init: () => init
-});
-import { createHash } from "crypto";
-var apiKey = null;
-var baseUrl = "https://configs.fallom.com";
-var initialized = false;
-var syncInterval = null;
-var debugMode = false;
-var configCache = /* @__PURE__ */ new Map();
-var SYNC_TIMEOUT = 2e3;
-var RECORD_TIMEOUT = 1e3;
-function log(msg) {
-  if (debugMode) {
-    console.log(`[Fallom] ${msg}`);
-  }
-}
-function evaluateTargeting(targeting, customerId, context) {
-  if (!targeting || targeting.enabled === false) {
-    return null;
-  }
-  const evalContext = {
-    ...context || {},
-    ...customerId ? { customerId } : {}
-  };
-  log(`Evaluating targeting with context: ${JSON.stringify(evalContext)}`);
-  if (targeting.individualTargets) {
-    for (const target of targeting.individualTargets) {
-      const fieldValue = evalContext[target.field];
-      if (fieldValue === target.value) {
-        log(`Individual target matched: ${target.field}=${target.value} -> variant ${target.variantIndex}`);
-        return target.variantIndex;
-      }
-    }
-  }
-  if (targeting.rules) {
-    for (const rule of targeting.rules) {
-      const allConditionsMatch = rule.conditions.every((condition) => {
-        const fieldValue = evalContext[condition.field];
-        if (fieldValue === void 0) return false;
-        switch (condition.operator) {
-          case "eq":
-            return fieldValue === condition.value;
-          case "neq":
-            return fieldValue !== condition.value;
-          case "in":
-            return Array.isArray(condition.value) && condition.value.includes(fieldValue);
-          case "nin":
-            return Array.isArray(condition.value) && !condition.value.includes(fieldValue);
-          case "contains":
-            return typeof condition.value === "string" && fieldValue.includes(condition.value);
-          case "startsWith":
-            return typeof condition.value === "string" && fieldValue.startsWith(condition.value);
-          case "endsWith":
-            return typeof condition.value === "string" && fieldValue.endsWith(condition.value);
-          default:
-            return false;
-        }
-      });
-      if (allConditionsMatch) {
-        log(`Rule matched: ${JSON.stringify(rule.conditions)} -> variant ${rule.variantIndex}`);
-        return rule.variantIndex;
-      }
-    }
-  }
-  log("No targeting rules matched, falling back to weighted random");
-  return null;
-}
-function init(options = {}) {
-  apiKey = options.apiKey || process.env.FALLOM_API_KEY || null;
-  baseUrl = options.baseUrl || process.env.FALLOM_CONFIGS_URL || process.env.FALLOM_BASE_URL || "https://configs.fallom.com";
-  initialized = true;
-  if (!apiKey) {
-    return;
-  }
-  fetchConfigs().catch(() => {
-  });
-  if (!syncInterval) {
-    syncInterval = setInterval(() => {
-      fetchConfigs().catch(() => {
-      });
-    }, 3e4);
-    syncInterval.unref();
-  }
-}
-function ensureInit() {
-  if (!initialized) {
-    try {
-      init();
-    } catch {
-    }
-  }
-}
-async function fetchConfigs(timeout = SYNC_TIMEOUT) {
-  if (!apiKey) {
-    log("_fetchConfigs: No API key, skipping");
-    return;
-  }
-  try {
-    log(`Fetching configs from ${baseUrl}/configs`);
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const resp = await fetch(`${baseUrl}/configs`, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    log(`Response status: ${resp.status}`);
-    if (resp.ok) {
-      const data = await resp.json();
-      const configs = data.configs || [];
-      log(`Got ${configs.length} configs: ${configs.map((c) => c.key)}`);
-      for (const c of configs) {
-        const key = c.key;
-        const version = c.version || 1;
-        log(`Config '${key}' v${version}: ${JSON.stringify(c.variants)}`);
-        if (!configCache.has(key)) {
-          configCache.set(key, { versions: /* @__PURE__ */ new Map(), latest: null });
-        }
-        const cached = configCache.get(key);
-        cached.versions.set(version, c);
-        cached.latest = version;
-      }
-    } else {
-      log(`Fetch failed: ${resp.statusText}`);
-    }
-  } catch (e) {
-    log(`Fetch exception: ${e}`);
-  }
-}
-async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT) {
-  if (!apiKey) return null;
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const resp = await fetch(
-      `${baseUrl}/configs/${configKey}/version/${version}`,
-      {
-        headers: { Authorization: `Bearer ${apiKey}` },
-        signal: controller.signal
-      }
-    );
-    clearTimeout(timeoutId);
-    if (resp.ok) {
-      const config = await resp.json();
-      if (!configCache.has(configKey)) {
-        configCache.set(configKey, { versions: /* @__PURE__ */ new Map(), latest: null });
-      }
-      configCache.get(configKey).versions.set(version, config);
-      return config;
-    }
-  } catch {
-  }
-  return null;
-}
-async function get(configKey, sessionId, options = {}) {
-  const { version, fallback, customerId, context, debug = false } = options;
-  debugMode = debug;
-  ensureInit();
-  log(
-    `get() called: configKey=${configKey}, sessionId=${sessionId}, fallback=${fallback}`
-  );
-  try {
-    let configData = configCache.get(configKey);
-    log(
-      `Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`
-    );
-    if (!configData) {
-      log("Not in cache, fetching...");
-      await fetchConfigs(SYNC_TIMEOUT);
-      configData = configCache.get(configKey);
-      log(
-        `After fetch, cache lookup: ${configData ? "found" : "still not found"}`
-      );
-    }
-    if (!configData) {
-      log(`Config not found, using fallback: ${fallback}`);
-      if (fallback) {
-        console.warn(
-          `[Fallom WARNING] Config '${configKey}' not found, using fallback model: ${fallback}`
-        );
-        return returnModel(configKey, sessionId, fallback, 0);
-      }
-      throw new Error(
-        `Config '${configKey}' not found. Check that it exists in your Fallom dashboard.`
-      );
-    }
-    let config;
-    let targetVersion;
-    if (version !== void 0) {
-      config = configData.versions.get(version);
-      if (!config) {
-        config = await fetchSpecificVersion(configKey, version, SYNC_TIMEOUT) || void 0;
-      }
-      if (!config) {
-        if (fallback) {
-          console.warn(
-            `[Fallom WARNING] Config '${configKey}' version ${version} not found, using fallback: ${fallback}`
-          );
-          return returnModel(configKey, sessionId, fallback, 0);
-        }
-        throw new Error(`Config '${configKey}' version ${version} not found.`);
-      }
-      targetVersion = version;
-    } else {
-      targetVersion = configData.latest;
-      config = configData.versions.get(targetVersion);
-      if (!config) {
-        if (fallback) {
-          console.warn(
-            `[Fallom WARNING] Config '${configKey}' has no cached version, using fallback: ${fallback}`
-          );
-          return returnModel(configKey, sessionId, fallback, 0);
-        }
-        throw new Error(`Config '${configKey}' has no cached version.`);
-      }
-    }
-    const variantsRaw = config.variants;
-    const configVersion = config.version || targetVersion;
-    const variants = Array.isArray(variantsRaw) ? variantsRaw : Object.values(variantsRaw);
-    log(
-      `Config found! Version: ${configVersion}, Variants: ${JSON.stringify(
-        variants
-      )}`
-    );
-    const targetedVariantIndex = evaluateTargeting(config.targeting, customerId, context);
-    if (targetedVariantIndex !== null && variants[targetedVariantIndex]) {
-      const assignedModel2 = variants[targetedVariantIndex].model;
-      log(`\u2705 Assigned model via targeting: ${assignedModel2}`);
-      return returnModel(configKey, sessionId, assignedModel2, configVersion);
-    }
-    const hashBytes = createHash("md5").update(sessionId).digest();
-    const hashVal = hashBytes.readUInt32BE(0) % 1e6;
-    log(`Session hash: ${hashVal} (out of 1,000,000)`);
-    let cumulative = 0;
-    let assignedModel = variants[variants.length - 1].model;
-    for (const v of variants) {
-      const oldCumulative = cumulative;
-      cumulative += v.weight * 1e4;
-      log(
-        `Variant ${v.model}: weight=${v.weight}%, range=${oldCumulative}-${cumulative}, hash=${hashVal}, match=${hashVal < cumulative}`
-      );
-      if (hashVal < cumulative) {
-        assignedModel = v.model;
-        break;
-      }
-    }
-    log(`\u2705 Assigned model via weighted random: ${assignedModel}`);
-    return returnModel(configKey, sessionId, assignedModel, configVersion);
-  } catch (e) {
-    if (e instanceof Error && e.message.includes("not found")) {
-      throw e;
-    }
-    if (fallback) {
-      console.warn(
-        `[Fallom WARNING] Error getting model for '${configKey}': ${e}. Using fallback: ${fallback}`
-      );
-      return returnModel(configKey, sessionId, fallback, 0);
-    }
-    throw e;
-  }
-}
-function returnModel(configKey, sessionId, model, version) {
-  if (version > 0) {
-    recordSession(configKey, version, sessionId, model).catch(() => {
-    });
-  }
-  return model;
-}
-async function recordSession(configKey, version, sessionId, model) {
-  if (!apiKey) return;
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), RECORD_TIMEOUT);
-    await fetch(`${baseUrl}/sessions`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        config_key: configKey,
-        config_version: version,
-        session_id: sessionId,
-        assigned_model: model
-      }),
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-  } catch {
-  }
-}
-
-export {
-  __export,
-  init,
-  get,
-  models_exports
-};

package/dist/models-SEFDGZU2.mjs

@@ -1,8 +0,0 @@
-import {
-  get,
-  init
-} from "./chunk-KFD5AQ7V.mjs";
-export {
-  get,
-  init
-};