@fallom/trace 0.1.1 → 0.1.4

package/dist/index.js

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,12 +20,252 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/prompts.ts
+var prompts_exports = {};
+__export(prompts_exports, {
+  clearPromptContext: () => clearPromptContext,
+  get: () => get,
+  getAB: () => getAB,
+  getPromptContext: () => getPromptContext,
+  init: () => init
+});
+function log(msg) {
+  if (debugMode) {
+    console.log(`[Fallom Prompts] ${msg}`);
+  }
+}
+function init(options = {}) {
+  apiKey = options.apiKey || process.env.FALLOM_API_KEY || null;
+  baseUrl = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
+  initialized = true;
+  if (!apiKey) {
+    return;
+  }
+  fetchAll().catch(() => {
+  });
+  if (!syncInterval) {
+    syncInterval = setInterval(() => {
+      fetchAll().catch(() => {
+      });
+    }, 3e4);
+    syncInterval.unref();
+  }
+}
+function ensureInit() {
+  if (!initialized) {
+    try {
+      init();
+    } catch {
+    }
+  }
+}
+async function fetchAll() {
+  await Promise.all([fetchPrompts(), fetchPromptABTests()]);
+}
+async function fetchPrompts(timeout = SYNC_TIMEOUT) {
+  if (!apiKey) return;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const resp = await fetch(`${baseUrl}/prompts`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (resp.ok) {
+      const data = await resp.json();
+      for (const p of data.prompts || []) {
+        if (!promptCache.has(p.key)) {
+          promptCache.set(p.key, { versions: /* @__PURE__ */ new Map(), current: null });
+        }
+        const cached = promptCache.get(p.key);
+        cached.versions.set(p.version, {
+          systemPrompt: p.system_prompt,
+          userTemplate: p.user_template
+        });
+        cached.current = p.version;
+      }
+    }
+  } catch {
+  }
+}
+async function fetchPromptABTests(timeout = SYNC_TIMEOUT) {
+  if (!apiKey) return;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const resp = await fetch(`${baseUrl}/prompt-ab-tests`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (resp.ok) {
+      const data = await resp.json();
+      for (const t of data.prompt_ab_tests || []) {
+        if (!promptABCache.has(t.key)) {
+          promptABCache.set(t.key, { versions: /* @__PURE__ */ new Map(), current: null });
+        }
+        const cached = promptABCache.get(t.key);
+        cached.versions.set(t.version, { variants: t.variants });
+        cached.current = t.version;
+      }
+    }
+  } catch {
+  }
+}
+function replaceVariables(template, variables) {
+  if (!variables) return template;
+  return template.replace(/\{\{(\s*\w+\s*)\}\}/g, (match, varName) => {
+    const key = varName.trim();
+    return key in variables ? String(variables[key]) : match;
+  });
+}
+function setPromptContext(ctx) {
+  promptContext = ctx;
+}
+function getPromptContext() {
+  const ctx = promptContext;
+  promptContext = null;
+  return ctx;
+}
+async function get(promptKey, options = {}) {
+  const { variables, version, debug = false } = options;
+  debugMode = debug;
+  ensureInit();
+  log(`get() called: promptKey=${promptKey}`);
+  let promptData = promptCache.get(promptKey);
+  if (!promptData) {
+    log("Not in cache, fetching...");
+    await fetchPrompts(SYNC_TIMEOUT);
+    promptData = promptCache.get(promptKey);
+  }
+  if (!promptData) {
+    throw new Error(
+      `Prompt '${promptKey}' not found. Check that it exists in your Fallom dashboard.`
+    );
+  }
+  const targetVersion = version ?? promptData.current;
+  const content = promptData.versions.get(targetVersion);
+  if (!content) {
+    throw new Error(
+      `Prompt '${promptKey}' version ${targetVersion} not found.`
+    );
+  }
+  const system = replaceVariables(content.systemPrompt, variables);
+  const user = replaceVariables(content.userTemplate, variables);
+  setPromptContext({
+    promptKey,
+    promptVersion: targetVersion
+  });
+  log(`\u2705 Got prompt: ${promptKey} v${targetVersion}`);
+  return {
+    key: promptKey,
+    version: targetVersion,
+    system,
+    user
+  };
+}
+async function getAB(abTestKey, sessionId, options = {}) {
+  const { variables, debug = false } = options;
+  debugMode = debug;
+  ensureInit();
+  log(`getAB() called: abTestKey=${abTestKey}, sessionId=${sessionId}`);
+  let abData = promptABCache.get(abTestKey);
+  if (!abData) {
+    log("Not in cache, fetching...");
+    await fetchPromptABTests(SYNC_TIMEOUT);
+    abData = promptABCache.get(abTestKey);
+  }
+  if (!abData) {
+    throw new Error(
+      `Prompt A/B test '${abTestKey}' not found. Check that it exists in your Fallom dashboard.`
+    );
+  }
+  const currentVersion = abData.current;
+  const versionData = abData.versions.get(currentVersion);
+  if (!versionData) {
+    throw new Error(`Prompt A/B test '${abTestKey}' has no current version.`);
+  }
+  const { variants } = versionData;
+  const hashBytes = (0, import_crypto.createHash)("md5").update(sessionId).digest();
+  const hashVal = hashBytes.readUInt32BE(0) % 1e6;
+  let cumulative = 0;
+  let selectedVariant = variants[variants.length - 1];
+  let selectedIndex = variants.length - 1;
+  for (let i = 0; i < variants.length; i++) {
+    cumulative += variants[i].weight * 1e4;
+    if (hashVal < cumulative) {
+      selectedVariant = variants[i];
+      selectedIndex = i;
+      break;
+    }
+  }
+  const promptKey = selectedVariant.prompt_key;
+  const promptVersion = selectedVariant.prompt_version;
+  let promptData = promptCache.get(promptKey);
+  if (!promptData) {
+    await fetchPrompts(SYNC_TIMEOUT);
+    promptData = promptCache.get(promptKey);
+  }
+  if (!promptData) {
+    throw new Error(
+      `Prompt '${promptKey}' (from A/B test '${abTestKey}') not found.`
+    );
+  }
+  const targetVersion = promptVersion ?? promptData.current;
+  const content = promptData.versions.get(targetVersion);
+  if (!content) {
+    throw new Error(
+      `Prompt '${promptKey}' version ${targetVersion} not found.`
+    );
+  }
+  const system = replaceVariables(content.systemPrompt, variables);
+  const user = replaceVariables(content.userTemplate, variables);
+  setPromptContext({
+    promptKey,
+    promptVersion: targetVersion,
+    abTestKey,
+    variantIndex: selectedIndex
+  });
+  log(
+    `\u2705 Got prompt from A/B: ${promptKey} v${targetVersion} (variant ${selectedIndex})`
+  );
+  return {
+    key: promptKey,
+    version: targetVersion,
+    system,
+    user,
+    abTestKey,
+    variantIndex: selectedIndex
+  };
+}
+function clearPromptContext() {
+  promptContext = null;
+}
+var import_crypto, apiKey, baseUrl, initialized, syncInterval, debugMode, promptCache, promptABCache, promptContext, SYNC_TIMEOUT;
+var init_prompts = __esm({
+  "src/prompts.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    apiKey = null;
+    baseUrl = "https://spans.fallom.com";
+    initialized = false;
+    syncInterval = null;
+    debugMode = false;
+    promptCache = /* @__PURE__ */ new Map();
+    promptABCache = /* @__PURE__ */ new Map();
+    promptContext = null;
+    SYNC_TIMEOUT = 2e3;
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   default: () => index_default,
-  init: () => init3,
+  init: () => init4,
   models: () => models_exports,
+  prompts: () => prompts_exports,
   trace: () => trace_exports
 });
 module.exports = __toCommonJS(index_exports);
@@ -32,11 +275,14 @@ var trace_exports = {};
 __export(trace_exports, {
   clearSession: () => clearSession,
   getSession: () => getSession,
-  init: () => init,
+  init: () => init2,
   runWithSession: () => runWithSession,
   setSession: () => setSession,
   shutdown: () => shutdown,
-  span: () => span
+  span: () => span,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapGoogleAI: () => wrapGoogleAI,
+  wrapOpenAI: () => wrapOpenAI
 });
 var import_async_hooks = require("async_hooks");
 var import_sdk_node = require("@opentelemetry/sdk-node");
@@ -668,20 +914,29 @@ var Resource = (
 // src/trace.ts
 var sessionStorage = new import_async_hooks.AsyncLocalStorage();
 var fallbackSession = null;
-var apiKey = null;
-var baseUrl = "https://spans.fallom.com";
-var initialized = false;
+var apiKey2 = null;
+var baseUrl2 = "https://spans.fallom.com";
+var initialized2 = false;
 var captureContent = true;
+var debugMode2 = false;
 var sdk = null;
+function log2(...args) {
+  if (debugMode2) console.log("[Fallom]", ...args);
+}
 var fallomSpanProcessor = {
   onStart(span2, _parentContext) {
+    log2("\u{1F4CD} Span started:", span2.name || "unknown");
     const ctx = sessionStorage.getStore() || fallbackSession;
     if (ctx) {
       span2.setAttribute("fallom.config_key", ctx.configKey);
       span2.setAttribute("fallom.session_id", ctx.sessionId);
+      log2("   Added session context:", ctx.configKey, ctx.sessionId);
+    } else {
+      log2("   No session context available");
     }
   },
-  onEnd(_span) {
+  onEnd(span2) {
+    log2("\u2705 Span ended:", span2.name, "duration:", span2.duration);
   },
   shutdown() {
     return Promise.resolve();
@@ -690,55 +945,103 @@ var fallomSpanProcessor = {
     return Promise.resolve();
   }
 };
-function init(options = {}) {
-  if (initialized) return;
-  apiKey = options.apiKey || process.env.FALLOM_API_KEY || null;
-  baseUrl = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
+async function init2(options = {}) {
+  if (initialized2) return;
+  debugMode2 = options.debug ?? false;
+  log2("\u{1F680} Initializing Fallom tracing...");
+  apiKey2 = options.apiKey || process.env.FALLOM_API_KEY || null;
+  baseUrl2 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
   const envCapture = process.env.FALLOM_CAPTURE_CONTENT?.toLowerCase();
   if (envCapture === "false" || envCapture === "0" || envCapture === "no") {
     captureContent = false;
   } else {
     captureContent = options.captureContent ?? true;
   }
-  if (!apiKey) {
+  if (!apiKey2) {
     throw new Error(
       "No API key provided. Set FALLOM_API_KEY environment variable or pass apiKey parameter."
     );
   }
-  initialized = true;
+  initialized2 = true;
+  log2("\u{1F4E1} Exporter URL:", `${baseUrl2}/v1/traces`);
   const exporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({
-    url: `${baseUrl}/v1/traces`,
+    url: `${baseUrl2}/v1/traces`,
     headers: {
-      Authorization: `Bearer ${apiKey}`
+      Authorization: `Bearer ${apiKey2}`
     }
   });
+  const instrumentations = await getInstrumentations();
+  log2("\u{1F527} Loaded instrumentations:", instrumentations.length);
   sdk = new import_sdk_node.NodeSDK({
     resource: new Resource({
       "service.name": "fallom-traced-app"
     }),
     traceExporter: exporter,
-    spanProcessor: fallomSpanProcessor
+    spanProcessor: fallomSpanProcessor,
+    instrumentations
   });
   sdk.start();
-  autoInstrument();
+  log2("\u2705 SDK started");
   process.on("SIGTERM", () => {
     sdk?.shutdown().catch(console.error);
   });
 }
-function autoInstrument() {
+async function getInstrumentations() {
+  const instrumentations = [];
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-openai",
+    "OpenAIInstrumentation"
+  );
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-anthropic",
+    "AnthropicInstrumentation"
+  );
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-cohere",
+    "CohereInstrumentation"
+  );
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-bedrock",
+    "BedrockInstrumentation"
+  );
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-google-generativeai",
+    "GoogleGenerativeAIInstrumentation"
+  );
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-azure",
+    "AzureOpenAIInstrumentation"
+  );
+  await tryAddInstrumentation(
+    instrumentations,
+    "@traceloop/instrumentation-vertexai",
+    "VertexAIInstrumentation"
+  );
+  return instrumentations;
+}
+async function tryAddInstrumentation(instrumentations, pkg, className) {
   try {
-    const traceloopModule = require("@traceloop/node-server-sdk");
-    const Traceloop = traceloopModule.Traceloop || traceloopModule.default?.Traceloop || traceloopModule;
-    if (!Traceloop?.initialize) {
-      return;
+    const mod = await import(pkg);
+    const InstrumentationClass = mod[className] || mod.default?.[className];
+    if (InstrumentationClass) {
+      instrumentations.push(
+        new InstrumentationClass({ traceContent: captureContent })
+      );
+      log2(`   \u2705 Loaded ${pkg}`);
+    } else {
+      log2(
+        `   \u26A0\uFE0F ${pkg} loaded but ${className} not found. Available:`,
+        Object.keys(mod)
+      );
     }
-    Traceloop.initialize({
-      baseUrl,
-      apiKey,
-      disableBatch: true,
-      traceContent: captureContent
-    });
-  } catch {
+  } catch (e) {
+    log2(`   \u274C ${pkg} not installed`);
   }
 }
 function setSession(configKey, sessionId) {
@@ -759,7 +1062,7 @@ function clearSession() {
   fallbackSession = null;
 }
 function span(data, options = {}) {
-  if (!initialized) {
+  if (!initialized2) {
     throw new Error("Fallom not initialized. Call trace.init() first.");
   }
   const ctx = sessionStorage.getStore() || fallbackSession;
@@ -777,10 +1080,10 @@ async function sendSpan(configKey, sessionId, data) {
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    await fetch(`${baseUrl}/spans`, {
+    await fetch(`${baseUrl2}/spans`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${apiKey}`,
+        Authorization: `Bearer ${apiKey2}`,
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
@@ -797,78 +1100,285 @@ async function sendSpan(configKey, sessionId, data) {
 async function shutdown() {
   if (sdk) {
     await sdk.shutdown();
-    initialized = false;
+    initialized2 = false;
+  }
+}
+async function sendTrace(trace) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${baseUrl2}/v1/traces`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey2}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(trace),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    log2("\u{1F4E4} Trace sent:", trace.name, trace.model);
+  } catch {
   }
 }
+function wrapOpenAI(client) {
+  const originalCreate = client.chat.completions.create.bind(
+    client.chat.completions
+  );
+  client.chat.completions.create = async function(...args) {
+    const ctx = sessionStorage.getStore() || fallbackSession;
+    if (!ctx || !initialized2) {
+      return originalCreate(...args);
+    }
+    let promptCtx = null;
+    try {
+      const { getPromptContext: getPromptContext2 } = await Promise.resolve().then(() => (init_prompts(), prompts_exports));
+      promptCtx = getPromptContext2();
+    } catch {
+    }
+    const params = args[0] || {};
+    const startTime = Date.now();
+    try {
+      const response = await originalCreate(...args);
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "chat.completions.create",
+        model: response?.model || params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "OK",
+        prompt_tokens: response?.usage?.prompt_tokens,
+        completion_tokens: response?.usage?.completion_tokens,
+        total_tokens: response?.usage?.total_tokens,
+        input: captureContent ? JSON.stringify(params?.messages) : void 0,
+        output: captureContent ? response?.choices?.[0]?.message?.content : void 0,
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
+      }).catch(() => {
+      });
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "chat.completions.create",
+        model: params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "ERROR",
+        error_message: error?.message,
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
+      }).catch(() => {
+      });
+      throw error;
+    }
+  };
+  return client;
+}
+function wrapAnthropic(client) {
+  const originalCreate = client.messages.create.bind(client.messages);
+  client.messages.create = async function(...args) {
+    const ctx = sessionStorage.getStore() || fallbackSession;
+    if (!ctx || !initialized2) {
+      return originalCreate(...args);
+    }
+    let promptCtx = null;
+    try {
+      const { getPromptContext: getPromptContext2 } = await Promise.resolve().then(() => (init_prompts(), prompts_exports));
+      promptCtx = getPromptContext2();
+    } catch {
+    }
+    const params = args[0] || {};
+    const startTime = Date.now();
+    try {
+      const response = await originalCreate(...args);
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "messages.create",
+        model: response?.model || params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "OK",
+        prompt_tokens: response?.usage?.input_tokens,
+        completion_tokens: response?.usage?.output_tokens,
+        total_tokens: (response?.usage?.input_tokens || 0) + (response?.usage?.output_tokens || 0),
+        input: captureContent ? JSON.stringify(params?.messages) : void 0,
+        output: captureContent ? response?.content?.[0]?.text : void 0,
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
+      }).catch(() => {
+      });
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "messages.create",
+        model: params?.model,
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "ERROR",
+        error_message: error?.message,
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
+      }).catch(() => {
+      });
+      throw error;
+    }
+  };
+  return client;
+}
+function wrapGoogleAI(model) {
+  const originalGenerate = model.generateContent.bind(model);
+  model.generateContent = async function(...args) {
+    const ctx = sessionStorage.getStore() || fallbackSession;
+    if (!ctx || !initialized2) {
+      return originalGenerate(...args);
+    }
+    let promptCtx = null;
+    try {
+      const { getPromptContext: getPromptContext2 } = await Promise.resolve().then(() => (init_prompts(), prompts_exports));
+      promptCtx = getPromptContext2();
+    } catch {
+    }
+    const startTime = Date.now();
+    try {
+      const response = await originalGenerate(...args);
+      const endTime = Date.now();
+      const result = response?.response;
+      const usage = result?.usageMetadata;
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "generateContent",
+        model: model?.model || "gemini",
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "OK",
+        prompt_tokens: usage?.promptTokenCount,
+        completion_tokens: usage?.candidatesTokenCount,
+        total_tokens: usage?.totalTokenCount,
+        input: captureContent ? JSON.stringify(args[0]) : void 0,
+        output: captureContent ? result?.text?.() : void 0,
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
+      }).catch(() => {
+      });
+      return response;
+    } catch (error) {
+      const endTime = Date.now();
+      sendTrace({
+        config_key: ctx.configKey,
+        session_id: ctx.sessionId,
+        name: "generateContent",
+        model: model?.model || "gemini",
+        start_time: new Date(startTime).toISOString(),
+        end_time: new Date(endTime).toISOString(),
+        duration_ms: endTime - startTime,
+        status: "ERROR",
+        error_message: error?.message,
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
+      }).catch(() => {
+      });
+      throw error;
+    }
+  };
+  return model;
+}
 
 // src/models.ts
 var models_exports = {};
 __export(models_exports, {
-  get: () => get,
-  init: () => init2
+  get: () => get2,
+  init: () => init3
 });
-var import_crypto = require("crypto");
-var apiKey2 = null;
-var baseUrl2 = "https://spans.fallom.com";
-var initialized2 = false;
-var syncInterval = null;
-var debugMode = false;
+var import_crypto2 = require("crypto");
+var apiKey3 = null;
+var baseUrl3 = "https://spans.fallom.com";
+var initialized3 = false;
+var syncInterval2 = null;
+var debugMode3 = false;
 var configCache = /* @__PURE__ */ new Map();
-var SYNC_TIMEOUT = 2e3;
+var SYNC_TIMEOUT2 = 2e3;
 var RECORD_TIMEOUT = 1e3;
-function log(msg) {
-  if (debugMode) {
+function log3(msg) {
+  if (debugMode3) {
     console.log(`[Fallom] ${msg}`);
   }
 }
-function init2(options = {}) {
-  apiKey2 = options.apiKey || process.env.FALLOM_API_KEY || null;
-  baseUrl2 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
-  initialized2 = true;
-  if (!apiKey2) {
+function init3(options = {}) {
+  apiKey3 = options.apiKey || process.env.FALLOM_API_KEY || null;
+  baseUrl3 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
+  initialized3 = true;
+  if (!apiKey3) {
     return;
   }
   fetchConfigs().catch(() => {
   });
-  if (!syncInterval) {
-    syncInterval = setInterval(() => {
+  if (!syncInterval2) {
+    syncInterval2 = setInterval(() => {
       fetchConfigs().catch(() => {
       });
     }, 3e4);
-    syncInterval.unref();
+    syncInterval2.unref();
   }
 }
-function ensureInit() {
-  if (!initialized2) {
+function ensureInit2() {
+  if (!initialized3) {
     try {
-      init2();
+      init3();
     } catch {
     }
   }
 }
-async function fetchConfigs(timeout = SYNC_TIMEOUT) {
-  if (!apiKey2) {
-    log("_fetchConfigs: No API key, skipping");
+async function fetchConfigs(timeout = SYNC_TIMEOUT2) {
+  if (!apiKey3) {
+    log3("_fetchConfigs: No API key, skipping");
     return;
   }
   try {
-    log(`Fetching configs from ${baseUrl2}/configs`);
+    log3(`Fetching configs from ${baseUrl3}/configs`);
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const resp = await fetch(`${baseUrl2}/configs`, {
-      headers: { Authorization: `Bearer ${apiKey2}` },
+    const resp = await fetch(`${baseUrl3}/configs`, {
+      headers: { Authorization: `Bearer ${apiKey3}` },
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    log(`Response status: ${resp.status}`);
+    log3(`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)}`);
+      log3(`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)}`);
+        log3(`Config '${key}' v${version}: ${JSON.stringify(c.variants)}`);
         if (!configCache.has(key)) {
           configCache.set(key, { versions: /* @__PURE__ */ new Map(), latest: null });
         }
@@ -877,21 +1387,21 @@ async function fetchConfigs(timeout = SYNC_TIMEOUT) {
         cached.latest = version;
       }
     } else {
-      log(`Fetch failed: ${resp.statusText}`);
+      log3(`Fetch failed: ${resp.statusText}`);
     }
   } catch (e) {
-    log(`Fetch exception: ${e}`);
+    log3(`Fetch exception: ${e}`);
   }
 }
-async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT) {
-  if (!apiKey2) return null;
+async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT2) {
+  if (!apiKey3) return null;
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
     const resp = await fetch(
-      `${baseUrl2}/configs/${configKey}/version/${version}`,
+      `${baseUrl3}/configs/${configKey}/version/${version}`,
       {
-        headers: { Authorization: `Bearer ${apiKey2}` },
+        headers: { Authorization: `Bearer ${apiKey3}` },
         signal: controller.signal
       }
     );
@@ -908,22 +1418,22 @@ async function fetchSpecificVersion(configKey, version, timeout = SYNC_TIMEOUT)
   }
   return null;
 }
-async function get(configKey, sessionId, options = {}) {
+async function get2(configKey, sessionId, options = {}) {
   const { version, fallback, debug = false } = options;
-  debugMode = debug;
-  ensureInit();
-  log(`get() called: configKey=${configKey}, sessionId=${sessionId}, fallback=${fallback}`);
+  debugMode3 = debug;
+  ensureInit2();
+  log3(`get() called: configKey=${configKey}, sessionId=${sessionId}, fallback=${fallback}`);
   try {
     let configData = configCache.get(configKey);
-    log(`Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`);
+    log3(`Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`);
     if (!configData) {
-      log("Not in cache, fetching...");
-      await fetchConfigs(SYNC_TIMEOUT);
+      log3("Not in cache, fetching...");
+      await fetchConfigs(SYNC_TIMEOUT2);
       configData = configCache.get(configKey);
-      log(`After fetch, cache lookup: ${configData ? "found" : "still not found"}`);
+      log3(`After fetch, cache lookup: ${configData ? "found" : "still not found"}`);
     }
     if (!configData) {
-      log(`Config not found, using fallback: ${fallback}`);
+      log3(`Config not found, using fallback: ${fallback}`);
       if (fallback) {
         console.warn(`[Fallom WARNING] Config '${configKey}' not found, using fallback model: ${fallback}`);
         return returnWithTrace(configKey, sessionId, fallback, 0);
@@ -937,7 +1447,7 @@ async function get(configKey, sessionId, options = {}) {
     if (version !== void 0) {
       config = configData.versions.get(version);
       if (!config) {
-        config = await fetchSpecificVersion(configKey, version, SYNC_TIMEOUT) || void 0;
+        config = await fetchSpecificVersion(configKey, version, SYNC_TIMEOUT2) || void 0;
       }
       if (!config) {
         if (fallback) {
@@ -961,22 +1471,22 @@ async function get(configKey, sessionId, options = {}) {
     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 hashBytes = (0, import_crypto.createHash)("md5").update(sessionId).digest();
+    log3(`Config found! Version: ${configVersion}, Variants: ${JSON.stringify(variants)}`);
+    const hashBytes = (0, import_crypto2.createHash)("md5").update(sessionId).digest();
     const hashVal = hashBytes.readUInt32BE(0) % 1e6;
-    log(`Session hash: ${hashVal} (out of 1,000,000)`);
+    log3(`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}`);
+      log3(`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: ${assignedModel}`);
+    log3(`\u2705 Assigned model: ${assignedModel}`);
     return returnWithTrace(configKey, sessionId, assignedModel, configVersion);
   } catch (e) {
     if (e instanceof Error && e.message.includes("not found")) {
@@ -1001,14 +1511,14 @@ function returnWithTrace(configKey, sessionId, model, version) {
   return model;
 }
 async function recordSession(configKey, version, sessionId, model) {
-  if (!apiKey2) return;
+  if (!apiKey3) return;
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), RECORD_TIMEOUT);
-    await fetch(`${baseUrl2}/sessions`, {
+    await fetch(`${baseUrl3}/sessions`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${apiKey2}`,
+        Authorization: `Bearer ${apiKey3}`,
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
@@ -1024,29 +1534,41 @@ async function recordSession(configKey, version, sessionId, model) {
   }
 }
 
+// src/index.ts
+init_prompts();
+
 // src/init.ts
-function init3(options = {}) {
-  const baseUrl3 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
-  init({
+init_prompts();
+async function init4(options = {}) {
+  const baseUrl4 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
+  await init2({
     apiKey: options.apiKey,
-    baseUrl: baseUrl3,
-    captureContent: options.captureContent
+    baseUrl: baseUrl4,
+    captureContent: options.captureContent,
+    debug: options.debug
   });
-  init2({
+  init3({
+    apiKey: options.apiKey,
+    baseUrl: baseUrl4
+  });
+  init({
     apiKey: options.apiKey,
-    baseUrl: baseUrl3
+    baseUrl: baseUrl4
   });
 }
 
 // src/index.ts
+init_prompts();
 var index_default = {
-  init: init3,
+  init: init4,
   trace: trace_exports,
-  models: models_exports
+  models: models_exports,
+  prompts: prompts_exports
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   init,
   models,
+  prompts,
   trace
 });