@attest-ai/core 0.4.1 → 0.5.0

package/dist/esm/index.js

@@ -0,0 +1,2385 @@
+// src/proto/constants.ts
+var STEP_LLM_CALL = "llm_call";
+var STEP_TOOL_CALL = "tool_call";
+var STEP_RETRIEVAL = "retrieval";
+var STEP_AGENT_CALL = "agent_call";
+var STATUS_PASS = "pass";
+var STATUS_SOFT_FAIL = "soft_fail";
+var STATUS_HARD_FAIL = "hard_fail";
+var TYPE_SCHEMA = "schema";
+var TYPE_CONSTRAINT = "constraint";
+var TYPE_TRACE = "trace";
+var TYPE_CONTENT = "content";
+var TYPE_EMBEDDING = "embedding";
+var TYPE_LLM_JUDGE = "llm_judge";
+var TYPE_TRACE_TREE = "trace_tree";
+var TYPE_PLUGIN = "plugin";
+var ERR_INVALID_TRACE = 1001;
+var ERR_ASSERTION_ERROR = 1002;
+var ERR_PROVIDER_ERROR = 2001;
+var ERR_ENGINE_ERROR = 3001;
+var ERR_TIMEOUT = 3002;
+var ERR_SESSION_ERROR = 3003;
+
+// src/proto/types.ts
+function traceId(id) {
+  return id;
+}
+function assertionId(id) {
+  return id;
+}
+function agentId(id) {
+  return id;
+}
+
+// src/proto/errors.ts
+var ProtocolError = class extends Error {
+  code;
+  errorMessage;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "ProtocolError";
+    this.code = code;
+    this.errorMessage = message;
+    this.data = data;
+  }
+};
+var EngineTimeoutError = class extends Error {
+  method;
+  timeoutMs;
+  constructor(method, timeoutMs) {
+    super(
+      `Engine request '${method}' timed out after ${timeoutMs}ms. Set ATTEST_ENGINE_TIMEOUT to increase the limit.`
+    );
+    this.name = "EngineTimeoutError";
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+  }
+};
+
+// src/proto/codec.ts
+function encodeRequest(id, method, params) {
+  const msg = {
+    jsonrpc: "2.0",
+    id,
+    method,
+    params
+  };
+  return JSON.stringify(msg) + "\n";
+}
+function decodeResponse(line) {
+  const text = line.trim();
+  if (!text) {
+    throw new Error("empty response line");
+  }
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (e) {
+    throw new Error(`malformed JSON response: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new Error(`expected JSON object, got ${Array.isArray(data) ? "array" : typeof data}`);
+  }
+  const obj = data;
+  if (obj.jsonrpc !== "2.0") {
+    throw new Error(`invalid jsonrpc version: ${String(obj.jsonrpc)}`);
+  }
+  if (obj.error != null) {
+    const err = obj.error;
+    let errorData;
+    if (err.data != null) {
+      const raw = err.data;
+      errorData = {
+        error_type: raw.error_type ?? "",
+        retryable: raw.retryable ?? false,
+        detail: raw.detail ?? ""
+      };
+    }
+    throw new ProtocolError(
+      err.code ?? -1,
+      err.message ?? "unknown error",
+      errorData
+    );
+  }
+  return obj;
+}
+function extractResult(response) {
+  if (response.result === void 0) {
+    throw new Error("response missing 'result' field");
+  }
+  return response.result;
+}
+function extractId(response) {
+  if (response.id === void 0) {
+    throw new Error("response missing 'id' field");
+  }
+  return Number(response.id);
+}
+
+// src/version.ts
+var VERSION = "0.5.0";
+var ENGINE_VERSION = "0.5.0";
+
+// src/engine-manager.ts
+import { spawn, execSync } from "child_process";
+import { createInterface } from "readline";
+import { existsSync as existsSync2, accessSync, constants as fsConstants } from "fs";
+import { resolve, join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/engine-downloader.ts
+import * as https from "https";
+import * as http from "http";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var RELEASE_BASE = `https://github.com/attest-framework/attest/releases/download/v${ENGINE_VERSION}`;
+var CHECKSUMS_URL = `${RELEASE_BASE}/checksums-sha256.txt`;
+var MAX_REDIRECTS = 5;
+function attestBinDir() {
+  const dir = path.join(os.homedir(), ".attest", "bin");
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function platformKey() {
+  const platform2 = os.platform();
+  const arch2 = os.arch();
+  const mapping = {
+    darwin: { arm64: "darwin-arm64", x64: "darwin-amd64" },
+    linux: { arm64: "linux-arm64", x64: "linux-amd64" },
+    win32: { x64: "windows-amd64", arm64: "windows-arm64" }
+  };
+  const osMap = mapping[platform2];
+  if (!osMap) {
+    throw new Error(
+      `Unsupported platform: ${platform2}. Supported: darwin, linux, win32.`
+    );
+  }
+  const key = osMap[arch2];
+  if (!key) {
+    throw new Error(
+      `Unsupported architecture '${arch2}' on platform '${platform2}'. Supported architectures: ${Object.keys(osMap).join(", ")}.`
+    );
+  }
+  return key;
+}
+function binaryFilename() {
+  return os.platform() === "win32" ? "attest-engine.exe" : "attest-engine";
+}
+function cachedEnginePath() {
+  const dir = path.join(os.homedir(), ".attest", "bin");
+  const binPath = path.join(dir, binaryFilename());
+  const versionFile = path.join(dir, ".engine-version");
+  if (!fs.existsSync(binPath)) {
+    return null;
+  }
+  if (!fs.existsSync(versionFile)) {
+    return null;
+  }
+  const cachedVersion = fs.readFileSync(versionFile, "utf-8").trim();
+  if (cachedVersion !== ENGINE_VERSION) {
+    return null;
+  }
+  return binPath;
+}
+function parseChecksums(text) {
+  const checksums = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const match = trimmed.match(/^([a-f0-9]{64})\s+(.+)$/);
+    if (match) {
+      checksums.set(match[2], match[1]);
+    }
+  }
+  return checksums;
+}
+function httpsGet(url, redirectCount = 0) {
+  if (redirectCount > MAX_REDIRECTS) {
+    return Promise.reject(
+      new Error(`Too many redirects (>${MAX_REDIRECTS}) following ${url}`)
+    );
+  }
+  return new Promise((resolve2, reject) => {
+    const client = url.startsWith("https:") ? https : http;
+    client.get(url, (res) => {
+      const status = res.statusCode ?? 0;
+      if (status === 301 || status === 302) {
+        const location = res.headers.location;
+        if (!location) {
+          reject(new Error(`Redirect ${status} without Location header from ${url}`));
+          return;
+        }
+        res.resume();
+        resolve2(httpsGet(location, redirectCount + 1));
+        return;
+      }
+      if (status < 200 || status >= 300) {
+        res.resume();
+        reject(new Error(`HTTP ${status} fetching ${url}`));
+        return;
+      }
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve2(Buffer.concat(chunks)));
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+async function downloadEngine() {
+  const key = platformKey();
+  const filename = `attest-engine-${key}`;
+  const binaryUrl = `${RELEASE_BASE}/${filename}`;
+  process.stderr.write(`[attest] Downloading engine v${ENGINE_VERSION} for ${key}...
+`);
+  process.stderr.write(`[attest] Fetching checksums...
+`);
+  const checksumsText = (await httpsGet(CHECKSUMS_URL)).toString("utf-8");
+  const checksums = parseChecksums(checksumsText);
+  const expectedHash = checksums.get(filename);
+  if (!expectedHash) {
+    throw new Error(
+      `No checksum found for '${filename}' in checksums-sha256.txt. Available files: ${[...checksums.keys()].join(", ")}`
+    );
+  }
+  process.stderr.write(`[attest] Downloading ${binaryUrl}...
+`);
+  const data = await httpsGet(binaryUrl);
+  const actualHash = crypto.createHash("sha256").update(data).digest("hex");
+  if (actualHash !== expectedHash) {
+    throw new Error(
+      `SHA256 mismatch for ${filename}. Expected: ${expectedHash}, got: ${actualHash}. The download may be corrupted. Delete ~/.attest/bin/ and retry.`
+    );
+  }
+  process.stderr.write(`[attest] Checksum verified.
+`);
+  const dir = attestBinDir();
+  const destFilename = binaryFilename();
+  const destPath = path.join(dir, destFilename);
+  const tmpPath = path.join(dir, `.${destFilename}.tmp.${process.pid}`);
+  fs.writeFileSync(tmpPath, data);
+  fs.chmodSync(tmpPath, 493);
+  fs.renameSync(tmpPath, destPath);
+  fs.writeFileSync(path.join(dir, ".engine-version"), ENGINE_VERSION);
+  process.stderr.write(`[attest] Engine installed at ${destPath}
+`);
+  return destPath;
+}
+
+// src/engine-manager.ts
+var ENGINE_BINARY_NAME = "attest-engine";
+async function findEngineBinary() {
+  const envPath = process.env["ATTEST_ENGINE_PATH"];
+  if (envPath) {
+    if (!existsSync2(envPath)) {
+      throw new Error(
+        `ATTEST_ENGINE_PATH is set to '${envPath}' but the file does not exist.`
+      );
+    }
+    return envPath;
+  }
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const found = execSync(`${cmd} ${ENGINE_BINARY_NAME}`, { encoding: "utf-8" }).trim();
+    if (found) return found;
+  } catch {
+  }
+  const cached = cachedEnginePath();
+  if (cached) return cached;
+  const candidates = [
+    join2(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..", "..", "bin", ENGINE_BINARY_NAME),
+    join2(process.cwd(), "bin", ENGINE_BINARY_NAME)
+  ];
+  for (const candidate of candidates) {
+    const resolved = resolve(candidate);
+    try {
+      accessSync(resolved, fsConstants.X_OK);
+      if (existsSync2(resolved)) return resolved;
+    } catch {
+    }
+  }
+  const noDownload = process.env["ATTEST_ENGINE_NO_DOWNLOAD"];
+  if (noDownload === "1" || noDownload === "true" || noDownload === "yes") {
+    throw new Error(
+      `Cannot find '${ENGINE_BINARY_NAME}' binary and auto-download is disabled (ATTEST_ENGINE_NO_DOWNLOAD is set). Install the engine manually:
+  1. Download from https://github.com/attest-framework/attest/releases
+  2. Place the binary on your PATH or set ATTEST_ENGINE_PATH`
+    );
+  }
+  return downloadEngine();
+}
+var EngineManager = class {
+  enginePath;
+  logLevel;
+  process = null;
+  reader = null;
+  initialized = false;
+  requestId = 0;
+  initResult = null;
+  constructor(options) {
+    this.enginePath = options?.enginePath ?? "";
+    this.logLevel = options?.logLevel ?? "warn";
+  }
+  async start() {
+    if (!this.enginePath) {
+      this.enginePath = await findEngineBinary();
+    }
+    this.process = spawn(this.enginePath, [`--log-level=${this.logLevel}`], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.reader = createInterface({ input: this.process.stdout });
+    const result = await this.sendRequestInternal("initialize", {
+      sdk_name: "attest-typescript",
+      sdk_version: VERSION,
+      protocol_version: 1,
+      required_capabilities: ["layers_1_4"],
+      preferred_encoding: "json"
+    });
+    this.initResult = result;
+    if (!this.initResult.compatible) {
+      throw new Error(
+        `Engine incompatible. Missing capabilities: ${JSON.stringify(this.initResult.missing)}`
+      );
+    }
+    this.initialized = true;
+    return this.initResult;
+  }
+  async stop() {
+    if (this.process === null) return;
+    if (this.initialized) {
+      try {
+        await this.sendRequestInternal("shutdown", {});
+      } catch {
+      }
+    }
+    if (this.reader) {
+      this.reader.close();
+      this.reader = null;
+    }
+    if (this.process.exitCode === null) {
+      this.process.kill("SIGTERM");
+      await new Promise((res) => {
+        const timer = setTimeout(() => {
+          this.process?.kill("SIGKILL");
+        }, 5e3);
+        this.process.on("exit", () => {
+          clearTimeout(timer);
+          res();
+        });
+      });
+    }
+    this.initialized = false;
+    this.process = null;
+  }
+  async sendRequest(method, params) {
+    if (!this.initialized && method !== "initialize") {
+      throw new Error("Engine not initialized. Call start() first.");
+    }
+    return this.sendRequestInternal(method, params);
+  }
+  async sendRequestInternal(method, params) {
+    if (this.process === null || this.process.stdin === null || this.reader === null) {
+      throw new Error("Engine process not started.");
+    }
+    this.requestId += 1;
+    const requestStr = encodeRequest(this.requestId, method, params);
+    return new Promise((resolve2, reject) => {
+      const onLine = (line) => {
+        try {
+          const response = decodeResponse(line);
+          resolve2(extractResult(response));
+        } catch (err) {
+          reject(err);
+        }
+      };
+      this.reader.once("line", onLine);
+      const ok = this.process.stdin.write(requestStr, (err) => {
+        if (err) {
+          this.reader.removeListener("line", onLine);
+          reject(err);
+        }
+      });
+      if (!ok) {
+        this.process.stdin.once("drain", () => {
+        });
+      }
+    });
+  }
+  get isRunning() {
+    return this.process !== null && this.process.exitCode === null;
+  }
+  /** Expose process for AttestClient reader loop access */
+  get childProcess() {
+    return this.process;
+  }
+  /** Expose readline interface for AttestClient reader loop */
+  get readlineInterface() {
+    return this.reader;
+  }
+};
+
+// src/config.ts
+var _simulationMode = false;
+function config(options) {
+  if (options.simulation !== void 0) {
+    _simulationMode = options.simulation;
+  }
+}
+function isSimulationMode() {
+  return _simulationMode || process.env["ATTEST_SIMULATION"] === "1" || process.env["ATTEST_SIMULATION"] === "true" || process.env["ATTEST_SIMULATION"] === "yes";
+}
+function resetConfig() {
+  _simulationMode = false;
+}
+
+// src/simulation.ts
+function simulationEvaluateBatch(assertions) {
+  const results = assertions.map((assertion) => ({
+    assertion_id: assertion.assertion_id,
+    status: "pass",
+    score: 1,
+    explanation: `[simulation] assertion '${assertion.assertion_id}' passed (type: ${assertion.type})`,
+    cost: 0,
+    duration_ms: 0
+  }));
+  return {
+    results,
+    total_cost: 0,
+    total_duration_ms: 0
+  };
+}
+
+// src/client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function resolveTimeoutMs(override) {
+  if (override !== void 0) return override;
+  const env = process.env["ATTEST_ENGINE_TIMEOUT"];
+  if (env !== void 0 && env !== "") {
+    const parsed = Number(env);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      throw new Error(
+        `ATTEST_ENGINE_TIMEOUT must be a positive number of milliseconds, got: '${env}'`
+      );
+    }
+    return parsed;
+  }
+  return DEFAULT_TIMEOUT_MS;
+}
+function makeTimeoutPromise(method, timeoutMs) {
+  return new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(new EngineTimeoutError(method, timeoutMs));
+    }, timeoutMs);
+  });
+}
+var AttestClient = class {
+  engine;
+  requestId = 0;
+  pending = /* @__PURE__ */ new Map();
+  writeChain = Promise.resolve();
+  readerActive = false;
+  lineHandler = null;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  startReader() {
+    if (this.readerActive) return;
+    const rl = this.engine.readlineInterface;
+    if (rl === null) {
+      throw new Error("Engine readline interface not available. Call engine.start() first.");
+    }
+    this.readerActive = true;
+    this.lineHandler = (line) => this.handleLine(line);
+    rl.on("line", this.lineHandler);
+    rl.on("close", () => {
+      this.failAll(new Error("Engine closed stdout."));
+      this.readerActive = false;
+    });
+  }
+  stopReader() {
+    if (!this.readerActive) return;
+    const rl = this.engine.readlineInterface;
+    if (rl !== null && this.lineHandler !== null) {
+      rl.removeListener("line", this.lineHandler);
+    }
+    this.lineHandler = null;
+    this.readerActive = false;
+  }
+  handleLine(line) {
+    let reqId;
+    try {
+      const response = decodeResponse(line);
+      reqId = extractId(response);
+      const pending = this.pending.get(reqId);
+      if (pending === void 0) return;
+      this.pending.delete(reqId);
+      try {
+        const result = extractResult(response);
+        pending.resolve(result);
+      } catch (err) {
+        pending.reject(err);
+      }
+    } catch (err) {
+      if (err instanceof ProtocolError) {
+        try {
+          const raw = JSON.parse(line.trim());
+          reqId = Number(raw.id ?? -1);
+        } catch {
+          reqId = -1;
+        }
+        const pending = this.pending.get(reqId);
+        if (pending !== void 0) {
+          this.pending.delete(reqId);
+          pending.reject(err);
+        }
+      }
+    }
+  }
+  failAll(err) {
+    for (const pending of this.pending.values()) {
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+  async sendRequest(method, params, timeoutMs) {
+    const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+    if (!this.readerActive) {
+      return Promise.race([
+        this.engine.sendRequest(method, params),
+        makeTimeoutPromise(method, resolvedTimeout)
+      ]);
+    }
+    const cp = this.engine.childProcess;
+    if (cp === null || cp.stdin === null) {
+      throw new Error("Engine process not started.");
+    }
+    let capturedReqId;
+    const requestPromise = new Promise((resolve2, reject) => {
+      this.writeChain = this.writeChain.then(() => {
+        this.requestId += 1;
+        const reqId = this.requestId;
+        capturedReqId = reqId;
+        this.pending.set(reqId, { resolve: resolve2, reject });
+        const requestStr = encodeRequest(reqId, method, params);
+        cp.stdin.write(requestStr, (err) => {
+          if (err) {
+            this.pending.delete(reqId);
+            reject(err);
+          }
+        });
+      });
+    });
+    const timeoutPromise = makeTimeoutPromise(method, resolvedTimeout);
+    return Promise.race([requestPromise, timeoutPromise]).catch((err) => {
+      if (err instanceof EngineTimeoutError && capturedReqId !== void 0) {
+        this.pending.delete(capturedReqId);
+      }
+      throw err;
+    });
+  }
+  async evaluateBatch(trace, assertions, options) {
+    if (isSimulationMode()) {
+      return simulationEvaluateBatch(assertions);
+    }
+    const params = {
+      trace,
+      assertions: [...assertions]
+    };
+    const raw = await this.sendRequest(
+      "evaluate_batch",
+      params,
+      options?.timeout
+    );
+    return raw;
+  }
+  async submitPluginResult(traceId2, pluginName, assertionId2, status, score, explanation, options) {
+    const result = {
+      assertion_id: assertionId2,
+      status,
+      score,
+      explanation,
+      cost: 0,
+      duration_ms: 0
+    };
+    const params = {
+      trace_id: traceId2,
+      plugin_name: pluginName,
+      assertion_id: assertionId2,
+      result
+    };
+    const raw = await this.sendRequest(
+      "submit_plugin_result",
+      params,
+      options?.timeout
+    );
+    return Boolean(raw?.accepted ?? false);
+  }
+};
+
+// src/trace.ts
+import { randomUUID } from "crypto";
+var TraceBuilder = class {
+  traceId;
+  agentId;
+  input;
+  steps = [];
+  output;
+  metadata;
+  parentTraceId;
+  constructor(agentId2) {
+    this.traceId = `trc_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+    this.agentId = agentId2;
+  }
+  setTraceId(traceId2) {
+    this.traceId = traceId2;
+    return this;
+  }
+  setInput(input) {
+    this.input = input;
+    return this;
+  }
+  addLlmCall(name, options) {
+    this.steps.push({
+      type: STEP_LLM_CALL,
+      name,
+      args: options?.args,
+      result: options?.result,
+      metadata: options?.metadata
+    });
+    return this;
+  }
+  addToolCall(name, options) {
+    this.steps.push({
+      type: STEP_TOOL_CALL,
+      name,
+      args: options?.args,
+      result: options?.result,
+      metadata: options?.metadata
+    });
+    return this;
+  }
+  addRetrieval(name, options) {
+    this.steps.push({
+      type: STEP_RETRIEVAL,
+      name,
+      args: options?.args,
+      result: options?.result,
+      metadata: options?.metadata
+    });
+    return this;
+  }
+  addStep(step) {
+    this.steps.push(step);
+    return this;
+  }
+  setOutput(output) {
+    this.output = output;
+    return this;
+  }
+  setMetadata(metadata) {
+    this.metadata = metadata;
+    return this;
+  }
+  getTraceId() {
+    return this.traceId;
+  }
+  setParentTraceId(parentId) {
+    this.parentTraceId = parentId;
+    return this;
+  }
+  build() {
+    if (this.output === void 0) {
+      throw new Error("Trace output is required. Call setOutput() before build().");
+    }
+    return {
+      trace_id: this.traceId,
+      output: this.output,
+      schema_version: 1,
+      agent_id: this.agentId,
+      input: this.input,
+      steps: [...this.steps],
+      metadata: this.metadata,
+      parent_trace_id: this.parentTraceId
+    };
+  }
+};
+
+// src/result.ts
+var AgentResult = class {
+  trace;
+  assertionResults;
+  totalCost;
+  totalDurationMs;
+  constructor(trace, assertionResults = [], totalCost = 0, totalDurationMs = 0) {
+    this.trace = trace;
+    this.assertionResults = assertionResults;
+    this.totalCost = totalCost;
+    this.totalDurationMs = totalDurationMs;
+  }
+  get passed() {
+    return this.assertionResults.every((r) => r.status === STATUS_PASS);
+  }
+  get failedAssertions() {
+    return this.assertionResults.filter((r) => r.status !== STATUS_PASS);
+  }
+  get hardFailures() {
+    return this.assertionResults.filter((r) => r.status === STATUS_HARD_FAIL);
+  }
+  get softFailures() {
+    return this.assertionResults.filter((r) => r.status === STATUS_SOFT_FAIL);
+  }
+  get passCount() {
+    return this.assertionResults.filter((r) => r.status === STATUS_PASS).length;
+  }
+  get failCount() {
+    return this.assertionResults.length - this.passCount;
+  }
+};
+
+// src/trace-tree.ts
+var TraceTree = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  get agents() {
+    const result = [];
+    this.collectAgents(this.root, result);
+    return result;
+  }
+  collectAgents(trace, acc) {
+    if (trace.agent_id != null) {
+      acc.push(trace.agent_id);
+    }
+    for (const step of trace.steps) {
+      if (step.type === STEP_AGENT_CALL && step.sub_trace != null) {
+        this.collectAgents(step.sub_trace, acc);
+      }
+    }
+  }
+  findAgent(agentId2) {
+    return this.findAgentIn(this.root, agentId2);
+  }
+  findAgentIn(trace, agentId2) {
+    if (trace.agent_id === agentId2) return trace;
+    for (const step of trace.steps) {
+      if (step.type === STEP_AGENT_CALL && step.sub_trace != null) {
+        const found = this.findAgentIn(step.sub_trace, agentId2);
+        if (found !== void 0) return found;
+      }
+    }
+    return void 0;
+  }
+  get depth() {
+    return this.computeDepth(this.root);
+  }
+  computeDepth(trace) {
+    let maxChild = -1;
+    for (const step of trace.steps) {
+      if (step.type === STEP_AGENT_CALL && step.sub_trace != null) {
+        const childDepth = this.computeDepth(step.sub_trace);
+        if (childDepth > maxChild) maxChild = childDepth;
+      }
+    }
+    return maxChild >= 0 ? maxChild + 1 : 0;
+  }
+  flatten() {
+    const result = [];
+    this.flattenInto(this.root, result);
+    return result;
+  }
+  flattenInto(trace, acc) {
+    acc.push(trace);
+    for (const step of trace.steps) {
+      if (step.type === STEP_AGENT_CALL && step.sub_trace != null) {
+        this.flattenInto(step.sub_trace, acc);
+      }
+    }
+  }
+  get delegations() {
+    const result = [];
+    this.collectDelegations(this.root, result);
+    return result;
+  }
+  collectDelegations(trace, acc) {
+    const parentId = trace.agent_id ?? "";
+    for (const step of trace.steps) {
+      if (step.type === STEP_AGENT_CALL && step.sub_trace != null) {
+        const childId = step.sub_trace.agent_id ?? "";
+        acc.push([parentId, childId]);
+        this.collectDelegations(step.sub_trace, acc);
+      }
+    }
+  }
+  allToolCalls() {
+    return this.flatten().flatMap(
+      (t) => t.steps.filter((step) => step.type === STEP_TOOL_CALL)
+    );
+  }
+  get aggregateTokens() {
+    return this.flatten().reduce(
+      (sum, t) => sum + (t.metadata?.total_tokens ?? 0),
+      0
+    );
+  }
+  get aggregateCost() {
+    return this.flatten().reduce(
+      (sum, t) => sum + (t.metadata?.cost_usd ?? 0),
+      0
+    );
+  }
+  get aggregateLatency() {
+    return this.flatten().reduce(
+      (sum, t) => sum + (t.metadata?.latency_ms ?? 0),
+      0
+    );
+  }
+};
+
+// src/expect.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var ExpectChain = class {
+  _result;
+  _assertions = [];
+  constructor(result) {
+    this._result = result;
+  }
+  get assertions() {
+    return [...this._assertions];
+  }
+  get trace() {
+    return this._result.trace;
+  }
+  add(assertionType, spec) {
+    this._assertions.push({
+      assertion_id: `assert_${randomUUID2().replace(/-/g, "").slice(0, 8)}`,
+      type: assertionType,
+      spec
+    });
+    return this;
+  }
+  // -- Layer 1: Schema --
+  /**
+   * Assert that `output.structured` conforms to the given JSON Schema.
+   *
+   * @param schema - A JSON Schema object to validate against.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputMatchesSchema({ type: "object", required: ["answer"] });
+   * ```
+   */
+  outputMatchesSchema(schema) {
+    return this.add(TYPE_SCHEMA, { target: "output.structured", schema });
+  }
+  /**
+   * Assert that a specific output field conforms to the given JSON Schema.
+   *
+   * @param field - Dot-delimited path under `output` (e.g. `"structured.items"`).
+   * @param schema - A JSON Schema object to validate against.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputFieldMatchesSchema("structured.items", { type: "array" });
+   * ```
+   */
+  outputFieldMatchesSchema(field, schema) {
+    return this.add(TYPE_SCHEMA, { target: `output.${field}`, schema });
+  }
+  /**
+   * Assert that a named tool's arguments conform to the given JSON Schema.
+   *
+   * @param toolName - The tool name to match in `steps`.
+   * @param schema - A JSON Schema object to validate against.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).toolArgsMatchSchema("search", { type: "object", required: ["query"] });
+   * ```
+   */
+  toolArgsMatchSchema(toolName, schema) {
+    return this.add(TYPE_SCHEMA, {
+      target: `steps[?name=='${toolName}'].args`,
+      schema
+    });
+  }
+  /**
+   * Assert that a named tool's result conforms to the given JSON Schema.
+   *
+   * @param toolName - The tool name to match in `steps`.
+   * @param schema - A JSON Schema object to validate against.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).toolResultMatchesSchema("search", { type: "object" });
+   * ```
+   */
+  toolResultMatchesSchema(toolName, schema) {
+    return this.add(TYPE_SCHEMA, {
+      target: `steps[?name=='${toolName}'].result`,
+      schema
+    });
+  }
+  // -- Layer 2: Constraints --
+  /**
+   * Assert total cost (in USD) is at or below `maxCost`.
+   *
+   * @param maxCost - Maximum allowed cost in USD.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).costUnder(0.05);
+   * expect(result).costUnder(0.05, { soft: true });
+   * ```
+   */
+  costUnder(maxCost, opts) {
+    return this.add(TYPE_CONSTRAINT, {
+      field: "metadata.cost_usd",
+      operator: "lte",
+      value: maxCost,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert total latency is at or below `maxMs` milliseconds.
+   *
+   * @param maxMs - Maximum allowed latency in milliseconds.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).latencyUnder(2000);
+   * ```
+   */
+  latencyUnder(maxMs, opts) {
+    return this.add(TYPE_CONSTRAINT, {
+      field: "metadata.latency_ms",
+      operator: "lte",
+      value: maxMs,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert total token usage is at or below `maxTokens`.
+   *
+   * @param maxTokens - Maximum allowed token count.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).tokensUnder(500);
+   * ```
+   */
+  tokensUnder(maxTokens, opts) {
+    return this.add(TYPE_CONSTRAINT, {
+      field: "metadata.total_tokens",
+      operator: "lte",
+      value: maxTokens,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert total token usage is between `minTokens` and `maxTokens` (inclusive).
+   *
+   * @param minTokens - Minimum allowed token count.
+   * @param maxTokens - Maximum allowed token count.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).tokensBetween(100, 500);
+   * ```
+   */
+  tokensBetween(minTokens, maxTokens, opts) {
+    return this.add(TYPE_CONSTRAINT, {
+      field: "metadata.total_tokens",
+      operator: "between",
+      min: minTokens,
+      max: maxTokens,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the number of steps satisfies the given comparison.
+   *
+   * @param operator - Comparison operator (e.g. `"eq"`, `"lte"`, `"gte"`).
+   * @param value - The reference count to compare against.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).stepCount("lte", 5);
+   * ```
+   */
+  stepCount(operator, value, opts) {
+    return this.add(TYPE_CONSTRAINT, {
+      field: "steps.length",
+      operator,
+      value,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the number of tool-call steps satisfies the given comparison.
+   *
+   * @param operator - Comparison operator (e.g. `"eq"`, `"lte"`, `"gte"`).
+   * @param value - The reference count to compare against.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).toolCallCount("gte", 1);
+   * ```
+   */
+  toolCallCount(operator, value, opts) {
+    return this.add(TYPE_CONSTRAINT, {
+      field: "steps[?type=='tool_call'].length",
+      operator,
+      value,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Generic constraint assertion on any field.
+   *
+   * @param field - Dot-delimited path into the trace (e.g. `"metadata.cost_usd"`).
+   * @param operator - Comparison operator.
+   * @param opts.value - Reference value for single-operand operators.
+   * @param opts.min - Minimum for `"between"` operator.
+   * @param opts.max - Maximum for `"between"` operator.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).constraint("metadata.cost_usd", "lte", { value: 0.1 });
+   * ```
+   */
+  constraint(field, operator, opts) {
+    const spec = {
+      field,
+      operator,
+      soft: opts?.soft ?? false
+    };
+    if (opts?.value !== void 0) spec.value = opts.value;
+    if (opts?.min !== void 0) spec.min = opts.min;
+    if (opts?.max !== void 0) spec.max = opts.max;
+    return this.add(TYPE_CONSTRAINT, spec);
+  }
+  // -- Layer 3: Trace --
+  /**
+   * Assert that tools were called in the given order (non-contiguous allowed).
+   *
+   * @param tools - Ordered list of tool names expected.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).toolsCalledInOrder(["search", "write"]);
+   * ```
+   */
+  toolsCalledInOrder(tools, opts) {
+    return this.add(TYPE_TRACE, {
+      check: "contains_in_order",
+      tools,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert that tools were called in exact contiguous order.
+   *
+   * @param tools - Exact ordered list of tool names.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).toolsCalledExactly(["search", "summarize", "respond"]);
+   * ```
+   */
+  toolsCalledExactly(tools, opts) {
+    return this.add(TYPE_TRACE, {
+      check: "exact_order",
+      tools,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert a tool is not called more than `maxRepetitions` times consecutively.
+   *
+   * @param tool - The tool name to check.
+   * @param maxRepetitions - Maximum allowed consecutive calls (default `1`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).noToolLoops("fetch", 2);
+   * ```
+   */
+  noToolLoops(tool, maxRepetitions = 1, opts) {
+    return this.add(TYPE_TRACE, {
+      check: "loop_detection",
+      tool,
+      max_repetitions: maxRepetitions,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert no tool is called more than once.
+   *
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).noDuplicateTools();
+   * ```
+   */
+  noDuplicateTools(opts) {
+    return this.add(TYPE_TRACE, { check: "no_duplicates", soft: opts?.soft ?? false });
+  }
+  /**
+   * Assert that all listed tools were called at least once.
+   *
+   * @param tools - Tool names that must appear in the trace.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).requiredTools(["search", "respond"]);
+   * ```
+   */
+  requiredTools(tools, opts) {
+    return this.add(TYPE_TRACE, {
+      check: "required_tools",
+      tools,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert that none of the listed tools were called.
+   *
+   * @param tools - Tool names that must not appear in the trace.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).forbiddenTools(["delete_user", "drop_table"]);
+   * ```
+   */
+  forbiddenTools(tools, opts) {
+    return this.add(TYPE_TRACE, {
+      check: "forbidden_tools",
+      tools,
+      soft: opts?.soft ?? false
+    });
+  }
+  // -- Layer 4: Content --
+  /**
+   * Assert the output message contains the given string.
+   *
+   * @param value - Substring to search for.
+   * @param opts.caseSensitive - Enable case-sensitive matching (default `false`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputContains("refund approved");
+   * ```
+   */
+  outputContains(value, opts) {
+    return this.add(TYPE_CONTENT, {
+      target: "output.message",
+      check: "contains",
+      value,
+      case_sensitive: opts?.caseSensitive ?? false,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the output message does not contain the given string.
+   *
+   * @param value - Substring that must be absent.
+   * @param opts.caseSensitive - Enable case-sensitive matching (default `false`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputNotContains("internal error");
+   * ```
+   */
+  outputNotContains(value, opts) {
+    return this.add(TYPE_CONTENT, {
+      target: "output.message",
+      check: "not_contains",
+      value,
+      case_sensitive: opts?.caseSensitive ?? false,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the output message matches the given regular expression.
+   *
+   * @param pattern - Regex pattern string.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputMatchesRegex("order #\\d{5}");
+   * ```
+   */
+  outputMatchesRegex(pattern, opts) {
+    return this.add(TYPE_CONTENT, {
+      target: "output.message",
+      check: "regex_match",
+      value: pattern,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the output message contains all of the given keywords.
+   *
+   * @param keywords - Keywords that must all be present.
+   * @param opts.caseSensitive - Enable case-sensitive matching (default `false`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputHasAllKeywords(["refund", "processed"]);
+   * ```
+   */
+  outputHasAllKeywords(keywords, opts) {
+    return this.add(TYPE_CONTENT, {
+      target: "output.message",
+      check: "keyword_all",
+      values: keywords,
+      case_sensitive: opts?.caseSensitive ?? false,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the output message contains at least one of the given keywords.
+   *
+   * @param keywords - Keywords where at least one must be present.
+   * @param opts.caseSensitive - Enable case-sensitive matching (default `false`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputHasAnyKeyword(["yes", "confirmed"]);
+   * ```
+   */
+  outputHasAnyKeyword(keywords, opts) {
+    return this.add(TYPE_CONTENT, {
+      target: "output.message",
+      check: "keyword_any",
+      values: keywords,
+      case_sensitive: opts?.caseSensitive ?? false,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the output message contains none of the forbidden terms.
+   *
+   * @param terms - Terms that must not appear in the output.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputForbids(["password", "api_key"]);
+   * ```
+   */
+  outputForbids(terms) {
+    return this.add(TYPE_CONTENT, {
+      target: "output.message",
+      check: "forbidden",
+      values: terms
+    });
+  }
+  /**
+   * Generic content-contains check on any target path.
+   *
+   * @param target - Dot-delimited path into the trace.
+   * @param value - Substring to search for.
+   * @param opts.caseSensitive - Enable case-sensitive matching (default `false`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).contentContains("steps[0].result.text", "success");
+   * ```
+   */
+  contentContains(target, value, opts) {
+    return this.add(TYPE_CONTENT, {
+      target,
+      check: "contains",
+      value,
+      case_sensitive: opts?.caseSensitive ?? false,
+      soft: opts?.soft ?? false
+    });
+  }
+  // -- Layer 5: Embedding Similarity --
+  /**
+   * Assert the output is semantically similar to a reference string via embeddings.
+   *
+   * @param reference - The reference text to compare against.
+   * @param opts.threshold - Minimum cosine similarity (default `0.8`).
+   * @param opts.model - Override the embedding model.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).outputSimilarTo("The order has been refunded", { threshold: 0.85 });
+   * ```
+   */
+  outputSimilarTo(reference, opts) {
+    return this.add(TYPE_EMBEDDING, {
+      target: "output.message",
+      reference,
+      threshold: opts?.threshold ?? 0.8,
+      model: opts?.model,
+      soft: opts?.soft ?? false
+    });
+  }
+  // -- Layer 6: LLM Judge --
+  /**
+   * Assert the output passes LLM judge evaluation against given criteria.
+   *
+   * @param criteria - Natural language description of what makes a good response.
+   * @param opts.rubric - Rubric name (default `"default"`).
+   * @param opts.threshold - Minimum passing score (default `0.8`).
+   * @param opts.model - Override the judge model.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).passesJudge("Response is polite and helpful", { threshold: 0.9 });
+   * ```
+   */
+  passesJudge(criteria, opts) {
+    return this.add(TYPE_LLM_JUDGE, {
+      target: "output.message",
+      criteria,
+      rubric: opts?.rubric ?? "default",
+      threshold: opts?.threshold ?? 0.8,
+      model: opts?.model,
+      soft: opts?.soft ?? false
+    });
+  }
+  // -- Layer 7: Trace Tree (Multi-Agent) --
+  /**
+   * Assert that a specific agent was called in the trace tree.
+   *
+   * @param agentId - The agent identifier to look for.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).agentCalled("summarizer");
+   * ```
+   */
+  agentCalled(agentId2, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "agent_called",
+      agent_id: agentId2,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert the trace tree delegation depth does not exceed `maxDepth`.
+   *
+   * @param maxDepth - Maximum allowed delegation depth.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).delegationDepth(3);
+   * ```
+   */
+  delegationDepth(maxDepth, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "delegation_depth",
+      max_depth: maxDepth,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert a sub-agent's output contains the given string.
+   *
+   * @param agentId - The agent whose output to check.
+   * @param value - Substring to search for.
+   * @param opts.caseSensitive - Enable case-sensitive matching (default `false`).
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).agentOutputContains("summarizer", "key findings");
+   * ```
+   */
+  agentOutputContains(agentId2, value, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "agent_output_contains",
+      agent_id: agentId2,
+      value,
+      case_sensitive: opts?.caseSensitive ?? false,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert data flows from one agent's output to another agent's input.
+   *
+   * @param fromAgent - Source agent ID.
+   * @param toAgent - Destination agent ID.
+   * @param field - The data field that must flow between agents.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).crossAgentDataFlow("researcher", "writer", "findings");
+   * ```
+   */
+  crossAgentDataFlow(fromAgent, toAgent, field, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "cross_agent_data_flow",
+      from_agent: fromAgent,
+      to_agent: toAgent,
+      field,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert agent delegations follow the specified transitions.
+   *
+   * @param transitions - Array of `[fromAgent, toAgent]` pairs.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).followsTransitions([["root", "planner"], ["planner", "executor"]]);
+   * ```
+   */
+  followsTransitions(transitions, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "follows_transitions",
+      transitions,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert aggregate cost across the entire trace tree is at or below `maxCost`.
+   *
+   * @param maxCost - Maximum allowed aggregate cost in USD.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).aggregateCostUnder(0.50);
+   * ```
+   */
+  aggregateCostUnder(maxCost, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "aggregate_cost",
+      operator: "lte",
+      value: maxCost,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert aggregate tokens across the entire trace tree is at or below `maxTokens`.
+   *
+   * @param maxTokens - Maximum allowed aggregate token count.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).aggregateTokensUnder(10000);
+   * ```
+   */
+  aggregateTokensUnder(maxTokens, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "aggregate_tokens",
+      operator: "lte",
+      value: maxTokens,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert `agentA` started before `agentB` in the trace tree.
+   *
+   * @param agentA - The agent expected to run first.
+   * @param agentB - The agent expected to run second.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).agentOrderedBefore("planner", "executor");
+   * ```
+   */
+  agentOrderedBefore(agentA, agentB, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "agent_ordered_before",
+      agent_a: agentA,
+      agent_b: agentB,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert `agentA` and `agentB` ran concurrently (overlapping wall-clock time).
+   *
+   * @param agentA - First agent ID.
+   * @param agentB - Second agent ID.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).agentsOverlap("worker-1", "worker-2");
+   * ```
+   */
+  agentsOverlap(agentA, agentB, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "agents_overlap",
+      agent_a: agentA,
+      agent_b: agentB,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert a specific agent's wall-clock duration is under `maxMs` milliseconds.
+   *
+   * @param agentId - The agent to check.
+   * @param maxMs - Maximum allowed wall-clock time in milliseconds.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).agentWallTimeUnder("summarizer", 5000);
+   * ```
+   */
+  agentWallTimeUnder(agentId2, maxMs, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "agent_wall_time_under",
+      agent_id: agentId2,
+      max_ms: maxMs,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert agents ran in ordered groups (parallel within each group, sequential across groups).
+   *
+   * @param groups - Array of agent-ID arrays. Each sub-array is a parallel group.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).orderedAgents([["planner"], ["worker-1", "worker-2"], ["aggregator"]]);
+   * ```
+   */
+  orderedAgents(groups, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "ordered_agents",
+      groups,
+      soft: opts?.soft ?? false
+    });
+  }
+  // -- Layer 8: Plugin --
+  /**
+   * Assert via a registered plugin (Layer 8).
+   *
+   * @param pluginId - Identifier of the plugin registered with the engine.
+   * @param config - Plugin-specific configuration passed at evaluation time.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).plugin("custom-safety-check", { threshold: 0.95 });
+   * ```
+   */
+  plugin(pluginId, config2, opts) {
+    const spec = { plugin_id: pluginId, soft: opts?.soft ?? false };
+    if (config2 !== void 0) spec.config = config2;
+    return this.add(TYPE_PLUGIN, spec);
+  }
+  // -- TraceTree Analytics (P9 parity) --
+  /**
+   * Assert aggregate latency across the trace tree is at or below `maxMs`.
+   *
+   * @param maxMs - Maximum allowed aggregate latency in milliseconds.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).aggregateLatencyUnder(5000);
+   * ```
+   */
+  aggregateLatencyUnder(maxMs, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "aggregate_latency",
+      operator: "lte",
+      value: maxMs,
+      soft: opts?.soft ?? false
+    });
+  }
+  /**
+   * Assert that all specified tools were called across the entire trace tree.
+   *
+   * @param toolNames - Tool names that must appear somewhere in the tree.
+   * @param opts.soft - When `true` the failure is non-blocking.
+   * @returns The chain for fluent composition.
+   *
+   * @example
+   * ```ts
+   * expect(result).allToolsCalled(["search", "summarize"]);
+   * ```
+   */
+  allToolsCalled(toolNames, opts) {
+    return this.add(TYPE_TRACE_TREE, {
+      check: "all_tools_called",
+      tools: toolNames,
+      soft: opts?.soft ?? false
+    });
+  }
+};
+function attestExpect(result) {
+  if (result instanceof AgentResult) {
+    return new ExpectChain(result);
+  }
+  return new ExpectChain(new AgentResult(result));
+}
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var activeBuilder = new AsyncLocalStorage();
+
+// src/agent.ts
+var Agent = class {
+  name;
+  fn;
+  constructor(name, fn) {
+    this.name = name;
+    this.fn = fn;
+  }
+  run(args = {}) {
+    if (this.fn === void 0) {
+      throw new Error("No agent function provided. Pass fn to Agent().");
+    }
+    const builder = new TraceBuilder(this.name);
+    builder.setInput(args);
+    const output = activeBuilder.run(builder, () => this.fn(builder, args));
+    this.setOutput(builder, output);
+    return new AgentResult(builder.build());
+  }
+  async arun(args = {}) {
+    if (this.fn === void 0) {
+      throw new Error("No agent function provided. Pass fn to Agent().");
+    }
+    const builder = new TraceBuilder(this.name);
+    builder.setInput(args);
+    const output = await activeBuilder.run(builder, async () => this.fn(builder, args));
+    this.setOutput(builder, output);
+    return new AgentResult(builder.build());
+  }
+  setOutput(builder, output) {
+    if (output !== null && output !== void 0 && typeof output === "object" && !Array.isArray(output)) {
+      builder.setOutput(output);
+    } else if (output !== void 0) {
+      builder.setOutput({ result: output });
+    } else {
+      builder.setOutput({ result: null });
+    }
+  }
+  withTrace(trace) {
+    return new AgentResult(trace);
+  }
+};
+function agent(name, fn) {
+  const wrapped = new Agent(name, fn);
+  const wrapper = (args) => {
+    return wrapped.run(args ?? {});
+  };
+  wrapper.agent = wrapped;
+  return wrapper;
+}
+
+// src/delegate.ts
+async function delegate(agentId2, fn) {
+  const parent = activeBuilder.getStore();
+  if (parent === void 0) {
+    throw new Error(
+      "delegate() must be used within an Agent.run() context. No active TraceBuilder found."
+    );
+  }
+  const child = new TraceBuilder(agentId2);
+  child.setParentTraceId(parent.getTraceId());
+  await activeBuilder.run(child, async () => {
+    await fn(child);
+  });
+  const childTrace = child.build();
+  parent.addStep({
+    type: STEP_AGENT_CALL,
+    name: agentId2,
+    args: void 0,
+    result: childTrace.output,
+    sub_trace: childTrace
+  });
+}
+
+// src/tier.ts
+var TIER_1 = 1;
+var TIER_2 = 2;
+var TIER_3 = 3;
+function tier(level) {
+  return (fn) => {
+    fn._attest_tier = level;
+    return fn;
+  };
+}
+
+// src/plugins.ts
+var PluginRegistry = class {
+  plugins = /* @__PURE__ */ new Map();
+  register(name, plugin) {
+    const pluginType = plugin.pluginType;
+    let typeMap = this.plugins.get(pluginType);
+    if (typeMap === void 0) {
+      typeMap = /* @__PURE__ */ new Map();
+      this.plugins.set(pluginType, typeMap);
+    }
+    typeMap.set(name, plugin);
+  }
+  get(pluginType, name) {
+    return this.plugins.get(pluginType)?.get(name);
+  }
+  listPlugins(pluginType) {
+    if (pluginType !== void 0) {
+      const typeMap = this.plugins.get(pluginType);
+      return typeMap !== void 0 ? [...typeMap.keys()] : [];
+    }
+    const result = [];
+    for (const [ptype, typeMap] of this.plugins) {
+      for (const pname of typeMap.keys()) {
+        result.push(`${ptype}/${pname}`);
+      }
+    }
+    return result;
+  }
+};
+async function executePluginAssertion(plugin, trace, spec, client, traceId2, assertionId2, timeoutMs = 3e4) {
+  const resultPromise = Promise.resolve(plugin.execute(trace, spec));
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(`Plugin '${plugin.name}' timed out after ${timeoutMs}ms`)), timeoutMs);
+  });
+  const result = await Promise.race([resultPromise, timeoutPromise]);
+  await client.submitPluginResult(
+    traceId2,
+    plugin.name,
+    assertionId2,
+    result.status,
+    result.score,
+    result.explanation
+  );
+  return result;
+}
+
+// src/continuous.ts
+import { EventEmitter } from "events";
+var DEFAULT_QUEUE_SIZE = 1e3;
+function resolveQueueSize() {
+  const raw = process.env["ATTEST_CONTINUOUS_QUEUE_SIZE"];
+  if (raw !== void 0 && raw !== "") {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  return DEFAULT_QUEUE_SIZE;
+}
+var Sampler = class {
+  rate;
+  constructor(rate) {
+    if (rate < 0 || rate > 1) {
+      throw new Error(`sample_rate must be in [0.0, 1.0], got ${rate}`);
+    }
+    this.rate = rate;
+  }
+  shouldSample() {
+    return Math.random() < this.rate;
+  }
+};
+var AlertDispatcher = class extends EventEmitter {
+  webhookUrl;
+  slackUrl;
+  constructor(webhookUrl, slackUrl) {
+    super();
+    this.webhookUrl = webhookUrl;
+    this.slackUrl = slackUrl;
+  }
+  async dispatch(alert) {
+    this.emit("alert", alert);
+    const tasks = [];
+    if (this.webhookUrl) {
+      tasks.push(this.postJson(this.webhookUrl, alert));
+    }
+    if (this.slackUrl) {
+      const text = `[attest] drift alert -- type=${alert.drift_type} score=${alert.score} trace_id=${alert.trace_id}`;
+      tasks.push(this.postJson(this.slackUrl, { text }));
+    }
+    const results = await Promise.allSettled(tasks);
+    for (const result of results) {
+      if (result.status === "rejected") {
+        this.emit("alertError", result.reason);
+      }
+    }
+  }
+  async postJson(url, payload) {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`POST to ${url} returned ${response.status}`);
+    }
+  }
+};
+var ContinuousEvalRunner = class {
+  client;
+  assertions;
+  sampler;
+  dispatcher;
+  queue = [];
+  maxSize;
+  running = false;
+  loopTimer = null;
+  constructor(client, assertions, options) {
+    this.client = client;
+    this.assertions = assertions;
+    this.sampler = new Sampler(options?.sampleRate ?? 1);
+    this.dispatcher = new AlertDispatcher(options?.alertWebhook, options?.alertSlackUrl);
+    this.maxSize = options?.maxSize ?? resolveQueueSize();
+  }
+  get alertEmitter() {
+    return this.dispatcher;
+  }
+  async evaluateTrace(trace) {
+    if (!this.sampler.shouldSample()) return null;
+    return this.client.evaluateBatch(trace, this.assertions);
+  }
+  submit(trace) {
+    if (this.queue.length >= this.maxSize) {
+      return false;
+    }
+    this.queue.push(trace);
+    return true;
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.scheduleNext();
+  }
+  stop() {
+    this.running = false;
+    if (this.loopTimer !== null) {
+      clearTimeout(this.loopTimer);
+      this.loopTimer = null;
+    }
+  }
+  get queueLength() {
+    return this.queue.length;
+  }
+  get isRunning() {
+    return this.running;
+  }
+  scheduleNext() {
+    if (!this.running) return;
+    this.loopTimer = setTimeout(async () => {
+      if (!this.running) return;
+      const trace = this.queue.shift();
+      if (trace !== void 0) {
+        try {
+          await this.evaluateTrace(trace);
+        } catch {
+        }
+      }
+      this.scheduleNext();
+    }, this.queue.length > 0 ? 0 : 100);
+  }
+};
+
+// src/adapters/manual.ts
+var ManualAdapter = class {
+  agentId;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  capture(builderFn) {
+    const builder = new TraceBuilder(this.agentId);
+    builderFn(builder);
+    return builder.build();
+  }
+  createBuilder() {
+    return new TraceBuilder(this.agentId);
+  }
+};
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class {
+  agentId;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  traceFromResponse(response, options) {
+    const builder = new TraceBuilder(this.agentId);
+    if (options?.inputMessages) {
+      builder.setInput({ messages: options.inputMessages });
+    }
+    const message = response.choices[0].message;
+    const completionText = message.content ?? "";
+    const stepArgs = {};
+    if (response.model !== void 0) stepArgs.model = response.model;
+    const stepResult = { completion: completionText };
+    if (response.usage?.total_tokens !== void 0) {
+      stepResult.tokens = response.usage.total_tokens;
+    }
+    builder.addLlmCall("completion", { args: stepArgs, result: stepResult });
+    if (message.tool_calls) {
+      for (const tc of message.tool_calls) {
+        builder.addToolCall(tc.function.name, {
+          args: { arguments: tc.function.arguments }
+        });
+      }
+    }
+    builder.setOutput({
+      message: completionText,
+      structured: options?.structuredOutput ?? {}
+    });
+    builder.setMetadata({
+      total_tokens: response.usage?.total_tokens,
+      cost_usd: options?.costUsd,
+      latency_ms: options?.latencyMs,
+      model: response.model
+    });
+    return builder.build();
+  }
+};
+
+// src/adapters/anthropic.ts
+var AnthropicAdapter = class {
+  agentId;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  traceFromResponse(response, options) {
+    const builder = new TraceBuilder(this.agentId);
+    if (options?.inputMessages) {
+      builder.setInput({ messages: options.inputMessages });
+    }
+    const completionParts = [];
+    for (const block of response.content) {
+      if (block.type === "text") {
+        completionParts.push(block.text);
+      } else if (block.type === "tool_use") {
+        builder.addToolCall(block.name, {
+          args: block.input
+        });
+      }
+    }
+    const completionText = completionParts.join("\n");
+    const stepArgs = {};
+    if (response.model !== void 0) stepArgs.model = response.model;
+    builder.addLlmCall("completion", { args: stepArgs, result: { completion: completionText } });
+    builder.setOutput({ message: completionText });
+    let totalTokens;
+    if (response.usage) {
+      totalTokens = response.usage.input_tokens + response.usage.output_tokens;
+    }
+    builder.setMetadata({
+      total_tokens: totalTokens,
+      cost_usd: options?.costUsd,
+      latency_ms: options?.latencyMs,
+      model: response.model
+    });
+    return builder.build();
+  }
+};
+
+// src/adapters/gemini.ts
+var GeminiAdapter = class {
+  agentId;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  traceFromResponse(response, options) {
+    const builder = new TraceBuilder(this.agentId);
+    if (options?.inputText) {
+      builder.setInput({ text: options.inputText });
+    }
+    let completionText = "";
+    if (response.text != null) {
+      completionText = response.text;
+    } else if (response.candidates && response.candidates.length > 0) {
+      completionText = response.candidates[0].content.parts.filter((p) => p.text != null).map((p) => p.text).join("");
+    }
+    if (response.candidates && response.candidates.length > 0) {
+      for (const part of response.candidates[0].content.parts) {
+        if (part.functionCall) {
+          builder.addToolCall(part.functionCall.name, {
+            args: part.functionCall.args ?? {}
+          });
+        }
+      }
+    }
+    builder.addLlmCall("completion", { result: { completion: completionText } });
+    builder.setOutput({ message: completionText });
+    builder.setMetadata({
+      cost_usd: options?.costUsd,
+      latency_ms: options?.latencyMs,
+      model: options?.model
+    });
+    return builder.build();
+  }
+};
+
+// src/adapters/ollama.ts
+var OllamaAdapter = class {
+  agentId;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  traceFromResponse(response, options) {
+    const builder = new TraceBuilder(this.agentId);
+    if (options?.inputMessages) {
+      builder.setInput({ messages: options.inputMessages });
+    }
+    const completionText = response.message?.content ?? "";
+    builder.addLlmCall("completion", {
+      args: { model: response.model ?? "" },
+      result: { completion: completionText }
+    });
+    builder.setOutput({ message: completionText });
+    let totalTokens;
+    if (response.eval_count !== void 0 && response.prompt_eval_count !== void 0) {
+      totalTokens = response.eval_count + response.prompt_eval_count;
+    }
+    builder.setMetadata({
+      total_tokens: totalTokens,
+      latency_ms: options?.latencyMs,
+      model: response.model
+    });
+    return builder.build();
+  }
+};
+
+// src/adapters/otel.ts
+var OTelAdapter = class _OTelAdapter {
+  agentId;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  static fromSpans(spans, agentId2) {
+    const adapter = new _OTelAdapter(agentId2);
+    return adapter.buildTrace(spans);
+  }
+  buildTrace(spans) {
+    const sorted = [...spans].sort((a, b) => {
+      const aTime = a.startTime[0] * 1e9 + a.startTime[1];
+      const bTime = b.startTime[0] * 1e9 + b.startTime[1];
+      return aTime - bTime;
+    });
+    const builder = new TraceBuilder(this.agentId);
+    const rootSpan = this.findRootSpan(sorted);
+    if (rootSpan) {
+      const traceId2 = rootSpan.spanContext().traceId;
+      if (traceId2) {
+        builder.setTraceId(`otel_${traceId2.slice(0, 16)}`);
+      }
+    }
+    let outputMessage = "";
+    let totalTokens;
+    let latencyMs;
+    let model;
+    for (const span of sorted) {
+      const attrs = span.attributes ?? {};
+      const stepType = this.classifySpan(attrs, span.name);
+      if (stepType === "llm_call") {
+        const [stepArgs, stepResult] = this.extractLlmStep(attrs);
+        builder.addLlmCall(span.name, {
+          args: stepArgs,
+          result: stepResult,
+          metadata: this.spanMetadata(span)
+        });
+        const completion = attrs["gen_ai.completion"];
+        if (completion) outputMessage = String(completion);
+        const inputTokens = Number(attrs["gen_ai.usage.input_tokens"] ?? 0);
+        const outputTokens = Number(attrs["gen_ai.usage.output_tokens"] ?? 0);
+        const spanTokens = inputTokens + outputTokens;
+        if (spanTokens > 0) totalTokens = (totalTokens ?? 0) + spanTokens;
+        if (model === void 0) {
+          const responseModel = attrs["gen_ai.response.model"];
+          const requestModel = attrs["gen_ai.request.model"];
+          if (responseModel) model = String(responseModel);
+          else if (requestModel) model = String(requestModel);
+        }
+      } else if (stepType === "tool_call") {
+        const [stepArgs, stepResult] = this.extractToolStep(attrs);
+        const toolName = String(attrs["gen_ai.tool.name"] ?? span.name);
+        builder.addToolCall(toolName, {
+          args: stepArgs,
+          result: stepResult,
+          metadata: this.spanMetadata(span)
+        });
+      }
+    }
+    if (rootSpan) {
+      const startNs = rootSpan.startTime[0] * 1e9 + rootSpan.startTime[1];
+      const endNs = rootSpan.endTime[0] * 1e9 + rootSpan.endTime[1];
+      latencyMs = Math.floor((endNs - startNs) / 1e6);
+    }
+    builder.setOutput({ message: outputMessage });
+    builder.setMetadata({ total_tokens: totalTokens, latency_ms: latencyMs, model });
+    return builder.build();
+  }
+  findRootSpan(spans) {
+    for (const span of spans) {
+      if (!span.parentSpanId) return span;
+    }
+    return spans[0];
+  }
+  classifySpan(attrs, name) {
+    const op = String(attrs["gen_ai.operation.name"] ?? "");
+    if (op === "chat" || op === "completion" || op === "generate_content" || "gen_ai.completion" in attrs) {
+      return "llm_call";
+    }
+    if (op === "tool" || "gen_ai.tool.name" in attrs) {
+      return "tool_call";
+    }
+    const lower = name.toLowerCase();
+    if (lower.includes("completion") || lower.includes("chat")) return "llm_call";
+    if (lower.includes("tool")) return "tool_call";
+    return void 0;
+  }
+  extractLlmStep(attrs) {
+    const args = {};
+    const result = {};
+    if ("gen_ai.request.model" in attrs) args.model = String(attrs["gen_ai.request.model"]);
+    if ("gen_ai.system" in attrs) args.system = String(attrs["gen_ai.system"]);
+    if ("gen_ai.prompt" in attrs) args.prompt = String(attrs["gen_ai.prompt"]);
+    if ("gen_ai.completion" in attrs) result.completion = String(attrs["gen_ai.completion"]);
+    if ("gen_ai.usage.input_tokens" in attrs) result.input_tokens = Number(attrs["gen_ai.usage.input_tokens"]);
+    if ("gen_ai.usage.output_tokens" in attrs) result.output_tokens = Number(attrs["gen_ai.usage.output_tokens"]);
+    if ("gen_ai.response.model" in attrs) result.model = String(attrs["gen_ai.response.model"]);
+    return [args, result];
+  }
+  extractToolStep(attrs) {
+    const args = {};
+    const result = {};
+    if ("gen_ai.tool.call.id" in attrs) args.call_id = String(attrs["gen_ai.tool.call.id"]);
+    if ("gen_ai.tool.parameters" in attrs) args.parameters = attrs["gen_ai.tool.parameters"];
+    if ("gen_ai.tool.output" in attrs) result.output = attrs["gen_ai.tool.output"];
+    return [args, result];
+  }
+  spanMetadata(span) {
+    const startNs = span.startTime[0] * 1e9 + span.startTime[1];
+    const endNs = span.endTime[0] * 1e9 + span.endTime[1];
+    return { duration_ms: Math.floor((endNs - startNs) / 1e6) };
+  }
+};
+
+// src/adapters/langchain.ts
+var LangChainAdapter = class {
+  agentId;
+  llmCalls = [];
+  toolCalls = [];
+  chainOutput = "";
+  startTime = 0;
+  constructor(agentId2) {
+    this.agentId = agentId2;
+  }
+  /**
+   * Reset accumulated state for a new trace capture session.
+   */
+  reset() {
+    this.llmCalls.length = 0;
+    this.toolCalls.length = 0;
+    this.chainOutput = "";
+    this.startTime = 0;
+  }
+  /**
+   * Call this when a chain starts (maps to `handleChainStart`).
+   */
+  handleChainStart() {
+    if (this.startTime === 0) {
+      this.startTime = Date.now();
+    }
+  }
+  /**
+   * Call this when an LLM call completes (maps to `handleLLMEnd`).
+   */
+  handleLLMEnd(output) {
+    const text = output.generations[0]?.[0]?.text ?? "";
+    const tokens = output.llmOutput?.["tokenUsage"];
+    const model = output.llmOutput?.["modelName"];
+    this.llmCalls.push({
+      name: "completion",
+      text,
+      tokens: tokens?.totalTokens,
+      model
+    });
+  }
+  /**
+   * Call this when a tool call completes (maps to `handleToolEnd`).
+   */
+  handleToolEnd(output, metadata) {
+    this.toolCalls.push({
+      name: metadata?.name ?? "unknown_tool",
+      output
+    });
+  }
+  /**
+   * Call this when a chain completes (maps to `handleChainEnd`).
+   */
+  handleChainEnd(output) {
+    const text = output["output"] ?? output["text"] ?? output["result"];
+    if (typeof text === "string") {
+      this.chainOutput = text;
+    }
+  }
+  /**
+   * Build a Trace from accumulated callback events.
+   *
+   * @param options.costUsd - Total cost override.
+   * @param options.model - Model name override.
+   * @returns A finalized Trace object.
+   */
+  buildTrace(options) {
+    const builder = new TraceBuilder(this.agentId);
+    const latencyMs = this.startTime > 0 ? Date.now() - this.startTime : void 0;
+    let totalTokens;
+    for (const llm of this.llmCalls) {
+      const args = {};
+      if (llm.model ?? options?.model) args.model = llm.model ?? options?.model;
+      const result = { completion: llm.text };
+      if (llm.tokens !== void 0) {
+        result.tokens = llm.tokens;
+        totalTokens = (totalTokens ?? 0) + llm.tokens;
+      }
+      builder.addLlmCall(llm.name, { args, result });
+    }
+    for (const tool of this.toolCalls) {
+      builder.addToolCall(tool.name, {
+        result: { output: tool.output }
+      });
+    }
+    const outputMessage = this.chainOutput || (this.llmCalls.length > 0 ? this.llmCalls[this.llmCalls.length - 1].text : "");
+    builder.setOutput({ message: outputMessage });
+    builder.setMetadata({
+      total_tokens: totalTokens,
+      cost_usd: options?.costUsd,
+      latency_ms: latencyMs,
+      model: options?.model ?? this.llmCalls[0]?.model
+    });
+    return builder.build();
+  }
+};
+export {
+  Agent,
+  AgentResult,
+  AlertDispatcher,
+  AnthropicAdapter,
+  AttestClient,
+  ContinuousEvalRunner,
+  ENGINE_VERSION,
+  ERR_ASSERTION_ERROR,
+  ERR_ENGINE_ERROR,
+  ERR_INVALID_TRACE,
+  ERR_PROVIDER_ERROR,
+  ERR_SESSION_ERROR,
+  ERR_TIMEOUT,
+  EngineManager,
+  EngineTimeoutError,
+  ExpectChain,
+  GeminiAdapter,
+  LangChainAdapter,
+  ManualAdapter,
+  OTelAdapter,
+  OllamaAdapter,
+  OpenAIAdapter,
+  PluginRegistry,
+  ProtocolError,
+  STATUS_HARD_FAIL,
+  STATUS_PASS,
+  STATUS_SOFT_FAIL,
+  STEP_AGENT_CALL,
+  STEP_LLM_CALL,
+  STEP_RETRIEVAL,
+  STEP_TOOL_CALL,
+  Sampler,
+  TIER_1,
+  TIER_2,
+  TIER_3,
+  TYPE_CONSTRAINT,
+  TYPE_CONTENT,
+  TYPE_EMBEDDING,
+  TYPE_LLM_JUDGE,
+  TYPE_PLUGIN,
+  TYPE_SCHEMA,
+  TYPE_TRACE,
+  TYPE_TRACE_TREE,
+  TraceBuilder,
+  TraceTree,
+  VERSION,
+  activeBuilder,
+  agent,
+  agentId,
+  assertionId,
+  attestExpect,
+  config,
+  decodeResponse,
+  delegate,
+  encodeRequest,
+  executePluginAssertion,
+  extractId,
+  extractResult,
+  isSimulationMode,
+  resetConfig,
+  tier,
+  traceId
+};
+//# sourceMappingURL=index.js.map