@fallom/trace 0.2.6 → 0.2.13

package/dist/index.mjs

@@ -1,14 +1,33 @@
 import {
-  __export,
   init,
   models_exports
-} from "./chunk-KFD5AQ7V.mjs";
+} from "./chunk-CCZLSKZ7.mjs";
+import {
+  AVAILABLE_METRICS,
+  DEFAULT_JUDGE_MODEL,
+  METRIC_PROMPTS,
+  compareModels,
+  createCustomModel,
+  createModelFromCallable,
+  createOpenAIModel,
+  customMetric,
+  datasetFromFallom,
+  datasetFromTraces,
+  evaluate,
+  getMetricName,
+  init as init2,
+  isCustomMetric,
+  uploadResultsPublic
+} from "./chunk-2NGJF2JZ.mjs";
+import {
+  __export
+} from "./chunk-7P6ASYW6.mjs";
 
 // src/trace.ts
 var trace_exports = {};
 __export(trace_exports, {
   FallomSession: () => FallomSession,
-  init: () => init2,
+  init: () => init3,
   session: () => session,
   shutdown: () => shutdown
 });
@@ -714,7 +733,7 @@ async function tryAddInstrumentation(instrumentations, pkg, className) {
     log(`   \u274C ${pkg} not installed`);
   }
 }
-async function init2(options = {}) {
+async function init3(options = {}) {
   if (initialized) return;
   debugMode = options.debug ?? false;
   log("\u{1F680} Initializing Fallom tracing...");
@@ -796,6 +815,246 @@ function generateHexId(length) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
+// src/prompts.ts
+var prompts_exports = {};
+__export(prompts_exports, {
+  clearPromptContext: () => clearPromptContext,
+  get: () => get,
+  getAB: () => getAB,
+  getPromptContext: () => getPromptContext,
+  init: () => init4
+});
+import { createHash } from "crypto";
+var apiKey2 = null;
+var baseUrl2 = "https://prompts.fallom.com";
+var initialized2 = false;
+var syncInterval = null;
+var debugMode2 = false;
+var promptCache = /* @__PURE__ */ new Map();
+var promptABCache = /* @__PURE__ */ new Map();
+var promptContext = null;
+var SYNC_TIMEOUT = 2e3;
+function log2(msg) {
+  if (debugMode2) {
+    console.log(`[Fallom Prompts] ${msg}`);
+  }
+}
+function init4(options = {}) {
+  apiKey2 = options.apiKey || process.env.FALLOM_API_KEY || null;
+  baseUrl2 = options.baseUrl || process.env.FALLOM_PROMPTS_URL || process.env.FALLOM_BASE_URL || "https://prompts.fallom.com";
+  initialized2 = true;
+  if (!apiKey2) {
+    return;
+  }
+  fetchAll().catch(() => {
+  });
+  if (!syncInterval) {
+    syncInterval = setInterval(() => {
+      fetchAll().catch(() => {
+      });
+    }, 3e4);
+    syncInterval.unref();
+  }
+}
+function ensureInit() {
+  if (!initialized2) {
+    try {
+      init4();
+    } catch {
+    }
+  }
+}
+async function fetchAll() {
+  await Promise.all([fetchPrompts(), fetchPromptABTests()]);
+}
+async function fetchPrompts(timeout = SYNC_TIMEOUT) {
+  if (!apiKey2) return;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const resp = await fetch(`${baseUrl2}/prompts`, {
+      headers: { Authorization: `Bearer ${apiKey2}` },
+      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 (!apiKey2) return;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const resp = await fetch(`${baseUrl2}/prompt-ab-tests`, {
+      headers: { Authorization: `Bearer ${apiKey2}` },
+      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;
+  debugMode2 = debug;
+  ensureInit();
+  log2(`get() called: promptKey=${promptKey}`);
+  let promptData = promptCache.get(promptKey);
+  if (!promptData) {
+    log2("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
+  });
+  log2(`\u2705 Got prompt: ${promptKey} v${targetVersion}`);
+  return {
+    key: promptKey,
+    version: targetVersion,
+    system,
+    user
+  };
+}
+async function getAB(abTestKey, sessionId, options = {}) {
+  const { variables, debug = false } = options;
+  debugMode2 = debug;
+  ensureInit();
+  log2(`getAB() called: abTestKey=${abTestKey}, sessionId=${sessionId}`);
+  let abData = promptABCache.get(abTestKey);
+  if (!abData) {
+    log2("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;
+  log2(`A/B test '${abTestKey}' has ${variants?.length ?? 0} variants`);
+  log2(`Version data: ${JSON.stringify(versionData, null, 2)}`);
+  if (!variants || variants.length === 0) {
+    throw new Error(
+      `Prompt A/B test '${abTestKey}' has no variants configured.`
+    );
+  }
+  const hashBytes = 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
+  });
+  log2(
+    `\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;
+}
+
 // src/trace/wrappers/openai.ts
 function wrapOpenAI(client, sessionCtx) {
   const originalCreate = client.chat.completions.create.bind(
@@ -823,18 +1082,43 @@ function wrapOpenAI(client, sessionCtx) {
       if (captureContent2) {
         attributes["fallom.raw.request"] = JSON.stringify({
           messages: params?.messages,
-          model: params?.model
+          model: params?.model,
+          tools: params?.tools,
+          tool_choice: params?.tool_choice,
+          functions: params?.functions,
+          function_call: params?.function_call
         });
+        const choice = response?.choices?.[0];
         attributes["fallom.raw.response"] = JSON.stringify({
-          text: response?.choices?.[0]?.message?.content,
-          finishReason: response?.choices?.[0]?.finish_reason,
+          text: choice?.message?.content,
+          finishReason: choice?.finish_reason,
           responseId: response?.id,
-          model: response?.model
+          model: response?.model,
+          // Tool calls - send everything!
+          toolCalls: choice?.message?.tool_calls,
+          functionCall: choice?.message?.function_call
         });
       }
       if (response?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(response.usage);
       }
+      const waterfallTimings = {
+        requestStart: 0,
+        requestEnd: endTime - startTime,
+        responseEnd: endTime - startTime,
+        totalDurationMs: endTime - startTime,
+        // OpenAI tool calls (if present)
+        toolCalls: response?.choices?.[0]?.message?.tool_calls?.map(
+          (tc, idx) => ({
+            id: tc.id,
+            name: tc.function?.name,
+            callTime: 0
+            // All tool calls happen at once in non-streaming
+          })
+        )
+      };
+      attributes["fallom.raw.timings"] = JSON.stringify(waterfallTimings);
+      const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
@@ -849,7 +1133,12 @@ function wrapOpenAI(client, sessionCtx) {
         end_time: new Date(endTime).toISOString(),
         duration_ms: endTime - startTime,
         status: "OK",
-        attributes
+        attributes,
+        // Prompt context (if prompts.get() or prompts.getAB() was called)
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
       }).catch(() => {
       });
       return response;
@@ -908,18 +1197,48 @@ function wrapAnthropic(client, sessionCtx) {
         attributes["fallom.raw.request"] = JSON.stringify({
           messages: params?.messages,
           system: params?.system,
-          model: params?.model
+          model: params?.model,
+          tools: params?.tools,
+          tool_choice: params?.tool_choice
         });
+        const contentBlocks = response?.content || [];
+        const textBlocks = contentBlocks.filter((b) => b.type === "text");
+        const toolUseBlocks2 = contentBlocks.filter(
+          (b) => b.type === "tool_use"
+        );
         attributes["fallom.raw.response"] = JSON.stringify({
-          text: response?.content?.[0]?.text,
+          text: textBlocks.map((b) => b.text).join(""),
           finishReason: response?.stop_reason,
           responseId: response?.id,
-          model: response?.model
+          model: response?.model,
+          // Tool calls - Anthropic uses tool_use content blocks
+          toolCalls: toolUseBlocks2.map((b) => ({
+            id: b.id,
+            name: b.name,
+            arguments: b.input
+          })),
+          // Also send raw content for full fidelity
+          content: contentBlocks
         });
       }
       if (response?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(response.usage);
       }
+      const waterfallTimings = {
+        requestStart: 0,
+        requestEnd: endTime - startTime,
+        responseEnd: endTime - startTime,
+        totalDurationMs: endTime - startTime,
+        // Anthropic tool calls (if present)
+        toolCalls: toolUseBlocks.map((b) => ({
+          id: b.id,
+          name: b.name,
+          callTime: 0
+          // All tool calls happen at once in non-streaming
+        }))
+      };
+      attributes["fallom.raw.timings"] = JSON.stringify(waterfallTimings);
+      const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
@@ -934,7 +1253,12 @@ function wrapAnthropic(client, sessionCtx) {
         end_time: new Date(endTime).toISOString(),
         duration_ms: endTime - startTime,
         status: "OK",
-        attributes
+        attributes,
+        // Prompt context (if prompts.get() or prompts.getAB() was called)
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
       }).catch(() => {
       });
       return response;
@@ -992,14 +1316,44 @@ function wrapGoogleAI(model, sessionCtx) {
       };
       if (captureContent2) {
         attributes["fallom.raw.request"] = JSON.stringify(request);
+        const candidates = result?.candidates || [];
+        const functionCalls2 = [];
+        for (const candidate of candidates) {
+          const parts = candidate?.content?.parts || [];
+          for (const part of parts) {
+            if (part.functionCall) {
+              functionCalls2.push({
+                name: part.functionCall.name,
+                arguments: part.functionCall.args
+              });
+            }
+          }
+        }
         attributes["fallom.raw.response"] = JSON.stringify({
           text: result?.text?.(),
-          candidates: result?.candidates
+          candidates: result?.candidates,
+          finishReason: candidates[0]?.finishReason,
+          // Tool/function calls - Google uses functionCall in parts
+          toolCalls: functionCalls2.length > 0 ? functionCalls2 : void 0
         });
       }
       if (result?.usageMetadata) {
         attributes["fallom.raw.usage"] = JSON.stringify(result.usageMetadata);
       }
+      const waterfallTimings = {
+        requestStart: 0,
+        requestEnd: endTime - startTime,
+        responseEnd: endTime - startTime,
+        totalDurationMs: endTime - startTime,
+        // Google AI function calls (if present)
+        toolCalls: functionCalls.map((fc) => ({
+          name: fc.name,
+          callTime: 0
+          // All tool calls happen at once in non-streaming
+        }))
+      };
+      attributes["fallom.raw.timings"] = JSON.stringify(waterfallTimings);
+      const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
@@ -1014,7 +1368,12 @@ function wrapGoogleAI(model, sessionCtx) {
         end_time: new Date(endTime).toISOString(),
         duration_ms: endTime - startTime,
         status: "OK",
-        attributes
+        attributes,
+        // Prompt context (if prompts.get() or prompts.getAB() was called)
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
       }).catch(() => {
       });
       return response;
@@ -1061,11 +1420,57 @@ function createGenerateTextWrapper(aiModule, sessionCtx, debug = false) {
     const params = args[0] || {};
     const startTime = Date.now();
     const captureContent2 = shouldCaptureContent();
+    const toolTimings = /* @__PURE__ */ new Map();
+    let wrappedParams = params;
+    if (params.tools && typeof params.tools === "object") {
+      const wrappedTools = {};
+      for (const [toolName, tool] of Object.entries(
+        params.tools
+      )) {
+        if (tool && typeof tool.execute === "function") {
+          const originalExecute = tool.execute;
+          wrappedTools[toolName] = {
+            ...tool,
+            execute: async (...executeArgs) => {
+              const toolStartTime = Date.now();
+              const toolCallId = `${toolName}-${toolStartTime}`;
+              try {
+                const result = await originalExecute(...executeArgs);
+                const toolEndTime = Date.now();
+                toolTimings.set(toolCallId, {
+                  name: toolName,
+                  startTime: toolStartTime - startTime,
+                  // Relative to request start
+                  endTime: toolEndTime - startTime,
+                  duration: toolEndTime - toolStartTime
+                });
+                return result;
+              } catch (error) {
+                const toolEndTime = Date.now();
+                toolTimings.set(toolCallId, {
+                  name: toolName,
+                  startTime: toolStartTime - startTime,
+                  endTime: toolEndTime - startTime,
+                  duration: toolEndTime - toolStartTime
+                });
+                throw error;
+              }
+            }
+          };
+        } else {
+          wrappedTools[toolName] = tool;
+        }
+      }
+      wrappedParams = { ...params, tools: wrappedTools };
+    }
     try {
-      const result = await aiModule.generateText(...args);
+      const result = await aiModule.generateText(wrappedParams);
       const endTime = Date.now();
       if (debug || isDebugMode()) {
-        console.log("\n\u{1F50D} [Fallom Debug] generateText raw result:", JSON.stringify(result, null, 2));
+        console.log(
+          "\n\u{1F50D} [Fallom Debug] generateText raw result:",
+          JSON.stringify(result, null, 2)
+        );
       }
       const modelId = result?.response?.modelId || params?.model?.modelId || String(params?.model || "unknown");
       const attributes = {
@@ -1077,21 +1482,153 @@ function createGenerateTextWrapper(aiModule, sessionCtx, debug = false) {
           prompt: params?.prompt,
           messages: params?.messages,
           system: params?.system,
-          model: modelId
+          model: modelId,
+          tools: params?.tools ? Object.keys(params.tools) : void 0,
+          maxSteps: params?.maxSteps
+        });
+        const mapToolCall = (tc) => ({
+          toolCallId: tc?.toolCallId,
+          toolName: tc?.toolName,
+          args: tc?.args,
+          // The actual arguments passed to the tool!
+          type: tc?.type
+        });
+        const mapToolResult = (tr) => ({
+          toolCallId: tr?.toolCallId,
+          toolName: tr?.toolName,
+          result: tr?.result,
+          // The actual result from the tool!
+          type: tr?.type
         });
         attributes["fallom.raw.response"] = JSON.stringify({
           text: result?.text,
           finishReason: result?.finishReason,
           responseId: result?.response?.id,
-          modelId: result?.response?.modelId
+          modelId: result?.response?.modelId,
+          // Tool calls with FULL data (id, name, args)
+          toolCalls: result?.toolCalls?.map(mapToolCall),
+          // Tool results with FULL data (id, name, result)
+          toolResults: result?.toolResults?.map(mapToolResult),
+          // Multi-step agent data with FULL tool info including timestamps
+          steps: result?.steps?.map((step) => ({
+            stepType: step?.stepType,
+            text: step?.text,
+            finishReason: step?.finishReason,
+            toolCalls: step?.toolCalls?.map(mapToolCall),
+            toolResults: step?.toolResults?.map(mapToolResult),
+            usage: step?.usage,
+            // Step-level timing from Vercel AI SDK
+            timestamp: step?.response?.timestamp,
+            responseId: step?.response?.id
+          })),
+          // Response messages (includes tool call/result messages)
+          responseMessages: result?.responseMessages
         });
       }
       if (result?.usage) {
         attributes["fallom.raw.usage"] = JSON.stringify(result.usage);
       }
       if (result?.experimental_providerMetadata) {
-        attributes["fallom.raw.providerMetadata"] = JSON.stringify(result.experimental_providerMetadata);
+        attributes["fallom.raw.providerMetadata"] = JSON.stringify(
+          result.experimental_providerMetadata
+        );
       }
+      const totalDurationMs = endTime - startTime;
+      const sortedToolTimings = Array.from(toolTimings.values()).sort(
+        (a, b) => a.startTime - b.startTime
+      );
+      const waterfallTimings = {
+        requestStart: 0,
+        responseEnd: totalDurationMs,
+        totalDurationMs,
+        phases: [],
+        // Include actual tool timings for verification
+        toolTimings: sortedToolTimings
+      };
+      if (sortedToolTimings.length > 0) {
+        const firstToolStart = Math.min(
+          ...sortedToolTimings.map((t) => t.startTime)
+        );
+        const lastToolEnd = Math.max(
+          ...sortedToolTimings.map((t) => t.endTime)
+        );
+        if (firstToolStart > 10) {
+          waterfallTimings.phases.push({
+            type: "llm",
+            label: "LLM Call 1 (decides tools)",
+            startMs: 0,
+            endMs: firstToolStart,
+            durationMs: firstToolStart,
+            accurate: true
+          });
+        }
+        sortedToolTimings.forEach((toolTiming) => {
+          waterfallTimings.phases.push({
+            type: "tool",
+            label: `${toolTiming.name}()`,
+            startMs: toolTiming.startTime,
+            endMs: toolTiming.endTime,
+            durationMs: toolTiming.duration,
+            accurate: true
+            // This is REAL measured timing!
+          });
+        });
+        const finalResponseDuration = totalDurationMs - lastToolEnd;
+        if (finalResponseDuration > 10) {
+          waterfallTimings.phases.push({
+            type: "response",
+            label: "LLM Call 2 \u2192 Final Response",
+            startMs: lastToolEnd,
+            endMs: totalDurationMs,
+            durationMs: finalResponseDuration,
+            accurate: true
+          });
+        }
+      } else if (result?.steps && result.steps.length > 0) {
+        const steps = result.steps;
+        const stepDuration = Math.round(totalDurationMs / steps.length);
+        steps.forEach((step, idx) => {
+          const hasTools = step?.toolCalls && step.toolCalls.length > 0;
+          const isFinalStep = step?.finishReason === "stop";
+          const stepStart = idx * stepDuration;
+          const stepEnd = Math.min((idx + 1) * stepDuration, totalDurationMs);
+          if (hasTools) {
+            waterfallTimings.phases.push({
+              type: "llm",
+              label: `Step ${idx + 1}: LLM + Tools`,
+              startMs: stepStart,
+              endMs: stepEnd,
+              durationMs: stepEnd - stepStart,
+              accurate: false,
+              note: "Tool timing not captured - combined step"
+            });
+          } else if (isFinalStep) {
+            waterfallTimings.phases.push({
+              type: "response",
+              label: `Step ${idx + 1}: Final Response`,
+              startMs: stepStart,
+              endMs: stepEnd,
+              durationMs: stepEnd - stepStart,
+              accurate: true
+            });
+          }
+        });
+      }
+      if (result?.steps) {
+        waterfallTimings.steps = result.steps.map((step, idx) => ({
+          stepIndex: idx,
+          stepType: step?.stepType,
+          finishReason: step?.finishReason,
+          timestamp: step?.response?.timestamp,
+          toolCalls: step?.toolCalls?.map((tc) => ({
+            id: tc?.toolCallId,
+            name: tc?.toolName
+          })),
+          usage: step?.usage
+        }));
+      }
+      attributes["fallom.raw.timings"] = JSON.stringify(waterfallTimings);
+      const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
@@ -1106,7 +1643,12 @@ function createGenerateTextWrapper(aiModule, sessionCtx, debug = false) {
         end_time: new Date(endTime).toISOString(),
         duration_ms: endTime - startTime,
         status: "OK",
-        attributes
+        attributes,
+        // Prompt context (if prompts.get() or prompts.getAB() was called)
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
       }).catch(() => {
       });
       return result;
@@ -1146,7 +1688,7 @@ function createGenerateTextWrapper(aiModule, sessionCtx, debug = false) {
 }
 
 // src/trace/wrappers/vercel-ai/stream-text.ts
-function log2(...args) {
+function log3(...args) {
   if (isDebugMode()) console.log("[Fallom]", ...args);
 }
 function createStreamTextWrapper(aiModule, sessionCtx, debug = false) {
@@ -1155,7 +1697,47 @@ function createStreamTextWrapper(aiModule, sessionCtx, debug = false) {
     const params = args[0] || {};
     const startTime = Date.now();
     const captureContent2 = shouldCaptureContent();
-    const result = await aiModule.streamText(...args);
+    const toolTimings = /* @__PURE__ */ new Map();
+    let wrappedParams = params;
+    if (params.tools && typeof params.tools === "object") {
+      const wrappedTools = {};
+      for (const [toolName, tool] of Object.entries(params.tools)) {
+        if (tool && typeof tool.execute === "function") {
+          const originalExecute = tool.execute;
+          wrappedTools[toolName] = {
+            ...tool,
+            execute: async (...executeArgs) => {
+              const toolStartTime = Date.now();
+              const toolCallId = `${toolName}-${toolStartTime}`;
+              try {
+                const result2 = await originalExecute(...executeArgs);
+                const toolEndTime = Date.now();
+                toolTimings.set(toolCallId, {
+                  name: toolName,
+                  startTime: toolStartTime - startTime,
+                  endTime: toolEndTime - startTime,
+                  duration: toolEndTime - toolStartTime
+                });
+                return result2;
+              } catch (error) {
+                const toolEndTime = Date.now();
+                toolTimings.set(toolCallId, {
+                  name: toolName,
+                  startTime: toolStartTime - startTime,
+                  endTime: toolEndTime - startTime,
+                  duration: toolEndTime - toolStartTime
+                });
+                throw error;
+              }
+            }
+          };
+        } else {
+          wrappedTools[toolName] = tool;
+        }
+      }
+      wrappedParams = { ...params, tools: wrappedTools };
+    }
+    const result = await aiModule.streamText(wrappedParams);
     if (!isInitialized()) {
       return result;
     }
@@ -1169,72 +1751,213 @@ function createStreamTextWrapper(aiModule, sessionCtx, debug = false) {
       Promise.all([
         result.usage.catch(() => null),
         result.text?.catch(() => null),
-        result.finishReason?.catch(() => null)
-      ]).then(async ([rawUsage, responseText, finishReason]) => {
-        const endTime = Date.now();
-        if (debug || isDebugMode()) {
-          console.log("\n\u{1F50D} [Fallom Debug] streamText raw usage:", JSON.stringify(rawUsage, null, 2));
-          console.log("\u{1F50D} [Fallom Debug] streamText response text:", responseText?.slice(0, 100));
-          console.log("\u{1F50D} [Fallom Debug] streamText finish reason:", finishReason);
-        }
-        let providerMetadata = result?.experimental_providerMetadata;
-        if (providerMetadata && typeof providerMetadata.then === "function") {
-          try {
-            providerMetadata = await providerMetadata;
-          } catch {
-            providerMetadata = void 0;
+        result.finishReason?.catch(() => null),
+        result.toolCalls?.catch(() => null),
+        result.toolResults?.catch(() => null),
+        result.steps?.catch(() => null),
+        result.responseMessages?.catch(() => null)
+      ]).then(
+        async ([
+          rawUsage,
+          responseText,
+          finishReason,
+          toolCalls,
+          toolResults,
+          steps,
+          responseMessages
+        ]) => {
+          const endTime = Date.now();
+          if (debug || isDebugMode()) {
+            console.log(
+              "\n\u{1F50D} [Fallom Debug] streamText raw usage:",
+              JSON.stringify(rawUsage, null, 2)
+            );
+            console.log(
+              "\u{1F50D} [Fallom Debug] streamText response text:",
+              responseText?.slice(0, 100)
+            );
+            console.log(
+              "\u{1F50D} [Fallom Debug] streamText finish reason:",
+              finishReason
+            );
+            console.log(
+              "\u{1F50D} [Fallom Debug] streamText toolCalls:",
+              JSON.stringify(toolCalls, null, 2)
+            );
+            console.log(
+              "\u{1F50D} [Fallom Debug] streamText steps count:",
+              steps?.length
+            );
           }
-        }
-        const attributes = {
-          "fallom.sdk_version": "2",
-          "fallom.method": "streamText",
-          "fallom.is_streaming": true
-        };
-        if (captureContent2) {
-          attributes["fallom.raw.request"] = JSON.stringify({
-            prompt: params?.prompt,
-            messages: params?.messages,
-            system: params?.system,
-            model: modelId
-          });
-          if (responseText || finishReason) {
+          let providerMetadata = result?.experimental_providerMetadata;
+          if (providerMetadata && typeof providerMetadata.then === "function") {
+            try {
+              providerMetadata = await providerMetadata;
+            } catch {
+              providerMetadata = void 0;
+            }
+          }
+          const attributes = {
+            "fallom.sdk_version": "2",
+            "fallom.method": "streamText",
+            "fallom.is_streaming": true
+          };
+          if (captureContent2) {
+            const mapToolCall = (tc) => ({
+              toolCallId: tc?.toolCallId,
+              toolName: tc?.toolName,
+              args: tc?.args,
+              // The actual arguments passed to the tool!
+              type: tc?.type
+            });
+            const mapToolResult = (tr) => ({
+              toolCallId: tr?.toolCallId,
+              toolName: tr?.toolName,
+              result: tr?.result,
+              // The actual result from the tool!
+              type: tr?.type
+            });
+            attributes["fallom.raw.request"] = JSON.stringify({
+              prompt: params?.prompt,
+              messages: params?.messages,
+              system: params?.system,
+              model: modelId,
+              tools: params?.tools ? Object.keys(params.tools) : void 0,
+              maxSteps: params?.maxSteps
+            });
             attributes["fallom.raw.response"] = JSON.stringify({
               text: responseText,
-              finishReason
+              finishReason,
+              // Tool calls with FULL data (id, name, args)
+              toolCalls: toolCalls?.map(mapToolCall),
+              // Tool results with FULL data (id, name, result)
+              toolResults: toolResults?.map(mapToolResult),
+              // Multi-step agent data with FULL tool info including timestamps
+              steps: steps?.map((step) => ({
+                stepType: step?.stepType,
+                text: step?.text,
+                finishReason: step?.finishReason,
+                toolCalls: step?.toolCalls?.map(mapToolCall),
+                toolResults: step?.toolResults?.map(mapToolResult),
+                usage: step?.usage,
+                // Step-level timing from Vercel AI SDK
+                timestamp: step?.response?.timestamp,
+                responseId: step?.response?.id
+              })),
+              // Response messages (includes tool call/result messages)
+              responseMessages
             });
           }
+          if (rawUsage) {
+            attributes["fallom.raw.usage"] = JSON.stringify(rawUsage);
+          }
+          if (providerMetadata) {
+            attributes["fallom.raw.providerMetadata"] = JSON.stringify(providerMetadata);
+          }
+          if (firstTokenTime) {
+            attributes["fallom.time_to_first_token_ms"] = firstTokenTime - startTime;
+          }
+          const totalDurationMs = endTime - startTime;
+          const sortedToolTimings = Array.from(toolTimings.values()).sort(
+            (a, b) => a.startTime - b.startTime
+          );
+          const waterfallTimings = {
+            requestStart: 0,
+            firstTokenTime: firstTokenTime ? firstTokenTime - startTime : void 0,
+            responseEnd: totalDurationMs,
+            totalDurationMs,
+            isStreaming: true,
+            phases: [],
+            toolTimings: sortedToolTimings
+          };
+          if (firstTokenTime) {
+            waterfallTimings.phases.push({
+              type: "ttft",
+              label: "Time to First Token",
+              startMs: 0,
+              endMs: firstTokenTime - startTime,
+              durationMs: firstTokenTime - startTime,
+              accurate: true
+            });
+          }
+          if (sortedToolTimings.length > 0) {
+            const firstToolStart = Math.min(...sortedToolTimings.map((t) => t.startTime));
+            const lastToolEnd = Math.max(...sortedToolTimings.map((t) => t.endTime));
+            if (firstToolStart > 10) {
+              waterfallTimings.phases.push({
+                type: "llm",
+                label: "LLM Call 1 (decides tools)",
+                startMs: 0,
+                endMs: firstToolStart,
+                durationMs: firstToolStart,
+                accurate: true
+              });
+            }
+            sortedToolTimings.forEach((toolTiming) => {
+              waterfallTimings.phases.push({
+                type: "tool",
+                label: `${toolTiming.name}()`,
+                startMs: toolTiming.startTime,
+                endMs: toolTiming.endTime,
+                durationMs: toolTiming.duration,
+                accurate: true
+              });
+            });
+            const finalResponseDuration = totalDurationMs - lastToolEnd;
+            if (finalResponseDuration > 10) {
+              waterfallTimings.phases.push({
+                type: "response",
+                label: "LLM Call 2 \u2192 Final Response",
+                startMs: lastToolEnd,
+                endMs: totalDurationMs,
+                durationMs: finalResponseDuration,
+                accurate: true
+              });
+            }
+          }
+          if (steps) {
+            waterfallTimings.steps = steps.map((step, idx) => ({
+              stepIndex: idx,
+              stepType: step?.stepType,
+              finishReason: step?.finishReason,
+              timestamp: step?.response?.timestamp,
+              toolCalls: step?.toolCalls?.map((tc) => ({
+                id: tc?.toolCallId,
+                name: tc?.toolName
+              })),
+              usage: step?.usage
+            }));
+          }
+          attributes["fallom.raw.timings"] = JSON.stringify(waterfallTimings);
+          const promptCtx = getPromptContext();
+          sendTrace({
+            config_key: ctx.configKey,
+            session_id: ctx.sessionId,
+            customer_id: ctx.customerId,
+            trace_id: traceId,
+            span_id: spanId,
+            parent_span_id: parentSpanId,
+            name: "streamText",
+            kind: "llm",
+            model: modelId,
+            start_time: new Date(startTime).toISOString(),
+            end_time: new Date(endTime).toISOString(),
+            duration_ms: endTime - startTime,
+            status: "OK",
+            time_to_first_token_ms: firstTokenTime ? firstTokenTime - startTime : void 0,
+            is_streaming: true,
+            attributes,
+            // Prompt context (if prompts.get() or prompts.getAB() was called)
+            prompt_key: promptCtx?.promptKey,
+            prompt_version: promptCtx?.promptVersion,
+            prompt_ab_test_key: promptCtx?.abTestKey,
+            prompt_variant_index: promptCtx?.variantIndex
+          }).catch(() => {
+          });
         }
-        if (rawUsage) {
-          attributes["fallom.raw.usage"] = JSON.stringify(rawUsage);
-        }
-        if (providerMetadata) {
-          attributes["fallom.raw.providerMetadata"] = JSON.stringify(providerMetadata);
-        }
-        if (firstTokenTime) {
-          attributes["fallom.time_to_first_token_ms"] = firstTokenTime - startTime;
-        }
-        sendTrace({
-          config_key: ctx.configKey,
-          session_id: ctx.sessionId,
-          customer_id: ctx.customerId,
-          trace_id: traceId,
-          span_id: spanId,
-          parent_span_id: parentSpanId,
-          name: "streamText",
-          kind: "llm",
-          model: modelId,
-          start_time: new Date(startTime).toISOString(),
-          end_time: new Date(endTime).toISOString(),
-          duration_ms: endTime - startTime,
-          status: "OK",
-          time_to_first_token_ms: firstTokenTime ? firstTokenTime - startTime : void 0,
-          is_streaming: true,
-          attributes
-        }).catch(() => {
-        });
-      }).catch((error) => {
+      ).catch((error) => {
         const endTime = Date.now();
-        log2("\u274C streamText error:", error?.message);
+        log3("\u274C streamText error:", error?.message);
         sendTrace({
           config_key: ctx.configKey,
           session_id: ctx.sessionId,
@@ -1265,7 +1988,7 @@ function createStreamTextWrapper(aiModule, sessionCtx, debug = false) {
         for await (const chunk of originalTextStream) {
           if (!firstTokenTime) {
             firstTokenTime = Date.now();
-            log2("\u23F1\uFE0F Time to first token:", firstTokenTime - startTime, "ms");
+            log3("\u23F1\uFE0F Time to first token:", firstTokenTime - startTime, "ms");
           }
           yield chunk;
         }
@@ -1335,6 +2058,7 @@ function createGenerateObjectWrapper(aiModule, sessionCtx, debug = false) {
           result.experimental_providerMetadata
         );
       }
+      const promptCtx = getPromptContext();
       sendTrace({
         config_key: ctx.configKey,
         session_id: ctx.sessionId,
@@ -1349,7 +2073,12 @@ function createGenerateObjectWrapper(aiModule, sessionCtx, debug = false) {
         end_time: new Date(endTime).toISOString(),
         duration_ms: endTime - startTime,
         status: "OK",
-        attributes
+        attributes,
+        // Prompt context (if prompts.get() or prompts.getAB() was called)
+        prompt_key: promptCtx?.promptKey,
+        prompt_version: promptCtx?.promptVersion,
+        prompt_ab_test_key: promptCtx?.abTestKey,
+        prompt_variant_index: promptCtx?.variantIndex
       }).catch(() => {
       });
       return result;
@@ -1444,6 +2173,7 @@ function createStreamObjectWrapper(aiModule, sessionCtx, debug = false) {
         if (providerMetadata) {
           attributes["fallom.raw.providerMetadata"] = JSON.stringify(providerMetadata);
         }
+        const promptCtx = getPromptContext();
         sendTrace({
           config_key: ctx.configKey,
           session_id: ctx.sessionId,
@@ -1459,7 +2189,12 @@ function createStreamObjectWrapper(aiModule, sessionCtx, debug = false) {
           duration_ms: endTime - startTime,
           status: "OK",
           is_streaming: true,
-          attributes
+          attributes,
+          // Prompt context (if prompts.get() or prompts.getAB() was called)
+          prompt_key: promptCtx?.promptKey,
+          prompt_version: promptCtx?.promptVersion,
+          prompt_ab_test_key: promptCtx?.abTestKey,
+          prompt_variant_index: promptCtx?.variantIndex
         }).catch(() => {
         });
       }).catch((error) => {
@@ -1602,7 +2337,7 @@ var FallomSession = class {
       configKey = this.ctx.configKey;
       opts = configKeyOrOptions || {};
     }
-    const { get: get2 } = await import("./models-SEFDGZU2.mjs");
+    const { get: get2 } = await import("./models-NKYYGMSR.mjs");
     return get2(configKey, this.ctx.sessionId, opts);
   }
   /**
@@ -1764,252 +2499,32 @@ function session(options) {
   return new FallomSession(options);
 }
 
-// src/prompts.ts
-var prompts_exports = {};
-__export(prompts_exports, {
-  clearPromptContext: () => clearPromptContext,
-  get: () => get,
-  getAB: () => getAB,
-  getPromptContext: () => getPromptContext,
-  init: () => init3
+// src/evals/index.ts
+var evals_exports = {};
+__export(evals_exports, {
+  AVAILABLE_METRICS: () => AVAILABLE_METRICS,
+  DEFAULT_JUDGE_MODEL: () => DEFAULT_JUDGE_MODEL,
+  METRIC_PROMPTS: () => METRIC_PROMPTS,
+  compareModels: () => compareModels,
+  createCustomModel: () => createCustomModel,
+  createModelFromCallable: () => createModelFromCallable,
+  createOpenAIModel: () => createOpenAIModel,
+  customMetric: () => customMetric,
+  datasetFromFallom: () => datasetFromFallom,
+  datasetFromTraces: () => datasetFromTraces,
+  evaluate: () => evaluate,
+  getMetricName: () => getMetricName,
+  init: () => init2,
+  isCustomMetric: () => isCustomMetric,
+  uploadResults: () => uploadResultsPublic
 });
-import { createHash } from "crypto";
-var apiKey2 = null;
-var baseUrl2 = "https://prompts.fallom.com";
-var initialized2 = false;
-var syncInterval = null;
-var debugMode2 = false;
-var promptCache = /* @__PURE__ */ new Map();
-var promptABCache = /* @__PURE__ */ new Map();
-var promptContext = null;
-var SYNC_TIMEOUT = 2e3;
-function log3(msg) {
-  if (debugMode2) {
-    console.log(`[Fallom Prompts] ${msg}`);
-  }
-}
-function init3(options = {}) {
-  apiKey2 = options.apiKey || process.env.FALLOM_API_KEY || null;
-  baseUrl2 = options.baseUrl || process.env.FALLOM_PROMPTS_URL || process.env.FALLOM_BASE_URL || "https://prompts.fallom.com";
-  initialized2 = true;
-  if (!apiKey2) {
-    return;
-  }
-  fetchAll().catch(() => {
-  });
-  if (!syncInterval) {
-    syncInterval = setInterval(() => {
-      fetchAll().catch(() => {
-      });
-    }, 3e4);
-    syncInterval.unref();
-  }
-}
-function ensureInit() {
-  if (!initialized2) {
-    try {
-      init3();
-    } catch {
-    }
-  }
-}
-async function fetchAll() {
-  await Promise.all([fetchPrompts(), fetchPromptABTests()]);
-}
-async function fetchPrompts(timeout = SYNC_TIMEOUT) {
-  if (!apiKey2) return;
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const resp = await fetch(`${baseUrl2}/prompts`, {
-      headers: { Authorization: `Bearer ${apiKey2}` },
-      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 (!apiKey2) return;
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    const resp = await fetch(`${baseUrl2}/prompt-ab-tests`, {
-      headers: { Authorization: `Bearer ${apiKey2}` },
-      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;
-  debugMode2 = debug;
-  ensureInit();
-  log3(`get() called: promptKey=${promptKey}`);
-  let promptData = promptCache.get(promptKey);
-  if (!promptData) {
-    log3("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
-  });
-  log3(`\u2705 Got prompt: ${promptKey} v${targetVersion}`);
-  return {
-    key: promptKey,
-    version: targetVersion,
-    system,
-    user
-  };
-}
-async function getAB(abTestKey, sessionId, options = {}) {
-  const { variables, debug = false } = options;
-  debugMode2 = debug;
-  ensureInit();
-  log3(`getAB() called: abTestKey=${abTestKey}, sessionId=${sessionId}`);
-  let abData = promptABCache.get(abTestKey);
-  if (!abData) {
-    log3("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;
-  log3(`A/B test '${abTestKey}' has ${variants?.length ?? 0} variants`);
-  log3(`Version data: ${JSON.stringify(versionData, null, 2)}`);
-  if (!variants || variants.length === 0) {
-    throw new Error(
-      `Prompt A/B test '${abTestKey}' has no variants configured.`
-    );
-  }
-  const hashBytes = 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
-  });
-  log3(
-    `\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;
-}
 
 // src/init.ts
-async function init4(options = {}) {
+async function init5(options = {}) {
   const tracesUrl = options.tracesUrl || process.env.FALLOM_TRACES_URL || "https://traces.fallom.com";
   const configsUrl = options.configsUrl || process.env.FALLOM_CONFIGS_URL || "https://configs.fallom.com";
   const promptsUrl = options.promptsUrl || process.env.FALLOM_PROMPTS_URL || "https://prompts.fallom.com";
-  await init2({
+  await init3({
     apiKey: options.apiKey,
     baseUrl: tracesUrl,
     captureContent: options.captureContent,
@@ -2019,7 +2534,7 @@ async function init4(options = {}) {
     apiKey: options.apiKey,
     baseUrl: configsUrl
   });
-  init3({
+  init4({
     apiKey: options.apiKey,
     baseUrl: promptsUrl
   });
@@ -2265,10 +2780,11 @@ var FallomExporter = class {
 
 // src/index.ts
 var index_default = {
-  init: init4,
+  init: init5,
   trace: trace_exports,
   models: models_exports,
   prompts: prompts_exports,
+  evals: evals_exports,
   session
 };
 export {
@@ -2276,7 +2792,8 @@ export {
   FallomSession,
   clearMastraPrompt,
   index_default as default,
-  init4 as init,
+  evals_exports as evals,
+  init5 as init,
   models_exports as models,
   prompts_exports as prompts,
   session,