elasticdash-test 0.1.11 → 0.1.12

package/dist/index.cjs

@@ -0,0 +1,2526 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/capture/recorder.ts
+function setCaptureContext(ctx) {
+  captureAls.enterWith(ctx);
+}
+function getCaptureContext() {
+  return captureAls.getStore();
+}
+var import_node_async_hooks, import_node_crypto, TraceRecorder, g, CAPTURE_ALS_KEY, captureAls;
+var init_recorder = __esm({
+  "src/capture/recorder.ts"() {
+    "use strict";
+    import_node_async_hooks = require("node:async_hooks");
+    import_node_crypto = require("node:crypto");
+    TraceRecorder = class {
+      events = [];
+      _counter = 0;
+      _sideEffectCounter = 0;
+      record(event) {
+        this.events.push(event);
+      }
+      nextId() {
+        return ++this._counter;
+      }
+      /** Separate counter for Date.now / Math.random — never shares IDs with main events. */
+      nextSideEffectId() {
+        return ++this._sideEffectCounter;
+      }
+      toTrace(traceId) {
+        return {
+          traceId: traceId ?? (0, import_node_crypto.randomUUID)(),
+          events: [...this.events]
+        };
+      }
+    };
+    g = globalThis;
+    CAPTURE_ALS_KEY = "__elasticdash_capture_als__";
+    captureAls = g[CAPTURE_ALS_KEY] ?? new import_node_async_hooks.AsyncLocalStorage();
+    if (!g[CAPTURE_ALS_KEY]) g[CAPTURE_ALS_KEY] = captureAls;
+  }
+});
+
+// src/interceptors/side-effects.ts
+function rawDateNow() {
+  return originalDateNow ? originalDateNow() : Date.now();
+}
+function interceptRandom() {
+  if (originalRandom) return;
+  originalRandom = Math.random;
+  Math.random = () => {
+    const ctx = getCaptureContext();
+    if (!ctx) return originalRandom();
+    const { recorder, replay } = ctx;
+    const n = recorder.nextSideEffectId();
+    if (replay.shouldReplaySideEffectOfType(n, "Math.random")) {
+      return replay.getSideEffectResultOfType(n, "Math.random");
+    }
+    const value = originalRandom();
+    recorder.record({
+      id: n,
+      type: "side_effect",
+      name: "Math.random",
+      input: null,
+      output: value,
+      timestamp: rawDateNow(),
+      durationMs: 0
+    });
+    return value;
+  };
+}
+function restoreRandom() {
+  if (originalRandom) {
+    Math.random = originalRandom;
+    originalRandom = void 0;
+  }
+}
+function interceptDateNow() {
+  if (originalDateNow) return;
+  originalDateNow = Date.now;
+  Date.now = () => {
+    const ctx = getCaptureContext();
+    if (!ctx) return originalDateNow();
+    const { recorder, replay } = ctx;
+    const n = recorder.nextSideEffectId();
+    if (replay.shouldReplaySideEffectOfType(n, "Date.now")) {
+      return replay.getSideEffectResultOfType(n, "Date.now");
+    }
+    const value = originalDateNow();
+    recorder.record({
+      id: n,
+      type: "side_effect",
+      name: "Date.now",
+      input: null,
+      output: value,
+      timestamp: value,
+      durationMs: 0
+    });
+    return value;
+  };
+}
+function restoreDateNow() {
+  if (originalDateNow) {
+    Date.now = originalDateNow;
+    originalDateNow = void 0;
+  }
+}
+var originalRandom, originalDateNow;
+var init_side_effects = __esm({
+  "src/interceptors/side-effects.ts"() {
+    "use strict";
+    init_recorder();
+  }
+});
+
+// src/trace-adapter/context.ts
+function setCurrentTrace(trace) {
+  traceAls.enterWith(trace);
+}
+function getCurrentTrace() {
+  return traceAls.getStore();
+}
+function createTraceHandle() {
+  const steps = [];
+  const llmSteps = [];
+  const toolCalls = [];
+  const customSteps = [];
+  return {
+    getSteps() {
+      return steps;
+    },
+    getLLMSteps() {
+      return llmSteps;
+    },
+    getToolCalls() {
+      return toolCalls;
+    },
+    getCustomSteps() {
+      return customSteps;
+    },
+    recordLLMStep(step) {
+      llmSteps.push(step);
+      steps.push({
+        type: "llm",
+        timestamp: rawDateNow(),
+        durationMs: 0,
+        data: step
+      });
+    },
+    recordToolCall(call) {
+      toolCalls.push(call);
+      steps.push({
+        type: "tool",
+        timestamp: rawDateNow(),
+        durationMs: 0,
+        data: call
+      });
+    },
+    recordCustomStep(step) {
+      customSteps.push(step);
+      steps.push({
+        type: "custom",
+        timestamp: rawDateNow(),
+        durationMs: 0,
+        data: step
+      });
+    }
+  };
+}
+function startTraceSession() {
+  const trace = createTraceHandle();
+  const context = { trace };
+  return {
+    context,
+    finalise() {
+    }
+  };
+}
+var import_node_async_hooks2, g2, TRACE_ALS_KEY, traceAls;
+var init_context = __esm({
+  "src/trace-adapter/context.ts"() {
+    "use strict";
+    import_node_async_hooks2 = require("node:async_hooks");
+    init_side_effects();
+    g2 = globalThis;
+    TRACE_ALS_KEY = "__elasticdash_trace_als__";
+    traceAls = g2[TRACE_ALS_KEY] ?? new import_node_async_hooks2.AsyncLocalStorage();
+    if (!g2[TRACE_ALS_KEY]) g2[TRACE_ALS_KEY] = traceAls;
+  }
+});
+
+// src/tracing.ts
+var tracing_exports = {};
+__export(tracing_exports, {
+  recordToolCall: () => recordToolCall
+});
+function wrapperRecordingActive() {
+  return globalThis[TOOL_WRAPPER_ACTIVE_KEY] === true;
+}
+function recordToolCall(name, args, result) {
+  if (!globalThis.__ELASTICDASH_WORKER__) return;
+  try {
+    if (wrapperRecordingActive()) return;
+    const trace = getCurrentTrace();
+    if (!trace || typeof trace.recordToolCall !== "function") return;
+    const ctx = getCaptureContext();
+    if (!ctx) {
+      trace.recordToolCall({ name, args, result });
+      return;
+    }
+    const { recorder, replay } = ctx;
+    const id = recorder.nextId();
+    if (replay.shouldReplay(id)) {
+      const historical = replay.getRecordedEvent(id);
+      if (historical) recorder.record(historical);
+      const replayed = replay.getRecordedResult(id);
+      trace.recordToolCall({ name, args, result: replayed, workflowEventId: id });
+      return;
+    }
+    const output = result instanceof Error ? { error: String(result) } : result;
+    recorder.record({
+      id,
+      type: "tool",
+      name,
+      input: args,
+      output,
+      timestamp: rawDateNow(),
+      durationMs: 0
+    });
+    trace.recordToolCall({ name, args, result: output, workflowEventId: id });
+  } catch {
+  }
+}
+var TOOL_WRAPPER_ACTIVE_KEY;
+var init_tracing = __esm({
+  "src/tracing.ts"() {
+    "use strict";
+    init_context();
+    init_recorder();
+    init_side_effects();
+    TOOL_WRAPPER_ACTIVE_KEY = "__elasticdash_tool_wrapper_active__";
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ReplayController: () => ReplayController,
+  TraceRecorder: () => TraceRecorder,
+  afterAll: () => afterAll,
+  afterEach: () => afterEach,
+  aiTest: () => aiTest,
+  beforeAll: () => beforeAll,
+  beforeEach: () => beforeEach,
+  clearRegistry: () => clearRegistry,
+  createTraceHandle: () => createTraceHandle,
+  deserializeAgentState: () => deserializeAgentState,
+  expect: () => import_expect.expect,
+  extractTaskOutputs: () => extractTaskOutputs,
+  fetchCapturedTrace: () => fetchCapturedTrace,
+  getCaptureContext: () => getCaptureContext,
+  getCurrentTrace: () => getCurrentTrace,
+  getRegistry: () => getRegistry,
+  installAIInterceptor: () => installAIInterceptor,
+  installDBAutoInterceptor: () => installDBAutoInterceptor,
+  interceptDateNow: () => interceptDateNow,
+  interceptFetch: () => interceptFetch,
+  interceptRandom: () => interceptRandom,
+  isWorker: () => isWorker,
+  recordToolCall: () => recordToolCall,
+  registerMatchers: () => registerMatchers,
+  reportResults: () => reportResults,
+  resolveTaskInput: () => resolveTaskInput,
+  restoreDateNow: () => restoreDateNow,
+  restoreFetch: () => restoreFetch,
+  restoreRandom: () => restoreRandom,
+  runFiles: () => runFiles,
+  runWorkflow: () => runWorkflow,
+  safeRecordToolCall: () => safeRecordToolCall,
+  serializeAgentState: () => serializeAgentState,
+  setCaptureContext: () => setCaptureContext,
+  setCurrentTrace: () => setCurrentTrace,
+  startLLMProxy: () => startLLMProxy,
+  startTraceSession: () => startTraceSession,
+  uninstallAIInterceptor: () => uninstallAIInterceptor,
+  uninstallDBAutoInterceptor: () => uninstallDBAutoInterceptor,
+  wrapAI: () => wrapAI,
+  wrapDB: () => wrapDB,
+  wrapKnex: () => wrapKnex,
+  wrapMongoCollection: () => wrapMongoCollection,
+  wrapPgClient: () => wrapPgClient,
+  wrapRedisClient: () => wrapRedisClient,
+  wrapTool: () => wrapTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/registry.ts
+var REGISTRY_KEY = "__elasticdash_registry__";
+function getGlobalRegistry() {
+  if (!globalThis[REGISTRY_KEY]) {
+    globalThis[REGISTRY_KEY] = createEmptyRegistry();
+  }
+  return globalThis[REGISTRY_KEY];
+}
+function createEmptyRegistry() {
+  return {
+    tests: [],
+    beforeAllHooks: [],
+    afterAllHooks: [],
+    beforeEachHooks: [],
+    afterEachHooks: []
+  };
+}
+function clearRegistry() {
+  globalThis[REGISTRY_KEY] = createEmptyRegistry();
+  console.log("[elasticdash] clearRegistry called. Registry reset.");
+}
+function getRegistry() {
+  const registry = getGlobalRegistry();
+  console.log("[elasticdash] getRegistry called. Current tests:", registry.tests.map((t) => t.name));
+  return registry;
+}
+function aiTest(name, fn) {
+  const registry = getGlobalRegistry();
+  registry.tests.push({ name, fn });
+  console.log(`[elasticdash] Registered test: ${name}`);
+}
+function beforeAll(fn) {
+  const registry = getGlobalRegistry();
+  registry.beforeAllHooks.push(fn);
+}
+function afterAll(fn) {
+  const registry = getGlobalRegistry();
+  registry.afterAllHooks.push(fn);
+}
+function beforeEach(fn) {
+  const registry = getGlobalRegistry();
+  registry.beforeEachHooks.push(fn);
+}
+function afterEach(fn) {
+  const registry = getGlobalRegistry();
+  registry.afterEachHooks.push(fn);
+}
+globalThis.aiTest = aiTest;
+globalThis.beforeAll = beforeAll;
+globalThis.afterAll = afterAll;
+globalThis.beforeEach = beforeEach;
+globalThis.afterEach = afterEach;
+
+// src/index.ts
+init_context();
+
+// src/matchers/index.ts
+var import_expect = require("expect");
+function isTraceHandle(value) {
+  return value !== null && typeof value === "object" && typeof value.getLLMSteps === "function" && typeof value.getToolCalls === "function";
+}
+var defaultModels = {
+  openai: "gpt-4.1",
+  claude: "claude-3-opus-20240229",
+  gemini: "gemini-1.5-pro",
+  grok: "grok-beta",
+  kimi: "kimi-k2-turbo-preview"
+};
+async function callProviderLLM(prompt, options = {}, systemPrompt = "You are an expert test judge.", maxTokens = 32, temperature = 0) {
+  const provider = options.provider ?? "openai";
+  const sdk = options.sdk;
+  const resolvedModel = options.model ?? defaultModels[provider];
+  switch (provider) {
+    case "openai": {
+      if (sdk && sdk.chat?.completions?.create) {
+        const resp = await sdk.chat.completions.create({
+          model: resolvedModel,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: prompt }
+          ],
+          max_tokens: maxTokens,
+          temperature
+        });
+        return resp?.choices?.[0]?.message?.content?.trim() ?? "";
+      }
+      const apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+      if (!apiKey) throw new Error("Provide apiKey or set OPENAI_API_KEY for OpenAI-compatible endpoint.");
+      const baseURL = (options.baseURL ?? "https://api.openai.com/v1").replace(/\/$/, "");
+      const response = await fetch(`${baseURL}/chat/completions`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: resolvedModel,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: prompt }
+          ],
+          max_tokens: maxTokens,
+          temperature
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.choices?.[0]?.message?.content?.trim() ?? "";
+    }
+    case "claude": {
+      if (sdk && sdk.messages?.create) {
+        const resp = await sdk.messages.create({
+          model: resolvedModel,
+          max_tokens: maxTokens,
+          temperature,
+          messages: [{ role: "user", content: `${systemPrompt}
+
+${prompt}` }]
+        });
+        return resp?.content?.[0]?.text?.trim() ?? "";
+      }
+      const apiKey = process.env.ANTHROPIC_API_KEY;
+      if (!apiKey) throw new Error("ANTHROPIC_API_KEY is not set in environment.");
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model: resolvedModel,
+          max_tokens: maxTokens,
+          temperature,
+          messages: [{ role: "user", content: `${systemPrompt}
+
+${prompt}` }]
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Claude API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data?.content?.[0]?.text?.trim() ?? "";
+    }
+    case "gemini": {
+      if (sdk && sdk.models?.generateContent) {
+        const resp = await sdk.models.generateContent({
+          model: resolvedModel,
+          contents: [{ role: "user", parts: [{ text: `${systemPrompt}
+
+${prompt}` }] }],
+          generationConfig: { temperature, maxOutputTokens: maxTokens }
+        });
+        return resp?.response?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
+      }
+      const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+      if (!apiKey) throw new Error("GEMINI_API_KEY (or GOOGLE_API_KEY) is not set in environment.");
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${resolvedModel}:generateContent?key=${apiKey}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            contents: [{ role: "user", parts: [{ text: `${systemPrompt}
+
+${prompt}` }] }],
+            generationConfig: { temperature, maxOutputTokens: maxTokens }
+          })
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`Gemini API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data?.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
+    }
+    case "grok": {
+      if (sdk && sdk.chat?.completions?.create) {
+        const resp = await sdk.chat.completions.create({
+          model: resolvedModel,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: prompt }
+          ],
+          max_tokens: maxTokens,
+          temperature
+        });
+        return resp?.choices?.[0]?.message?.content?.trim() ?? "";
+      }
+      const apiKey = process.env.GROK_API_KEY;
+      if (!apiKey) throw new Error("GROK_API_KEY is not set in environment.");
+      const response = await fetch("https://api.x.ai/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: resolvedModel,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: prompt }
+          ],
+          max_tokens: maxTokens,
+          temperature
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Grok API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.choices?.[0]?.message?.content?.trim() ?? "";
+    }
+    case "kimi": {
+      const apiKey = process.env.KIMI_API_KEY;
+      if (!apiKey) throw new Error("KIMI_API_KEY is not set in environment.");
+      const response = await fetch("https://api.moonshot.ai/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model: resolvedModel,
+          messages: [
+            { role: "system", content: systemPrompt },
+            { role: "user", content: prompt }
+          ],
+          max_tokens: maxTokens,
+          temperature
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Kimi API error: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      return data.choices?.[0]?.message?.content?.trim() ?? "";
+    }
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+async function llmJudgeSemanticMatch(traceOutput, expected, options = {}) {
+  const prompt = `
+You are an expert test judge. Given the following AI trace output and an expected semantic result, answer "YES" if the trace output semantically matches the expectation, otherwise answer "NO".
+
+Trace Output:
+${traceOutput}
+
+Expected:
+${expected}
+
+Answer only "YES" or "NO".
+  `.trim();
+  const content = (await callProviderLLM(prompt, options, "You are an expert test judge.", 8, 0)).trim().toUpperCase();
+  return content.startsWith("YES");
+}
+function parseFirstNumber(text) {
+  const match = text.match(/-?\d+(?:\.\d+)?/);
+  if (!match) return null;
+  const num = Number.parseFloat(match[0]);
+  return Number.isFinite(num) ? num : null;
+}
+function resolveCondition(config) {
+  const entries = Object.entries(config || {}).filter(([, v]) => typeof v === "number" && Number.isFinite(v));
+  if (entries.length === 0) return { kind: "atLeast", value: 0.7 };
+  if (entries.length > 1) {
+    throw new Error("Provide only one metric condition (greaterThan, lessThan, atLeast, atMost, equals).");
+  }
+  return { kind: entries[0][0], value: entries[0][1] };
+}
+function checkCondition(score, condition) {
+  switch (condition.kind) {
+    case "greaterThan":
+      return score > condition.value;
+    case "lessThan":
+      return score < condition.value;
+    case "atLeast":
+      return score >= condition.value;
+    case "atMost":
+      return score <= condition.value;
+    case "equals":
+      return score === condition.value;
+    default:
+      return false;
+  }
+}
+function registerMatchers() {
+  import_expect.expect.extend({
+    toHaveLLMStep(trace, config = {}) {
+      if (!isTraceHandle(trace)) {
+        return {
+          pass: false,
+          message: () => `Expected a TraceHandle (ctx.trace) but received ${typeof trace}.
+Use: expect(ctx.trace).toHaveLLMStep(...)`
+        };
+      }
+      const steps = trace.getLLMSteps();
+      const matching = steps.filter((step) => {
+        if (config.model && step.model !== config.model) return false;
+        if (config.provider && step.provider !== config.provider) return false;
+        if (config.contains) {
+          const haystack = [step.completion, step.prompt, step.contains].filter(Boolean).join(" ").toLowerCase();
+          if (!haystack.includes(config.contains.toLowerCase())) return false;
+        }
+        if (config.promptContains) {
+          const promptHaystack = (step.prompt ?? "").toLowerCase();
+          if (!promptHaystack.includes(config.promptContains.toLowerCase())) return false;
+        }
+        if (config.outputContains) {
+          const outputHaystack = (step.completion ?? "").toLowerCase();
+          if (!outputHaystack.includes(config.outputContains.toLowerCase())) return false;
+        }
+        return true;
+      });
+      const count = matching.length;
+      let pass;
+      if (config.times !== void 0) {
+        pass = count === config.times;
+      } else if (config.minTimes !== void 0 || config.maxTimes !== void 0) {
+        const min = config.minTimes ?? 0;
+        const max = config.maxTimes ?? Infinity;
+        pass = count >= min && count <= max;
+      } else {
+        pass = count > 0;
+      }
+      return {
+        pass,
+        message: () => {
+          if (pass) {
+            return `Expected trace NOT to have LLM step matching ${JSON.stringify(config)}`;
+          }
+          const stepSummary = steps.length === 0 ? "no LLM steps were recorded" : `${count} matching step(s) found; recorded steps: ${JSON.stringify(steps)}`;
+          return `Expected trace to have LLM step matching ${JSON.stringify(config)}, but ${stepSummary}`;
+        }
+      };
+    },
+    toCallTool(trace, toolName) {
+      if (!isTraceHandle(trace)) {
+        return {
+          pass: false,
+          message: () => `Expected a TraceHandle (ctx.trace) but received ${typeof trace}.
+Use: expect(ctx.trace).toCallTool(...)`
+        };
+      }
+      const calls = trace.getToolCalls();
+      const pass = calls.some((c) => c.name === toolName);
+      return {
+        pass,
+        message: () => {
+          if (pass) {
+            return `Expected trace NOT to call tool "${toolName}"`;
+          }
+          const names = calls.map((c) => c.name);
+          const recorded = names.length === 0 ? "no tool calls were recorded" : `recorded: [${names.join(", ")}]`;
+          return `Expected tool "${toolName}" to be called, but ${recorded}`;
+        }
+      };
+    },
+    async toMatchSemanticOutput(trace, expected, options) {
+      if (!isTraceHandle(trace)) {
+        return {
+          pass: false,
+          message: () => `Expected a TraceHandle (ctx.trace) but received ${typeof trace}.
+Use: expect(ctx.trace).toMatchSemanticOutput(...)`
+        };
+      }
+      const steps = trace.getLLMSteps();
+      const fullOutput = steps.map((s) => [s.completion, s.contains].filter(Boolean).join(" ")).join(" ").trim();
+      try {
+        const pass = await llmJudgeSemanticMatch(fullOutput, expected, options);
+        return {
+          pass,
+          message: () => {
+            if (pass) {
+              return `Expected trace output NOT to semantically match "${expected}" (LLM judged YES)`;
+            }
+            return `Expected trace output to semantically match "${expected}", but LLM judged NO. Trace output: "${fullOutput || "(empty)"}"`;
+          }
+        };
+      } catch (err) {
+        return {
+          pass: false,
+          message: () => `LLM semantic match failed: ${err.message}`
+        };
+      }
+    },
+    async toEvaluateOutputMetric(trace, config) {
+      if (!isTraceHandle(trace)) {
+        return {
+          pass: false,
+          message: () => `Expected a TraceHandle (ctx.trace) but received ${typeof trace}.
+Use: expect(ctx.trace).toEvaluateOutputMetric(...)`
+        };
+      }
+      if (!config || !config.evaluationPrompt) {
+        return {
+          pass: false,
+          message: () => "toEvaluateOutputMetric requires evaluationPrompt"
+        };
+      }
+      const steps = trace.getLLMSteps();
+      if (steps.length === 0) {
+        return {
+          pass: false,
+          message: () => "No LLM steps recorded; cannot evaluate output metric."
+        };
+      }
+      const targetIdx = config.index ?? (config.nth !== void 0 ? config.nth - 1 : steps.length - 1);
+      if (targetIdx < 0 || targetIdx >= steps.length) {
+        return {
+          pass: false,
+          message: () => `LLM steps length ${steps.length}, but index/nth points to ${targetIdx}.`
+        };
+      }
+      const targetStep = steps[targetIdx];
+      const targetField = config.target ?? "result";
+      const targetText = targetField === "prompt" ? targetStep.prompt ?? "" : targetStep.completion ?? "";
+      if (!targetText) {
+        return {
+          pass: false,
+          message: () => `Selected LLM step has empty ${targetField}; cannot evaluate.`
+        };
+      }
+      const condition = (() => {
+        try {
+          return resolveCondition(config.condition);
+        } catch (err) {
+          return err;
+        }
+      })();
+      if (condition instanceof Error) {
+        return {
+          pass: false,
+          message: () => condition.message
+        };
+      }
+      const evalPrompt = `
+Evaluation prompt (from user):
+${config.evaluationPrompt}
+
+Score the following text strictly between 0 and 1 (inclusive). Respond with only the number.
+
+Text:
+${targetText}
+      `.trim();
+      try {
+        const raw = await callProviderLLM(
+          evalPrompt,
+          { provider: config.provider, model: config.model, sdk: config.sdk, apiKey: config.apiKey, baseURL: config.baseURL },
+          "You are an evaluation assistant. Return only a number between 0 and 1.",
+          16,
+          0
+        );
+        const score = parseFirstNumber(raw);
+        if (score === null) {
+          return {
+            pass: false,
+            message: () => `Could not parse numeric metric from model response: "${raw}"`
+          };
+        }
+        if (score < 0 || score > 1) {
+          return {
+            pass: false,
+            message: () => `Metric ${score} is out of allowed range 0.0\u20131.0 (raw: "${raw}")`
+          };
+        }
+        const pass = checkCondition(score, condition);
+        return {
+          pass,
+          message: () => {
+            if (pass) {
+              return `Expected metric NOT to satisfy ${condition.kind} ${condition.value} (score ${score})`;
+            }
+            return `Metric check failed: score ${score} did not satisfy ${condition.kind} ${condition.value}. Raw response: "${raw}"`;
+          }
+        };
+      } catch (err) {
+        return {
+          pass: false,
+          message: () => `LLM evaluation failed: ${err.message}`
+        };
+      }
+    },
+    toHaveCustomStep(trace, config = {}) {
+      if (!isTraceHandle(trace) || typeof trace.getCustomSteps !== "function") {
+        return {
+          pass: false,
+          message: () => `Expected a TraceHandle (ctx.trace with getCustomSteps) but received ${typeof trace}.
+Use: expect(ctx.trace).toHaveCustomStep(...)`
+        };
+      }
+      const steps = trace.getCustomSteps();
+      const matchString = (val) => {
+        if (val === void 0 || val === null) return "";
+        if (typeof val === "string") return val;
+        try {
+          return JSON.stringify(val);
+        } catch {
+          return String(val);
+        }
+      };
+      const matching = steps.filter((step) => {
+        if (config.kind && step.kind !== config.kind) return false;
+        if (config.name && step.name !== config.name) return false;
+        if (config.tag && !(step.tags || []).includes(config.tag)) return false;
+        const payloadStr = matchString(step.payload).toLowerCase();
+        const resultStr = matchString(step.result).toLowerCase();
+        const metaStr = matchString(step.metadata).toLowerCase();
+        const combined = [payloadStr, resultStr, metaStr].filter(Boolean).join(" ");
+        if (config.contains && !combined.includes(config.contains.toLowerCase())) return false;
+        if (config.payloadContains && !payloadStr.includes(config.payloadContains.toLowerCase())) return false;
+        if (config.resultContains && !resultStr.includes(config.resultContains.toLowerCase())) return false;
+        if (config.metadataContains && !metaStr.includes(config.metadataContains.toLowerCase())) return false;
+        return true;
+      });
+      const count = matching.length;
+      let pass;
+      if (config.times !== void 0) {
+        pass = count === config.times;
+      } else if (config.minTimes !== void 0 || config.maxTimes !== void 0) {
+        const min = config.minTimes ?? 0;
+        const max = config.maxTimes ?? Infinity;
+        pass = count >= min && count <= max;
+      } else {
+        pass = count > 0;
+      }
+      return {
+        pass,
+        message: () => {
+          if (pass) {
+            return `Expected trace NOT to have custom step matching ${JSON.stringify(config)}`;
+          }
+          const stepSummary = steps.length === 0 ? "no custom steps were recorded" : `${count} matching step(s) found; recorded custom steps: ${JSON.stringify(steps)}`;
+          return `Expected trace to have custom step matching ${JSON.stringify(config)}, but ${stepSummary}`;
+        }
+      };
+    },
+    toHavePromptWhere(trace, config) {
+      if (!isTraceHandle(trace)) {
+        return {
+          pass: false,
+          message: () => `Expected a TraceHandle (ctx.trace) but received ${typeof trace}.
+Use: expect(ctx.trace).toHavePromptWhere(...)`
+        };
+      }
+      if (!config || !config.filterContains) {
+        return {
+          pass: false,
+          message: () => "toHavePromptWhere requires filterContains"
+        };
+      }
+      const filterNeedle = config.filterContains.toLowerCase();
+      const requireNeedle = config.requireContains?.toLowerCase();
+      const forbidNeedle = config.requireNotContains?.toLowerCase();
+      const prompts = trace.getLLMSteps().map((s) => s.prompt ?? "");
+      const filtered = prompts.filter((p) => p.toLowerCase().includes(filterNeedle));
+      const targetIdx = config.index ?? (config.nth !== void 0 ? config.nth - 1 : void 0);
+      let checked = [];
+      let count = 0;
+      let pass = true;
+      if (targetIdx !== void 0) {
+        if (targetIdx < 0 || targetIdx >= filtered.length) {
+          return {
+            pass: false,
+            message: () => `Filtered prompts length ${filtered.length}, but index/nth points to ${targetIdx}. Config: ${JSON.stringify(config)}`
+          };
+        }
+        const p = filtered[targetIdx];
+        const lower = p.toLowerCase();
+        const okRequire = requireNeedle ? lower.includes(requireNeedle) : true;
+        const okForbid = forbidNeedle ? !lower.includes(forbidNeedle) : true;
+        pass = okRequire && okForbid;
+        checked = okRequire && okForbid ? [p] : [];
+        count = checked.length;
+      } else {
+        checked = filtered.filter((p) => {
+          const lower = p.toLowerCase();
+          if (requireNeedle && !lower.includes(requireNeedle)) return false;
+          if (forbidNeedle && lower.includes(forbidNeedle)) return false;
+          return true;
+        });
+        count = checked.length;
+        if (config.times !== void 0) {
+          pass = count === config.times;
+        } else {
+          const min = config.minTimes ?? 0;
+          const max = config.maxTimes ?? Infinity;
+          pass = count >= min && count <= max;
+        }
+        if (requireNeedle) {
+          const violating = filtered.filter((p) => !p.toLowerCase().includes(requireNeedle));
+          if (violating.length > 0) pass = false;
+        }
+        if (forbidNeedle) {
+          const violating = filtered.filter((p) => p.toLowerCase().includes(forbidNeedle));
+          if (violating.length > 0) pass = false;
+        }
+      }
+      return {
+        pass,
+        message: () => {
+          if (pass) {
+            return `Expected prompts NOT to satisfy filter/require combo: ${JSON.stringify(config)}`;
+          }
+          const base = [`Expected prompts filtered by "${config.filterContains}" to satisfy requirements`];
+          if (config.requireContains) base.push(`requireContains: "${config.requireContains}"`);
+          if (config.requireNotContains) base.push(`requireNotContains: "${config.requireNotContains}"`);
+          if (targetIdx !== void 0) {
+            base.push(`checked index: ${targetIdx}`, `filtered count: ${filtered.length}`);
+          } else {
+            base.push(`filtered count: ${filtered.length}, passing count: ${checked.length}`);
+            base.push(
+              config.times !== void 0 ? `expected exactly ${config.times}` : `expected between ${config.minTimes ?? 0} and ${config.maxTimes ?? Infinity}`
+            );
+          }
+          return base.filter(Boolean).join("; ");
+        }
+      };
+    }
+  });
+}
+
+// src/runner.ts
+init_context();
+
+// src/proxy/llm-capture.ts
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_url = require("node:url");
+var import_node_stream = require("node:stream");
+var DEFAULT_PORT = 8787;
+var HEADER_TRACE_ID = "x-trace-id";
+var DEFAULT_UPSTREAM = {
+  openai: "https://api.openai.com",
+  gemini: "https://generativelanguage.googleapis.com",
+  grok: "https://api.x.ai",
+  anthropic: "https://api.anthropic.com"
+};
+var AI_PATTERNS = {
+  openai: /\/v1\/(chat\/)?completions/,
+  // also covers legacy /v1/completions
+  gemini: /\/v1beta\/models\/[^/:]+:(generateContent|streamGenerateContent)/,
+  grok: /\/v1\/(chat\/)?completions/,
+  anthropic: /\/v1\/messages/
+};
+function detectProvider(pathname) {
+  for (const [provider, pattern] of Object.entries(AI_PATTERNS)) {
+    if (pattern.test(pathname)) return provider;
+  }
+  return null;
+}
+function extractModel(provider, body, url) {
+  if (provider === "gemini") {
+    const match = /\/models\/([^/:]+):/.exec(url);
+    return match ? match[1] : "unknown";
+  }
+  if (provider === "anthropic") {
+    return typeof body.model === "string" ? body.model : "unknown";
+  }
+  return typeof body.model === "string" ? body.model : "unknown";
+}
+function extractPrompt(provider, body) {
+  if (provider === "openai" || provider === "grok") {
+    const messages = body.messages;
+    if (Array.isArray(messages)) {
+      return messages.map((m) => {
+        if (m && typeof m === "object") {
+          const msg = m;
+          return `${msg.role}: ${msg.content}`;
+        }
+        return String(m);
+      }).join("\n");
+    }
+    return typeof body.prompt === "string" ? body.prompt : "";
+  }
+  if (provider === "gemini") {
+    const contents = body.contents;
+    if (Array.isArray(contents)) {
+      return contents.flatMap((c) => {
+        if (c && typeof c === "object") {
+          const parts = c.parts;
+          if (Array.isArray(parts)) {
+            return parts.map((p) => {
+              if (p && typeof p === "object") {
+                return String(p.text ?? "");
+              }
+              return "";
+            });
+          }
+        }
+        return [];
+      }).join("\n");
+    }
+  }
+  if (provider === "anthropic") {
+    const messages = body.messages;
+    if (Array.isArray(messages)) {
+      return messages.map((m) => {
+        if (m && typeof m === "object") {
+          const msg = m;
+          return `${msg.role ?? "user"}: ${msg.content ?? ""}`;
+        }
+        return String(m);
+      }).join("\n");
+    }
+  }
+  return "";
+}
+function extractCompletion(provider, responseBody) {
+  if (provider === "openai" || provider === "grok") {
+    const choices = responseBody.choices;
+    if (Array.isArray(choices) && choices.length > 0) {
+      const first = choices[0];
+      if (first.message && typeof first.message === "object") {
+        return String(first.message.content ?? "");
+      }
+      if (typeof first.text === "string") return first.text;
+    }
+  }
+  if (provider === "gemini") {
+    const candidates = responseBody.candidates;
+    if (Array.isArray(candidates) && candidates.length > 0) {
+      const first = candidates[0];
+      if (first.content && typeof first.content === "object") {
+        const parts = first.content.parts;
+        if (Array.isArray(parts) && parts.length > 0) {
+          return String(parts[0].text ?? "");
+        }
+      }
+    }
+  }
+  if (provider === "anthropic") {
+    const content = responseBody.content;
+    if (Array.isArray(content) && content.length > 0) {
+      const first = content[0];
+      if (typeof first.text === "string") return first.text;
+      if (first.type === "text" && typeof first.text === "string") return first.text;
+    }
+  }
+  return "";
+}
+function cloneHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      result[key] = value.join(", ");
+    } else if (typeof value === "string") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function normalizeUpstream(provider, userBase) {
+  const base = userBase || DEFAULT_UPSTREAM[provider];
+  return base.endsWith("/") ? base.slice(0, -1) : base;
+}
+function recordStep(store, traceId, step) {
+  if (!store.has(traceId)) {
+    store.set(traceId, []);
+  }
+  store.get(traceId).push(step);
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks);
+}
+function sendUpstreamResponse(upstreamRes, res) {
+  res.statusCode = upstreamRes.status;
+  for (const [key, value] of upstreamRes.headers.entries()) {
+    res.setHeader(key, value);
+  }
+  const body = upstreamRes.body;
+  if (!body) {
+    res.end();
+    return;
+  }
+  const nodeStream = import_node_stream.Readable.fromWeb(body);
+  nodeStream.pipe(res);
+}
+async function startLLMProxy(options = {}) {
+  const port = options.port ?? DEFAULT_PORT;
+  const store = /* @__PURE__ */ new Map();
+  const upstreamOverride = options.upstream || {};
+  const server = import_node_http.default.createServer(async (req, res) => {
+    try {
+      if (!req.url || !req.method) {
+        res.statusCode = 400;
+        res.end("Bad request");
+        return;
+      }
+      const parsed = new import_node_url.URL(req.url, `http://localhost:${port}`);
+      if (req.method === "GET" && parsed.pathname.startsWith("/traces/")) {
+        const traceId2 = decodeURIComponent(parsed.pathname.replace("/traces/", ""));
+        const steps = store.get(traceId2) ?? [];
+        store.delete(traceId2);
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({ steps }));
+        return;
+      }
+      if (req.method === "GET" && parsed.pathname === "/health") {
+        res.statusCode = 200;
+        res.end("ok");
+        return;
+      }
+      const bodyBuf = await readBody(req);
+      const bodyText = bodyBuf.toString() || "{}";
+      const requestBody = (() => {
+        try {
+          return JSON.parse(bodyText);
+        } catch {
+          return {};
+        }
+      })();
+      const provider = detectProvider(parsed.pathname);
+      const traceId = req.headers[HEADER_TRACE_ID]?.toString();
+      const isStreaming = requestBody && typeof requestBody === "object" ? requestBody.stream === true : false;
+      const headers = cloneHeaders(req.headers);
+      const upstreamBase = provider ? normalizeUpstream(provider, upstreamOverride[provider]) : void 0;
+      if (!provider || !upstreamBase) {
+        const passthrough = await fetch(parsed.toString(), {
+          method: req.method,
+          headers,
+          body: bodyBuf.length > 0 ? bodyBuf : void 0
+        });
+        sendUpstreamResponse(passthrough, res);
+        return;
+      }
+      const targetUrl = `${upstreamBase}${parsed.pathname}${parsed.search}`;
+      const upstreamRes = await fetch(targetUrl, {
+        method: req.method,
+        headers,
+        body: bodyBuf.length > 0 ? bodyBuf : void 0
+      });
+      if (traceId) {
+        const model = extractModel(provider, requestBody, targetUrl);
+        const prompt = extractPrompt(provider, requestBody);
+        if (isStreaming) {
+          recordStep(store, traceId, { model, provider, prompt, completion: "(streamed)" });
+        } else {
+          try {
+            const clone = upstreamRes.clone();
+            const responseBody = await clone.json();
+            const completion = extractCompletion(provider, responseBody);
+            recordStep(store, traceId, { model, provider, prompt, completion });
+          } catch {
+            recordStep(store, traceId, { model, provider, prompt, completion: "" });
+          }
+        }
+      }
+      sendUpstreamResponse(upstreamRes, res);
+    } catch (err) {
+      res.statusCode = 500;
+      res.end(`proxy error: ${err.message}`);
+    }
+  });
+  await new Promise((resolve) => server.listen(port, resolve));
+  return {
+    url: `http://localhost:${port}`,
+    async stop() {
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+async function fetchCapturedTrace(proxyUrl, traceId) {
+  const url = `${proxyUrl.replace(/\/$/, "")}/traces/${encodeURIComponent(traceId)}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`failed to fetch trace ${traceId} from proxy: ${res.status}`);
+  }
+  const data = await res.json();
+  return data.steps || [];
+}
+
+// src/runner.ts
+var import_node_url2 = require("node:url");
+var import_node_crypto2 = require("node:crypto");
+var import_node_path = __toESM(require("node:path"), 1);
+async function runFiles(files, options = {}) {
+  const proxyOptIn = process.env.ELASTICDASH_LLM_PROXY === "1" || Boolean(process.env.ELASTICDASH_LLM_PROXY_URL);
+  const proxyPort = Number.parseInt(process.env.ELASTICDASH_LLM_PROXY_PORT || "8787", 10);
+  let proxyUrl = process.env.ELASTICDASH_LLM_PROXY_URL;
+  const proxyHandle = proxyOptIn && !proxyUrl ? await startLLMProxy({ port: proxyPort }) : null;
+  if (proxyHandle) {
+    proxyUrl = proxyHandle.url;
+  }
+  const fileResults = [];
+  for (const file of files) {
+    const result = await runFile(file, options, { proxyOptIn, proxyUrl });
+    fileResults.push(result);
+  }
+  if (proxyHandle) {
+    await proxyHandle.stop();
+  }
+  return fileResults;
+}
+async function runFile(file, options, proxyCtx) {
+  const { hooks = {} } = options;
+  clearRegistry();
+  const resolvedPath = file.startsWith("file://") ? file : (0, import_node_url2.pathToFileURL)(import_node_path.default.resolve(file)).href;
+  if (resolvedPath.endsWith(".ts") && typeof globalThis.Deno === "undefined") {
+    await import("tsx/esm");
+    await import("tsx/cjs");
+  }
+  await import(resolvedPath);
+  const registry = getRegistry();
+  const results = [];
+  let currentTestName = null;
+  let pendingUnhandled;
+  const onUnhandled = (reason) => {
+    if (!pendingUnhandled) pendingUnhandled = reason instanceof Error ? reason : new Error(String(reason));
+  };
+  process.on("unhandledRejection", onUnhandled);
+  process.on("uncaughtException", onUnhandled);
+  for (const hook of registry.beforeAllHooks) {
+    await hook();
+  }
+  for (const entry of registry.tests) {
+    const { context, finalise } = startTraceSession();
+    const traceId = proxyCtx.proxyOptIn ? (0, import_node_crypto2.randomUUID)() : null;
+    setCurrentTrace(context.trace);
+    if (traceId) {
+      process.env.ELASTICDASH_TRACE_ID = traceId;
+    }
+    if (hooks.onTestStart) {
+      await hooks.onTestStart(entry.name);
+    }
+    const startTime = Date.now();
+    let passed = false;
+    let error;
+    pendingUnhandled = void 0;
+    currentTestName = entry.name;
+    setCurrentTrace(context.trace);
+    try {
+      for (const hook of registry.beforeEachHooks) {
+        await hook();
+      }
+      await entry.fn(context);
+      passed = true;
+    } catch (err) {
+      error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      try {
+        for (const hook of registry.afterEachHooks) {
+          await hook();
+        }
+      } catch (afterErr) {
+        if (!error) {
+          error = afterErr instanceof Error ? afterErr : new Error(String(afterErr));
+          passed = false;
+        }
+      }
+      setCurrentTrace(void 0);
+      if (!error && pendingUnhandled) {
+        error = pendingUnhandled;
+        passed = false;
+      }
+      currentTestName = null;
+    }
+    const durationMs = Date.now() - startTime;
+    if (hooks.onTestFinish) {
+      await hooks.onTestFinish(entry.name, passed, durationMs, error);
+    }
+    if (hooks.onTraceComplete) {
+      await hooks.onTraceComplete(entry.name, context.trace);
+    }
+    if (traceId && proxyCtx.proxyUrl) {
+      try {
+        const captured = await fetchCapturedTrace(proxyCtx.proxyUrl, traceId);
+        for (const step of captured) {
+          context.trace.recordLLMStep(step);
+        }
+      } catch (proxyErr) {
+        console.warn("[elasticdash] Failed to fetch proxy-captured steps:", proxyErr);
+      }
+    }
+    finalise();
+    setCurrentTrace(void 0);
+    if (traceId) {
+      delete process.env.ELASTICDASH_TRACE_ID;
+    }
+    results.push({ name: entry.name, passed, durationMs, error });
+  }
+  for (const hook of registry.afterAllHooks) {
+    await hook();
+  }
+  process.off("unhandledRejection", onUnhandled);
+  process.off("uncaughtException", onUnhandled);
+  return { file, results };
+}
+
+// src/reporter.ts
+var import_chalk = __toESM(require("chalk"), 1);
+function reportResults(fileResults) {
+  let totalPassed = 0;
+  let totalFailed = 0;
+  let totalDurationMs = 0;
+  for (const fileResult of fileResults) {
+    if (fileResults.length > 1) {
+      console.log(import_chalk.default.dim(`
+${fileResult.file}`));
+    }
+    for (const result of fileResult.results) {
+      printTestResult(result);
+      totalDurationMs += result.durationMs;
+      if (result.passed) {
+        totalPassed++;
+      } else {
+        totalFailed++;
+      }
+    }
+  }
+  printSummary(totalPassed, totalFailed, totalDurationMs);
+}
+function printTestResult(result) {
+  const duration = import_chalk.default.dim(`(${formatDuration(result.durationMs)})`);
+  if (result.passed) {
+    console.log(`  ${import_chalk.default.green("\u2713")} ${result.name} ${duration}`);
+  } else {
+    console.log(`  ${import_chalk.default.red("\u2717")} ${result.name} ${duration}`);
+    if (result.error) {
+      const errorLines = formatError(result.error);
+      for (const line of errorLines) {
+        console.log(`    ${import_chalk.default.red("\u2192")} ${line}`);
+      }
+    }
+  }
+}
+function printSummary(passed, failed, totalMs) {
+  const total = passed + failed;
+  console.log("");
+  if (passed > 0) {
+    console.log(import_chalk.default.green(`${passed} passed`));
+  }
+  if (failed > 0) {
+    console.log(import_chalk.default.red(`${failed} failed`));
+  }
+  console.log(import_chalk.default.dim(`Total: ${total}`));
+  console.log(import_chalk.default.dim(`Duration: ${formatDuration(totalMs)}`));
+}
+function formatDuration(ms) {
+  if (ms >= 1e3) {
+    return `${(ms / 1e3).toFixed(1)}s`;
+  }
+  return `${ms}ms`;
+}
+function formatError(error) {
+  const lines = [];
+  if (error.message) {
+    lines.push(error.message);
+  }
+  if (error.stack) {
+    const stackLines = error.stack.split("\n").slice(1).map((l) => l.trim()).filter((l) => l.startsWith("at ")).slice(0, 3);
+    lines.push(...stackLines);
+  }
+  return lines;
+}
+
+// src/interceptors/ai-interceptor.ts
+init_context();
+init_recorder();
+init_side_effects();
+var AI_PATTERNS2 = {
+  openai: /https?:\/\/api\.openai\.com\/v1\/((chat\/)?completions|embeddings)/,
+  gemini: /https?:\/\/generativelanguage\.googleapis\.com\/.*\/models\/[^/:]+:(generateContent|streamGenerateContent)/,
+  grok: /https?:\/\/api\.x\.ai\/v1\/(chat\/)?completions/,
+  kimi: /https?:\/\/api\.moonshot\.ai\/v1\/(chat\/)?completions/
+};
+function detectProvider2(url) {
+  for (const [provider, pattern] of Object.entries(AI_PATTERNS2)) {
+    if (pattern.test(url)) return provider;
+  }
+  return null;
+}
+function extractModel2(provider, body, url) {
+  if (provider === "gemini") {
+    const match = /\/models\/([^/:]+):/.exec(url);
+    return match ? match[1] : "unknown";
+  }
+  return typeof body.model === "string" ? body.model : "unknown";
+}
+function extractPrompt2(provider, body) {
+  if (provider === "openai" || provider === "grok" || provider === "kimi") {
+    const messages = body.messages;
+    if (Array.isArray(messages)) {
+      return messages.map((m) => {
+        if (m && typeof m === "object") {
+          const msg = m;
+          return `${msg.role}: ${msg.content}`;
+        }
+        return String(m);
+      }).join("\n");
+    }
+    if (typeof body.prompt === "string") return body.prompt;
+    if (typeof body.input === "string") return body.input;
+    if (Array.isArray(body.input)) return body.input.map((v) => String(v)).join("\n");
+    return "";
+  }
+  if (provider === "gemini") {
+    const contents = body.contents;
+    if (Array.isArray(contents)) {
+      return contents.flatMap((c) => {
+        if (c && typeof c === "object") {
+          const parts = c.parts;
+          if (Array.isArray(parts)) {
+            return parts.map((p) => {
+              if (p && typeof p === "object") {
+                return String(p.text ?? "");
+              }
+              return "";
+            });
+          }
+        }
+        return [];
+      }).join("\n");
+    }
+  }
+  return "";
+}
+function extractCompletion2(provider, responseBody) {
+  if (responseBody.streamed === true && typeof responseBody.completion === "string") {
+    return responseBody.completion;
+  }
+  if (provider === "openai" || provider === "grok" || provider === "kimi") {
+    const choices = responseBody.choices;
+    if (Array.isArray(choices) && choices.length > 0) {
+      const first = choices[0];
+      if (first.message && typeof first.message === "object") {
+        return String(first.message.content ?? "");
+      }
+      if (typeof first.text === "string") return first.text;
+    }
+    const data = responseBody.data;
+    if (Array.isArray(data) && data.length > 0) {
+      const first = data[0];
+      if (Array.isArray(first?.embedding)) {
+        return `[${data.length} embedding(s), ${first.embedding.length} dimensions]`;
+      }
+    }
+  }
+  if (provider === "gemini") {
+    const candidates = responseBody.candidates;
+    if (Array.isArray(candidates) && candidates.length > 0) {
+      const first = candidates[0];
+      if (first.content && typeof first.content === "object") {
+        const parts = first.content.parts;
+        if (Array.isArray(parts) && parts.length > 0) {
+          return String(parts[0].text ?? "");
+        }
+      }
+    }
+    const embeddings = responseBody.embeddings;
+    if (Array.isArray(embeddings) && embeddings.length > 0) {
+      const first = embeddings[0];
+      if (Array.isArray(first?.values)) {
+        return `[${embeddings.length} embedding(s), ${first.values.length} dimensions]`;
+      }
+    }
+  }
+  return "";
+}
+async function bufferSSEStream(provider, stream) {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  let raw = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      raw += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const lines = raw.split("\n");
+  let completion = "";
+  if (provider === "gemini") {
+    for (const line of lines) {
+      const trimmed = line.trim().replace(/^[,\[]/, "").replace(/[,\]]$/, "");
+      if (!trimmed) continue;
+      try {
+        const obj = JSON.parse(trimmed);
+        const candidates = obj.candidates;
+        if (Array.isArray(candidates) && candidates.length > 0) {
+          const first = candidates[0];
+          if (first.content && typeof first.content === "object") {
+            const parts = first.content.parts;
+            if (Array.isArray(parts) && parts.length > 0) {
+              completion += String(parts[0].text ?? "");
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } else {
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const data = line.slice(6).trim();
+      if (data === "[DONE]") continue;
+      try {
+        const obj = JSON.parse(data);
+        const choices = obj.choices;
+        if (Array.isArray(choices) && choices.length > 0) {
+          const first = choices[0];
+          if (first.delta && typeof first.delta === "object") {
+            completion += String(first.delta.content ?? "");
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return completion;
+}
+function synthesizeCompletionJSON(provider, completion) {
+  if (provider === "gemini") {
+    return {
+      candidates: [{ content: { parts: [{ text: completion }], role: "model" }, finishReason: "STOP" }]
+    };
+  }
+  return {
+    id: "replay",
+    object: "chat.completion",
+    choices: [{ index: 0, message: { role: "assistant", content: completion }, finish_reason: "stop" }]
+  };
+}
+function synthesizeSSEStream(provider, completion) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(ctrl) {
+      if (provider === "gemini") {
+        const chunk = `[{"candidates":[{"content":{"parts":[{"text":${JSON.stringify(completion)}}],"role":"model"},"finishReason":"STOP"}]}]
+`;
+        ctrl.enqueue(encoder.encode(chunk));
+      } else {
+        const frame1 = `data: ${JSON.stringify({ id: "replay", choices: [{ delta: { content: completion }, index: 0, finish_reason: null }] })}
+
+`;
+        const frame2 = "data: [DONE]\n\n";
+        ctrl.enqueue(encoder.encode(frame1));
+        ctrl.enqueue(encoder.encode(frame2));
+      }
+      ctrl.close();
+    }
+  });
+}
+var originalFetch = null;
+function installAIInterceptor() {
+  if (originalFetch) return;
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = async function patchedFetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const provider = detectProvider2(url);
+    const traceAtCall = getCurrentTrace();
+    if (!provider || !traceAtCall) {
+      return originalFetch(input, init);
+    }
+    let model = "unknown";
+    let prompt = "";
+    let isStreaming = false;
+    try {
+      const rawBody = init?.body;
+      if (rawBody && typeof rawBody === "string") {
+        const body = JSON.parse(rawBody);
+        model = extractModel2(provider, body, url);
+        prompt = extractPrompt2(provider, body);
+        isStreaming = body.stream === true;
+      }
+    } catch {
+    }
+    const ctx = getCaptureContext();
+    if (ctx) {
+      const { recorder, replay } = ctx;
+      const id = recorder.nextId();
+      const start = rawDateNow();
+      if (replay.shouldReplay(id)) {
+        const historicalEvent = replay.getRecordedEvent(id);
+        const historicalInput = historicalEvent?.input;
+        const historicalUrl = typeof historicalInput?.url === "string" ? historicalInput.url : void 0;
+        const historicalProvider = typeof historicalInput?.provider === "string" ? historicalInput.provider : void 0;
+        const isReplayMatch = !!historicalEvent && historicalEvent.type === "ai" && historicalProvider === provider && historicalUrl === url;
+        if (isReplayMatch && historicalEvent) {
+          recorder.record(historicalEvent);
+          const historicalOutput = historicalEvent.output;
+          const completion = historicalOutput ? extractCompletion2(provider, historicalOutput) : "(replayed)";
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id });
+          if (isStreaming) {
+            return new Response(synthesizeSSEStream(provider, completion), {
+              status: 200,
+              headers: { "Content-Type": provider === "gemini" ? "application/json" : "text/event-stream" }
+            });
+          }
+          if (historicalOutput?.streamed === true) {
+            return new Response(JSON.stringify(synthesizeCompletionJSON(provider, completion)), {
+              status: 200,
+              headers: { "Content-Type": "application/json" }
+            });
+          }
+          return new Response(
+            historicalOutput != null ? JSON.stringify(historicalOutput) : null,
+            { status: 200, headers: { "Content-Type": "application/json" } }
+          );
+        }
+      }
+      const response2 = await originalFetch(input, init);
+      const durationMs = rawDateNow() - start;
+      if (isStreaming) {
+        if (response2.body) {
+          const [streamForCaller, streamForRecorder] = response2.body.tee();
+          bufferSSEStream(provider, streamForRecorder).then((completion) => {
+            const durationMs2 = rawDateNow() - start;
+            traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id });
+            recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: { streamed: true, completion }, timestamp: start, durationMs: durationMs2 });
+          }).catch(() => {
+            traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed-error)", workflowEventId: id });
+            recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: null, timestamp: start, durationMs: rawDateNow() - start });
+          });
+          return new Response(streamForCaller, {
+            status: response2.status,
+            statusText: response2.statusText,
+            headers: response2.headers
+          });
+        } else {
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed)", workflowEventId: id });
+          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: null, timestamp: start, durationMs });
+        }
+      } else {
+        try {
+          const cloned = response2.clone();
+          const responseBody = await cloned.json();
+          const completion = extractCompletion2(provider, responseBody);
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion, workflowEventId: id });
+          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: responseBody, timestamp: start, durationMs });
+        } catch {
+          traceAtCall.recordLLMStep({ model, provider, prompt, completion: "", workflowEventId: id });
+          recorder.record({ id, type: "ai", name: model, input: { url, provider, model, prompt }, output: null, timestamp: start, durationMs });
+        }
+      }
+      return response2;
+    }
+    const response = await originalFetch(input, init);
+    if (isStreaming && response.body) {
+      const [streamForCaller, streamForRecorder] = response.body.tee();
+      bufferSSEStream(provider, streamForRecorder).then((completion) => {
+        traceAtCall.recordLLMStep({ model, provider, prompt, completion });
+      }).catch(() => {
+        traceAtCall.recordLLMStep({ model, provider, prompt, completion: "(streamed-error)" });
+      });
+      return new Response(streamForCaller, { status: response.status, statusText: response.statusText, headers: response.headers });
+    } else if (!isStreaming) {
+      try {
+        const cloned = response.clone();
+        const responseBody = await cloned.json();
+        const completion = extractCompletion2(provider, responseBody);
+        traceAtCall.recordLLMStep({ model, provider, prompt, completion });
+      } catch {
+        traceAtCall.recordLLMStep({ model, provider, prompt, completion: "" });
+      }
+    }
+    return response;
+  };
+}
+function uninstallAIInterceptor() {
+  if (originalFetch) {
+    globalThis.fetch = originalFetch;
+    originalFetch = null;
+  }
+}
+
+// src/index.ts
+init_tracing();
+
+// src/internals/conditional-recorder.ts
+var isWorkerContext = () => {
+  if (typeof globalThis === "undefined") {
+    return false;
+  }
+  return globalThis.__ELASTICDASH_WORKER__ === true;
+};
+var recordToolCallFn = null;
+var getRecordToolCall = async () => {
+  if (!isWorkerContext()) {
+    return null;
+  }
+  if (recordToolCallFn !== null) {
+    return recordToolCallFn;
+  }
+  try {
+    const { recordToolCall: recordToolCall2 } = await Promise.resolve().then(() => (init_tracing(), tracing_exports));
+    recordToolCallFn = recordToolCall2;
+    return recordToolCallFn;
+  } catch (err) {
+    console.warn("Failed to load recordToolCall from tracing module:", err);
+    return null;
+  }
+};
+var safeRecordToolCall = async (name, input, output) => {
+  const recorder = await getRecordToolCall();
+  if (recorder) {
+    recorder(name, input, output);
+  }
+};
+var isWorker = () => {
+  return isWorkerContext();
+};
+
+// src/index.ts
+init_recorder();
+
+// src/capture/replay.ts
+var ReplayController = class {
+  constructor(replayMode, checkpoint, history) {
+    this.replayMode = replayMode;
+    this.checkpoint = checkpoint;
+    this.history = history;
+    this.historyMap = new Map(history.map((e) => [e.id, e]));
+    this.sideEffectMap = new Map(
+      history.filter((e) => e.type === "side_effect").map((e) => [e.id, e])
+    );
+  }
+  historyMap;
+  /** Side effects keyed by their assigned sideEffectId, independent of main event IDs */
+  sideEffectMap;
+  shouldReplay(eventId) {
+    return this.replayMode && eventId <= this.checkpoint;
+  }
+  getRecordedEvent(eventId) {
+    return this.historyMap.get(eventId);
+  }
+  getRecordedResult(eventId) {
+    return this.historyMap.get(eventId)?.output;
+  }
+  /** Returns true if the side effect with this sideEffectId has a recorded value to replay */
+  shouldReplaySideEffect(n) {
+    return this.replayMode && this.sideEffectMap.has(n);
+  }
+  getSideEffectResult(n) {
+    return this.sideEffectMap.get(n)?.output;
+  }
+  getRecordedSideEffectEvent(n) {
+    return this.sideEffectMap.get(n);
+  }
+  shouldReplaySideEffectOfType(n, expectedName) {
+    if (!this.replayMode) return false;
+    const event = this.sideEffectMap.get(n);
+    return !!event && event.type === "side_effect" && event.name === expectedName;
+  }
+  getSideEffectResultOfType(n, expectedName) {
+    const event = this.sideEffectMap.get(n);
+    if (!event || event.type !== "side_effect" || event.name !== expectedName) return void 0;
+    return event.output;
+  }
+};
+
+// src/interceptors/tool.ts
+init_recorder();
+init_context();
+init_side_effects();
+var TOOL_WRAPPER_ACTIVE_KEY2 = "__elasticdash_tool_wrapper_active__";
+function toTraceArgs(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  if (input === void 0) return void 0;
+  return { value: input };
+}
+function isReadableStream(v) {
+  return typeof v === "object" && v !== null && typeof v.getReader === "function" && typeof v.tee === "function";
+}
+function isAsyncIterable(v) {
+  return typeof v === "object" && v !== null && Symbol.asyncIterator in v;
+}
+async function bufferReadableStream(stream) {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  let raw = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      raw += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return raw;
+}
+function reconstructStream(raw) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(encoder.encode(raw));
+      ctrl.close();
+    }
+  });
+}
+function wrapAsyncIterable(source, onComplete) {
+  return {
+    [Symbol.asyncIterator]() {
+      const iter = source[Symbol.asyncIterator]();
+      const collected = [];
+      return {
+        async next() {
+          const result = await iter.next();
+          if (!result.done) {
+            collected.push(result.value);
+          } else {
+            onComplete(collected);
+          }
+          return result;
+        },
+        async return(value) {
+          onComplete(collected);
+          return iter.return ? iter.return(value) : { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+}
+function wrapTool(name, fn) {
+  return async (...args) => {
+    const ctx = getCaptureContext();
+    if (!ctx) return fn(...args);
+    const trace = getCurrentTrace();
+    const { recorder, replay } = ctx;
+    const id = recorder.nextId();
+    const input = args.length === 1 ? args[0] : args;
+    if (replay.shouldReplay(id)) {
+      const historical = replay.getRecordedEvent(id);
+      if (historical) recorder.record(historical);
+      if (historical?.streamed === true) {
+        const raw = typeof historical.streamRaw === "string" ? historical.streamRaw : "";
+        const stream = reconstructStream(raw);
+        if (trace && typeof trace.recordToolCall === "function") {
+          trace.recordToolCall({ name, args: toTraceArgs(input), result: stream, workflowEventId: id });
+        }
+        return stream;
+      }
+      const replayed = replay.getRecordedResult(id);
+      if (trace && typeof trace.recordToolCall === "function") {
+        trace.recordToolCall({ name, args: toTraceArgs(input), result: replayed, workflowEventId: id });
+      }
+      return replayed;
+    }
+    const g3 = globalThis;
+    const prev = g3[TOOL_WRAPPER_ACTIVE_KEY2];
+    g3[TOOL_WRAPPER_ACTIVE_KEY2] = true;
+    const start = rawDateNow();
+    try {
+      const output = await fn(...args);
+      if (isReadableStream(output)) {
+        const [streamForCaller, streamForRecorder] = output.tee();
+        bufferReadableStream(streamForRecorder).then((rawText) => {
+          recorder.record({ id, type: "tool", name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs: rawDateNow() - start });
+        }).catch(() => {
+          recorder.record({ id, type: "tool", name, input, output: null, streamed: true, streamRaw: "", timestamp: start, durationMs: rawDateNow() - start });
+        });
+        const result = streamForCaller;
+        if (trace && typeof trace.recordToolCall === "function") {
+          trace.recordToolCall({ name, args: toTraceArgs(input), result, workflowEventId: id });
+        }
+        return result;
+      }
+      if (isAsyncIterable(output)) {
+        const wrapped = wrapAsyncIterable(output, (chunks) => {
+          const rawText = chunks.map((c) => typeof c === "string" ? c : JSON.stringify(c)).join("");
+          recorder.record({ id, type: "tool", name, input, output: null, streamed: true, streamRaw: rawText, timestamp: start, durationMs: rawDateNow() - start });
+        });
+        if (trace && typeof trace.recordToolCall === "function") {
+          trace.recordToolCall({ name, args: toTraceArgs(input), result: wrapped, workflowEventId: id });
+        }
+        return wrapped;
+      }
+      recorder.record({
+        id,
+        type: "tool",
+        name,
+        input,
+        output,
+        timestamp: start,
+        durationMs: rawDateNow() - start
+      });
+      if (trace && typeof trace.recordToolCall === "function") {
+        trace.recordToolCall({ name, args: toTraceArgs(input), result: output, workflowEventId: id });
+      }
+      return output;
+    } catch (e) {
+      recorder.record({
+        id,
+        type: "tool",
+        name,
+        input,
+        output: { error: String(e) },
+        timestamp: start,
+        durationMs: rawDateNow() - start
+      });
+      if (trace && typeof trace.recordToolCall === "function") {
+        trace.recordToolCall({ name, args: toTraceArgs(input), result: { error: String(e) }, workflowEventId: id });
+      }
+      throw e;
+    } finally {
+      if (prev === void 0) delete g3[TOOL_WRAPPER_ACTIVE_KEY2];
+      else g3[TOOL_WRAPPER_ACTIVE_KEY2] = prev;
+    }
+  };
+}
+
+// src/interceptors/workflow-ai.ts
+init_recorder();
+function wrapAI(modelName, callFn) {
+  return async (...args) => {
+    const ctx = getCaptureContext();
+    if (!ctx) return callFn(...args);
+    const { recorder, replay } = ctx;
+    const id = recorder.nextId();
+    if (replay.shouldReplay(id)) {
+      return replay.getRecordedResult(id);
+    }
+    const start = Date.now();
+    const output = await callFn(...args);
+    recorder.record({
+      id,
+      type: "ai",
+      name: modelName,
+      input: args.length === 1 ? args[0] : args,
+      output,
+      timestamp: start,
+      durationMs: Date.now() - start
+    });
+    return output;
+  };
+}
+
+// src/interceptors/db.ts
+init_recorder();
+function wrapDB(client, methodNames, label) {
+  const prefix = label ?? (client.constructor?.name ?? "db");
+  for (const method of methodNames) {
+    const original = client[method];
+    if (typeof original !== "function") continue;
+    client[method] = async (...args) => {
+      const ctx = getCaptureContext();
+      if (!ctx) return original.apply(client, args);
+      const { recorder, replay } = ctx;
+      const id = recorder.nextId();
+      const name = `${prefix}.${method}`;
+      if (replay.shouldReplay(id)) {
+        return replay.getRecordedResult(id);
+      }
+      const start = Date.now();
+      const output = await original.apply(client, args);
+      recorder.record({
+        id,
+        type: "db",
+        name,
+        input: args.length === 1 ? args[0] : args,
+        output,
+        timestamp: start,
+        durationMs: Date.now() - start
+      });
+      return output;
+    };
+  }
+  return client;
+}
+function wrapPgClient(client) {
+  return wrapDB(client, ["query"], "pg");
+}
+function wrapKnex(knex) {
+  return wrapDB(knex, ["raw"], "knex");
+}
+function wrapMongoCollection(collection) {
+  return wrapDB(
+    collection,
+    ["find", "findOne", "insertOne", "updateOne", "deleteOne"],
+    "mongo"
+  );
+}
+function wrapRedisClient(client) {
+  return wrapDB(
+    client,
+    ["get", "set", "del", "hget", "hset"],
+    "redis"
+  );
+}
+
+// src/interceptors/db-auto.ts
+init_recorder();
+var appliedPatches = [];
+function wrapProtoMethod(proto, method, eventName) {
+  const p = proto;
+  if (typeof p[method] !== "function") return;
+  const original = p[method];
+  appliedPatches.push({ proto: p, method, original });
+  p[method] = function(...args) {
+    if (args.length > 0 && typeof args[args.length - 1] === "function") {
+      return original.apply(this, args);
+    }
+    const ctx = getCaptureContext();
+    if (!ctx) return original.apply(this, args);
+    const { recorder, replay } = ctx;
+    const id = recorder.nextId();
+    if (replay.shouldReplay(id)) {
+      const historicalEvent = replay.getRecordedEvent(id);
+      if (historicalEvent) recorder.record(historicalEvent);
+      return Promise.resolve(replay.getRecordedResult(id));
+    }
+    const start = Date.now();
+    const input = args.length === 1 ? args[0] : args;
+    let result;
+    try {
+      result = original.apply(this, args);
+    } catch (err) {
+      recorder.record({
+        id,
+        type: "db",
+        name: eventName,
+        input,
+        output: { error: String(err) },
+        timestamp: start,
+        durationMs: Date.now() - start
+      });
+      throw err;
+    }
+    if (result != null && typeof result.then === "function") {
+      return result.then((output) => {
+        recorder.record({
+          id,
+          type: "db",
+          name: eventName,
+          input,
+          output,
+          timestamp: start,
+          durationMs: Date.now() - start
+        });
+        return output;
+      }).catch((err) => {
+        recorder.record({
+          id,
+          type: "db",
+          name: eventName,
+          input,
+          output: { error: String(err) },
+          timestamp: start,
+          durationMs: Date.now() - start
+        });
+        throw err;
+      });
+    }
+    recorder.record({
+      id,
+      type: "db",
+      name: eventName,
+      input,
+      output: result,
+      timestamp: start,
+      durationMs: Date.now() - start
+    });
+    return result;
+  };
+}
+async function tryPatchPg() {
+  const pgMod = await import("pg");
+  const pg = pgMod.default ?? pgMod;
+  const Client = pg.Client;
+  if (Client?.prototype) {
+    wrapProtoMethod(Client.prototype, "query", "pg.query");
+  }
+}
+async function tryPatchMysql2() {
+  const mod = await import("mysql2/promise");
+  const mysql2 = mod.default ?? mod;
+  const Connection = mysql2.Connection;
+  if (Connection?.prototype) {
+    wrapProtoMethod(Connection.prototype, "query", "mysql2.query");
+    wrapProtoMethod(Connection.prototype, "execute", "mysql2.execute");
+  }
+}
+async function tryPatchMongodb() {
+  const mongMod = await import("mongodb");
+  const Collection = mongMod.Collection ?? mongMod.default?.Collection;
+  if (Collection?.prototype) {
+    for (const method of ["find", "findOne", "insertOne", "updateOne", "deleteOne", "aggregate"]) {
+      wrapProtoMethod(Collection.prototype, method, `mongodb.${method}`);
+    }
+  }
+}
+async function tryPatchIoredis() {
+  const mod = await import("ioredis");
+  const Redis = mod.default ?? mod;
+  if (Redis?.prototype) {
+    wrapProtoMethod(Redis.prototype, "call", "redis.call");
+  }
+}
+async function installDBAutoInterceptor() {
+  await Promise.allSettled([
+    tryPatchPg(),
+    tryPatchMysql2(),
+    tryPatchMongodb(),
+    tryPatchIoredis()
+  ]);
+}
+function uninstallDBAutoInterceptor() {
+  for (const { proto, method, original } of appliedPatches) {
+    proto[method] = original;
+  }
+  appliedPatches.length = 0;
+}
+
+// src/interceptors/http.ts
+init_recorder();
+var AI_URL_PATTERNS = [
+  /https?:\/\/api\.openai\.com\/v1\/((chat\/)?completions|embeddings)/,
+  /https?:\/\/generativelanguage\.googleapis\.com\/.*\/models\/[^/:]+:(generateContent|streamGenerateContent)/,
+  /https?:\/\/api\.x\.ai\/v1\/(chat\/)?completions/,
+  /https?:\/\/api\.moonshot\.ai\/v1\/(chat\/)?completions/
+];
+function isAIProviderUrl(url) {
+  return AI_URL_PATTERNS.some((p) => p.test(url));
+}
+function parseQuery(url) {
+  try {
+    const { searchParams } = new URL(url);
+    if (searchParams.size === 0) return void 0;
+    return Object.fromEntries(searchParams.entries());
+  } catch {
+    const qIdx = url.indexOf("?");
+    if (qIdx === -1) return void 0;
+    try {
+      const params = new URLSearchParams(url.slice(qIdx + 1));
+      if (![...params].length) return void 0;
+      return Object.fromEntries(params.entries());
+    } catch {
+      return void 0;
+    }
+  }
+}
+function parseBody(body) {
+  if (body == null) return void 0;
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  if (body instanceof URLSearchParams) {
+    return Object.fromEntries(body.entries());
+  }
+  return "[binary]";
+}
+function normalizeHeaders(headers) {
+  if (!headers) return void 0;
+  if (headers instanceof Headers) {
+    const obj = {};
+    headers.forEach((v, k) => {
+      obj[k] = v;
+    });
+    return obj;
+  }
+  if (Array.isArray(headers)) return Object.fromEntries(headers);
+  return headers;
+}
+function pickReplayResponseHeaders(headers) {
+  if (!headers) return { "Content-Type": "application/json" };
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "string") out[key] = value;
+  }
+  if (!out["Content-Type"]) out["Content-Type"] = "application/json";
+  return out;
+}
+function isStreamingContentType(headers) {
+  const ct = headers.get("content-type") ?? "";
+  return ct.includes("text/event-stream") || ct.includes("application/x-ndjson") || ct.includes("application/stream+json") || ct.includes("application/jsonl");
+}
+async function bufferStream(stream) {
+  const decoder = new TextDecoder();
+  const reader = stream.getReader();
+  let raw = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      raw += decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return raw;
+}
+function reconstructStream2(raw) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(encoder.encode(raw));
+      ctrl.close();
+    }
+  });
+}
+var originalFetch2;
+function interceptFetch() {
+  if (originalFetch2) return;
+  originalFetch2 = globalThis.fetch;
+  globalThis.fetch = async (input, init) => {
+    const ctx = getCaptureContext();
+    if (!ctx) return originalFetch2(input, init);
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const rawHeaders = init?.headers ?? (input instanceof Request ? input.headers : void 0);
+    const rawBody = init?.body ?? (input instanceof Request ? input.body : void 0);
+    if (isAIProviderUrl(url)) {
+      return originalFetch2(input, init);
+    }
+    const { recorder, replay } = ctx;
+    const id = recorder.nextId();
+    if (replay.shouldReplay(id)) {
+      const historicalEvent = replay.getRecordedEvent(id);
+      const historicalInput = historicalEvent?.input;
+      const historicalMethod = typeof historicalInput?.method === "string" ? historicalInput.method.toUpperCase() : "GET";
+      const historicalUrl = typeof historicalInput?.url === "string" ? historicalInput.url : void 0;
+      const isReplayMatch = !!historicalEvent && historicalEvent.type === "http" && historicalEvent.name === "fetch" && historicalMethod === method && historicalUrl === url;
+      if (isReplayMatch && historicalEvent) {
+        recorder.record(historicalEvent);
+        const replayMeta = historicalInput?.__elasticdashResponse ?? {};
+        const replayStatus = typeof replayMeta.status === "number" ? replayMeta.status : 200;
+        const replayStatusText = typeof replayMeta.statusText === "string" ? replayMeta.statusText : "";
+        const replayHeaders = pickReplayResponseHeaders(
+          replayMeta.headers && typeof replayMeta.headers === "object" ? replayMeta.headers : void 0
+        );
+        if (historicalEvent.streamed === true) {
+          const raw = typeof historicalEvent.streamRaw === "string" ? historicalEvent.streamRaw : "";
+          return new Response(reconstructStream2(raw), {
+            status: replayStatus,
+            statusText: replayStatusText,
+            headers: replayHeaders
+          });
+        }
+        const historicalOutput = replay.getRecordedResult(id);
+        const body2 = historicalOutput != null ? JSON.stringify(historicalOutput) : null;
+        return new Response(body2, {
+          status: replayStatus,
+          statusText: replayStatusText,
+          headers: replayHeaders
+        });
+      }
+    }
+    const query = parseQuery(url);
+    const body = parseBody(rawBody);
+    const headers = normalizeHeaders(rawHeaders);
+    const start = Date.now();
+    const res = await originalFetch2(input, init);
+    const responseHeadersObj = {};
+    res.headers.forEach((v, k) => {
+      responseHeadersObj[k] = v;
+    });
+    const elasticdashResponse = {
+      status: res.status,
+      statusText: res.statusText,
+      headers: responseHeadersObj,
+      url: res.url
+    };
+    const baseInput = {
+      url,
+      method,
+      ...query ? { query } : {},
+      ...body !== void 0 ? { body } : {},
+      ...headers && Object.keys(headers).length > 0 ? { headers } : {},
+      __elasticdashResponse: elasticdashResponse
+    };
+    if (isStreamingContentType(res.headers) && res.body) {
+      const [streamForCaller, streamForRecorder] = res.body.tee();
+      bufferStream(streamForRecorder).then((rawText) => {
+        recorder.record({
+          id,
+          type: "http",
+          name: "fetch",
+          input: baseInput,
+          output: null,
+          streamed: true,
+          streamRaw: rawText,
+          timestamp: start,
+          durationMs: Date.now() - start
+        });
+      }).catch(() => {
+        recorder.record({
+          id,
+          type: "http",
+          name: "fetch",
+          input: baseInput,
+          output: null,
+          streamed: true,
+          streamRaw: "",
+          timestamp: start,
+          durationMs: Date.now() - start
+        });
+      });
+      return new Response(streamForCaller, {
+        status: res.status,
+        statusText: res.statusText,
+        headers: res.headers
+      });
+    }
+    let output = null;
+    try {
+      output = await res.clone().json();
+    } catch {
+    }
+    recorder.record({
+      id,
+      type: "http",
+      name: "fetch",
+      input: baseInput,
+      output,
+      timestamp: start,
+      durationMs: Date.now() - start
+    });
+    return res;
+  };
+}
+function restoreFetch() {
+  if (originalFetch2) {
+    globalThis.fetch = originalFetch2;
+    originalFetch2 = void 0;
+  }
+}
+
+// src/index.ts
+init_side_effects();
+
+// src/workflow-runner.ts
+init_recorder();
+init_side_effects();
+async function runWorkflow(workflowFn, options = {}) {
+  const {
+    replayMode = false,
+    checkpoint = 0,
+    history = [],
+    interceptHttp = true,
+    interceptSideEffects = true
+  } = options;
+  const recorder = new TraceRecorder();
+  const replay = new ReplayController(replayMode, checkpoint, history);
+  setCaptureContext({ recorder, replay });
+  if (interceptHttp) interceptFetch();
+  if (interceptSideEffects) {
+    interceptRandom();
+    interceptDateNow();
+  }
+  try {
+    const result = await workflowFn();
+    return { result, trace: recorder.toTrace() };
+  } finally {
+    if (interceptHttp) restoreFetch();
+    if (interceptSideEffects) {
+      restoreRandom();
+      restoreDateNow();
+    }
+    setCaptureContext(void 0);
+  }
+}
+
+// src/core/agent-state.ts
+function serializeAgentState(plan, trace) {
+  const resumeFromTaskIndex = plan.tasks.findIndex(
+    (t) => t.status !== "completed"
+  );
+  return {
+    plan: JSON.parse(JSON.stringify(plan)),
+    trace: JSON.parse(JSON.stringify(trace)),
+    resumeFromTaskIndex: resumeFromTaskIndex === -1 ? plan.tasks.length : resumeFromTaskIndex
+  };
+}
+function deserializeAgentState(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error("AgentState must be a non-null object");
+  }
+  const obj = raw;
+  if (!obj.plan || typeof obj.plan !== "object") {
+    throw new Error("AgentState.plan is required");
+  }
+  const plan = obj.plan;
+  if (!Array.isArray(plan.tasks)) {
+    throw new Error("AgentState.plan.tasks must be an array");
+  }
+  if (typeof plan.id !== "string") {
+    throw new Error("AgentState.plan.id must be a string");
+  }
+  const trace = Array.isArray(obj.trace) ? obj.trace : [];
+  const resumeFromTaskIndex = typeof obj.resumeFromTaskIndex === "number" ? obj.resumeFromTaskIndex : 0;
+  for (let i = 0; i < resumeFromTaskIndex; i++) {
+    const task = plan.tasks[i];
+    if (!task) continue;
+    if (task.status !== "completed") {
+      throw new Error(
+        `Task at index ${i} (id="${task.id}") has status "${task.status}" but must be "completed" before resumeFromTaskIndex=${resumeFromTaskIndex}`
+      );
+    }
+    if (task.output === void 0) {
+      throw new Error(
+        `Task at index ${i} (id="${task.id}") is completed but has no output. Cannot resume safely.`
+      );
+    }
+  }
+  return { plan, trace, resumeFromTaskIndex };
+}
+function extractTaskOutputs(plan) {
+  const outputs = {};
+  for (const task of plan.tasks) {
+    if (task.status === "completed" && task.output !== void 0) {
+      outputs[task.id] = task.output;
+    }
+  }
+  return outputs;
+}
+function resolveTaskInput(input, previousOutputs) {
+  if (input === null || input === void 0) return input;
+  if (Array.isArray(input)) {
+    return input.map((item) => resolveTaskInput(item, previousOutputs));
+  }
+  if (typeof input === "object") {
+    const obj = input;
+    if (typeof obj["$ref"] === "string") {
+      return resolveRef(obj["$ref"], previousOutputs);
+    }
+    const resolved = {};
+    for (const [k, v] of Object.entries(obj)) {
+      resolved[k] = resolveTaskInput(v, previousOutputs);
+    }
+    return resolved;
+  }
+  return input;
+}
+function resolveRef(ref, previousOutputs) {
+  const parts = ref.split(".");
+  const taskId = parts[0];
+  const pathParts = parts.slice(1);
+  let current = previousOutputs[taskId];
+  for (const part of pathParts) {
+    if (part === "output") continue;
+    if (current === null || current === void 0) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReplayController,
+  TraceRecorder,
+  afterAll,
+  afterEach,
+  aiTest,
+  beforeAll,
+  beforeEach,
+  clearRegistry,
+  createTraceHandle,
+  deserializeAgentState,
+  expect,
+  extractTaskOutputs,
+  fetchCapturedTrace,
+  getCaptureContext,
+  getCurrentTrace,
+  getRegistry,
+  installAIInterceptor,
+  installDBAutoInterceptor,
+  interceptDateNow,
+  interceptFetch,
+  interceptRandom,
+  isWorker,
+  recordToolCall,
+  registerMatchers,
+  reportResults,
+  resolveTaskInput,
+  restoreDateNow,
+  restoreFetch,
+  restoreRandom,
+  runFiles,
+  runWorkflow,
+  safeRecordToolCall,
+  serializeAgentState,
+  setCaptureContext,
+  setCurrentTrace,
+  startLLMProxy,
+  startTraceSession,
+  uninstallAIInterceptor,
+  uninstallDBAutoInterceptor,
+  wrapAI,
+  wrapDB,
+  wrapKnex,
+  wrapMongoCollection,
+  wrapPgClient,
+  wrapRedisClient,
+  wrapTool
+});