@fallom/trace 0.1.3 → 0.1.5

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,7 +275,7 @@ var trace_exports = {};
 __export(trace_exports, {
   clearSession: () => clearSession,
   getSession: () => getSession,
-  init: () => init,
+  init: () => init2,
   runWithSession: () => runWithSession,
   setSession: () => setSession,
   shutdown: () => shutdown,
@@ -671,29 +914,37 @@ 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 debugMode = false;
+var debugMode2 = false;
 var sdk = null;
-function log(...args) {
-  if (debugMode) console.log("[Fallom]", ...args);
+function log2(...args) {
+  if (debugMode2) console.log("[Fallom]", ...args);
 }
 var fallomSpanProcessor = {
   onStart(span2, _parentContext) {
-    log("\u{1F4CD} Span started:", span2.name || "unknown");
+    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);
-      log("   Added session context:", ctx.configKey, ctx.sessionId);
+      if (ctx.customerId) {
+        span2.setAttribute("fallom.customer_id", ctx.customerId);
+      }
+      log2(
+        "   Added session context:",
+        ctx.configKey,
+        ctx.sessionId,
+        ctx.customerId
+      );
     } else {
-      log("   No session context available");
+      log2("   No session context available");
     }
   },
   onEnd(span2) {
-    log("\u2705 Span ended:", span2.name, "duration:", span2.duration);
+    log2("\u2705 Span ended:", span2.name, "duration:", span2.duration);
   },
   shutdown() {
     return Promise.resolve();
@@ -702,33 +953,33 @@ var fallomSpanProcessor = {
     return Promise.resolve();
   }
 };
-async function init(options = {}) {
-  if (initialized) return;
-  debugMode = options.debug ?? false;
-  log("\u{1F680} Initializing Fallom tracing...");
-  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;
-  log("\u{1F4E1} Exporter URL:", `${baseUrl}/v1/traces`);
+  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();
-  log("\u{1F527} Loaded instrumentations:", instrumentations.length);
+  log2("\u{1F527} Loaded instrumentations:", instrumentations.length);
   sdk = new import_sdk_node.NodeSDK({
     resource: new Resource({
       "service.name": "fallom-traced-app"
@@ -738,20 +989,48 @@ async function init(options = {}) {
     instrumentations
   });
   sdk.start();
-  log("\u2705 SDK started");
+  log2("\u2705 SDK started");
   process.on("SIGTERM", () => {
     sdk?.shutdown().catch(console.error);
   });
 }
 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");
+  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) {
@@ -759,25 +1038,37 @@ async function tryAddInstrumentation(instrumentations, pkg, className) {
     const mod = await import(pkg);
     const InstrumentationClass = mod[className] || mod.default?.[className];
     if (InstrumentationClass) {
-      instrumentations.push(new InstrumentationClass({ traceContent: captureContent }));
-      log(`   \u2705 Loaded ${pkg}`);
+      instrumentations.push(
+        new InstrumentationClass({ traceContent: captureContent })
+      );
+      log2(`   \u2705 Loaded ${pkg}`);
     } else {
-      log(`   \u26A0\uFE0F ${pkg} loaded but ${className} not found. Available:`, Object.keys(mod));
+      log2(
+        `   \u26A0\uFE0F ${pkg} loaded but ${className} not found. Available:`,
+        Object.keys(mod)
+      );
     }
   } catch (e) {
-    log(`   \u274C ${pkg} not installed`);
+    log2(`   \u274C ${pkg} not installed`);
   }
 }
-function setSession(configKey, sessionId) {
+function setSession(configKey, sessionId, customerId) {
   const store = sessionStorage.getStore();
   if (store) {
     store.configKey = configKey;
     store.sessionId = sessionId;
+    store.customerId = customerId;
   }
-  fallbackSession = { configKey, sessionId };
+  fallbackSession = { configKey, sessionId, customerId };
 }
-function runWithSession(configKey, sessionId, fn) {
-  return sessionStorage.run({ configKey, sessionId }, fn);
+function runWithSession(configKey, sessionId, customerIdOrFn, fn) {
+  if (typeof customerIdOrFn === "function") {
+    return sessionStorage.run({ configKey, sessionId }, customerIdOrFn);
+  }
+  return sessionStorage.run(
+    { configKey, sessionId, customerId: customerIdOrFn },
+    fn
+  );
 }
 function getSession() {
   return sessionStorage.getStore() || fallbackSession || void 0;
@@ -786,7 +1077,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;
@@ -804,10 +1095,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({
@@ -824,34 +1115,42 @@ 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(`${baseUrl}/v1/traces`, {
+    await fetch(`${baseUrl2}/v1/traces`, {
       method: "POST",
       headers: {
-        Authorization: `Bearer ${apiKey}`,
+        Authorization: `Bearer ${apiKey2}`,
         "Content-Type": "application/json"
       },
       body: JSON.stringify(trace),
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    log("\u{1F4E4} Trace sent:", trace.name, trace.model);
+    log2("\u{1F4E4} Trace sent:", trace.name, trace.model);
   } catch {
   }
 }
 function wrapOpenAI(client) {
-  const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+  const originalCreate = client.chat.completions.create.bind(
+    client.chat.completions
+  );
   client.chat.completions.create = async function(...args) {
     const ctx = sessionStorage.getStore() || fallbackSession;
-    if (!ctx || !initialized) {
+    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 {
@@ -860,6 +1159,7 @@ function wrapOpenAI(client) {
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
+        customer_id: ctx.customerId,
         name: "chat.completions.create",
         model: response?.model || params?.model,
         start_time: new Date(startTime).toISOString(),
@@ -870,7 +1170,11 @@ function wrapOpenAI(client) {
         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
+        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;
@@ -879,13 +1183,18 @@ function wrapOpenAI(client) {
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
+        customer_id: ctx.customerId,
         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
+        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;
@@ -897,9 +1206,15 @@ function wrapAnthropic(client) {
   const originalCreate = client.messages.create.bind(client.messages);
   client.messages.create = async function(...args) {
     const ctx = sessionStorage.getStore() || fallbackSession;
-    if (!ctx || !initialized) {
+    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 {
@@ -908,6 +1223,7 @@ function wrapAnthropic(client) {
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
+        customer_id: ctx.customerId,
         name: "messages.create",
         model: response?.model || params?.model,
         start_time: new Date(startTime).toISOString(),
@@ -918,7 +1234,11 @@ function wrapAnthropic(client) {
         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
+        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;
@@ -927,13 +1247,18 @@ function wrapAnthropic(client) {
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
+        customer_id: ctx.customerId,
         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
+        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;
@@ -945,9 +1270,15 @@ function wrapGoogleAI(model) {
   const originalGenerate = model.generateContent.bind(model);
   model.generateContent = async function(...args) {
     const ctx = sessionStorage.getStore() || fallbackSession;
-    if (!ctx || !initialized) {
+    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);
@@ -957,6 +1288,7 @@ function wrapGoogleAI(model) {
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
+        customer_id: ctx.customerId,
         name: "generateContent",
         model: model?.model || "gemini",
         start_time: new Date(startTime).toISOString(),
@@ -967,7 +1299,11 @@ function wrapGoogleAI(model) {
         completion_tokens: usage?.candidatesTokenCount,
         total_tokens: usage?.totalTokenCount,
         input: captureContent ? JSON.stringify(args[0]) : void 0,
-        output: captureContent ? result?.text?.() : 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;
@@ -976,13 +1312,18 @@ function wrapGoogleAI(model) {
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
+        customer_id: ctx.customerId,
         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
+        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;
@@ -994,71 +1335,71 @@ function wrapGoogleAI(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 debugMode2 = 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 log2(msg) {
-  if (debugMode2) {
+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) {
-    log2("_fetchConfigs: No API key, skipping");
+async function fetchConfigs(timeout = SYNC_TIMEOUT2) {
+  if (!apiKey3) {
+    log3("_fetchConfigs: No API key, skipping");
     return;
   }
   try {
-    log2(`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);
-    log2(`Response status: ${resp.status}`);
+    log3(`Response status: ${resp.status}`);
     if (resp.ok) {
       const data = await resp.json();
       const configs = data.configs || [];
-      log2(`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;
-        log2(`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 });
         }
@@ -1067,21 +1408,21 @@ async function fetchConfigs(timeout = SYNC_TIMEOUT) {
         cached.latest = version;
       }
     } else {
-      log2(`Fetch failed: ${resp.statusText}`);
+      log3(`Fetch failed: ${resp.statusText}`);
     }
   } catch (e) {
-    log2(`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
       }
     );
@@ -1098,22 +1439,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;
-  debugMode2 = debug;
-  ensureInit();
-  log2(`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);
-    log2(`Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`);
+    log3(`Cache lookup for '${configKey}': ${configData ? "found" : "not found"}`);
     if (!configData) {
-      log2("Not in cache, fetching...");
-      await fetchConfigs(SYNC_TIMEOUT);
+      log3("Not in cache, fetching...");
+      await fetchConfigs(SYNC_TIMEOUT2);
       configData = configCache.get(configKey);
-      log2(`After fetch, cache lookup: ${configData ? "found" : "still not found"}`);
+      log3(`After fetch, cache lookup: ${configData ? "found" : "still not found"}`);
     }
     if (!configData) {
-      log2(`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);
@@ -1127,7 +1468,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) {
@@ -1151,22 +1492,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);
-    log2(`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;
-    log2(`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;
-      log2(`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;
       }
     }
-    log2(`\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")) {
@@ -1191,14 +1532,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({
@@ -1214,30 +1555,41 @@ async function recordSession(configKey, version, sessionId, model) {
   }
 }
 
+// src/index.ts
+init_prompts();
+
 // src/init.ts
-async function init3(options = {}) {
-  const baseUrl3 = options.baseUrl || process.env.FALLOM_BASE_URL || "https://spans.fallom.com";
-  await 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,
+    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
 });