@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/emitter-CPBAhxum.js

@@ -0,0 +1,266 @@
+//#region src/trace/emitter.ts
+var TraceEmitter = class {
+	store;
+	stack = [];
+	_runId;
+	now;
+	id;
+	hooks;
+	hookErrors;
+	constructor(store, options = {}) {
+		this.store = store;
+		this.now = options.now ?? (() => Date.now());
+		this.id = options.id ?? (() => cryptoRandomId());
+		this._runId = options.runId ?? this.id();
+		this.hooks = options.onRunComplete ?? [];
+		this.hookErrors = options.hookErrors ?? "swallow";
+	}
+	get runId() {
+		return this._runId;
+	}
+	get traceStore() {
+		return this.store;
+	}
+	/** Append a hook after construction (e.g. attach the trace analyst). */
+	addRunCompleteHook(hook) {
+		this.hooks.push(hook);
+	}
+	/**
+	* Begin a Run.
+	*
+	* `scenarioId` is required on the persisted Run shape — every Run downstream
+	* gets a non-empty scenarioId so filters and aggregations stay simple — but
+	* the INPUT here accepts it as optional. When omitted, startRun substitutes
+	* a sensible default (`run.layer ?? run.tags?.['kind'] ?? 'runtime'`) so
+	* runtime / operator / meta-eval runs that have no curated-scenario corpus
+	* to anchor to don't have to invent placeholder strings at the call site.
+	*/
+	async startRun(run) {
+		const scenarioId = run.scenarioId ?? run.layer ?? run.tags?.kind ?? "runtime";
+		const full = {
+			...run,
+			scenarioId,
+			runId: this._runId,
+			startedAt: this.now(),
+			status: "running"
+		};
+		await this.store.appendRun(full);
+		return full;
+	}
+	async endRun(outcome) {
+		const status = outcome?.pass === false ? "failed" : "completed";
+		await this.store.updateRun(this._runId, {
+			endedAt: this.now(),
+			status,
+			outcome
+		});
+		await this.runHooks({
+			runId: this._runId,
+			emitter: this,
+			store: this.store,
+			outcome,
+			status
+		});
+	}
+	async abortRun(reason) {
+		const outcome = {
+			pass: false,
+			notes: reason
+		};
+		await this.store.updateRun(this._runId, {
+			endedAt: this.now(),
+			status: "aborted",
+			outcome
+		});
+		await this.runHooks({
+			runId: this._runId,
+			emitter: this,
+			store: this.store,
+			outcome,
+			status: "aborted"
+		});
+	}
+	async runHooks(ctx) {
+		for (const hook of this.hooks) try {
+			await hook(ctx);
+		} catch (err) {
+			if (this.hookErrors === "throw") throw err;
+			try {
+				await this.store.appendEvent({
+					eventId: this.id(),
+					runId: this._runId,
+					kind: "log",
+					timestamp: this.now(),
+					payload: {
+						source: "run_complete_hook",
+						error: err instanceof Error ? err.message : String(err)
+					}
+				});
+			} catch {}
+		}
+	}
+	async span(init) {
+		const spanId = this.id();
+		const span = {
+			spanId,
+			parentSpanId: init.parentSpanId ?? this.stack[this.stack.length - 1],
+			runId: this._runId,
+			startedAt: this.now(),
+			...init
+		};
+		await this.store.appendSpan(span);
+		this.stack.push(spanId);
+		return this.handle(span);
+	}
+	handle(span) {
+		return {
+			span,
+			end: async (patch) => {
+				const endedAt = this.now();
+				await this.store.updateSpan(span.spanId, {
+					endedAt,
+					status: "ok",
+					...patch
+				});
+				this.pop(span.spanId);
+			},
+			fail: async (error, patch) => {
+				const endedAt = this.now();
+				const errStr = error instanceof Error ? error.message : error;
+				await this.store.updateSpan(span.spanId, {
+					endedAt,
+					status: "error",
+					error: errStr,
+					...patch
+				});
+				this.pop(span.spanId);
+			}
+		};
+	}
+	pop(spanId) {
+		const idx = this.stack.lastIndexOf(spanId);
+		if (idx >= 0) this.stack.splice(idx, 1);
+	}
+	llm(init) {
+		return this.span({
+			kind: "llm",
+			...init
+		});
+	}
+	tool(init) {
+		return this.span({
+			kind: "tool",
+			...init
+		});
+	}
+	retrieval(init) {
+		return this.span({
+			kind: "retrieval",
+			...init
+		});
+	}
+	async recordJudge(verdict) {
+		const spanId = this.id();
+		const now = this.now();
+		const full = {
+			spanId,
+			runId: this._runId,
+			kind: "judge",
+			startedAt: now,
+			endedAt: now,
+			status: "ok",
+			...verdict
+		};
+		await this.store.appendSpan(full);
+		return full;
+	}
+	sandbox(init) {
+		return this.span({
+			kind: "sandbox",
+			...init
+		});
+	}
+	async emit(event) {
+		const full = {
+			eventId: this.id(),
+			runId: this._runId,
+			spanId: event.spanId ?? this.stack[this.stack.length - 1],
+			kind: event.kind,
+			timestamp: this.now(),
+			payload: event.payload ?? {}
+		};
+		await this.store.appendEvent(full);
+		return full;
+	}
+	async recordBudget(entry) {
+		const full = {
+			runId: this._runId,
+			timestamp: entry.timestamp ?? this.now(),
+			dimension: entry.dimension,
+			limit: entry.limit,
+			consumed: entry.consumed,
+			remaining: entry.remaining,
+			breached: entry.breached,
+			spanId: entry.spanId ?? this.stack[this.stack.length - 1]
+		};
+		await this.store.appendBudgetEntry(full);
+		if (full.breached) await this.emit({
+			kind: "budget_breach",
+			spanId: full.spanId,
+			payload: {
+				dimension: full.dimension,
+				limit: full.limit,
+				consumed: full.consumed
+			}
+		});
+		return full;
+	}
+	async recordArtifact(artifact) {
+		const full = {
+			artifactId: this.id(),
+			runId: this._runId,
+			...artifact
+		};
+		await this.store.appendArtifact(full);
+		return full;
+	}
+	/**
+	* Runs `fn` inside a span; auto-ends on success, auto-fails on throw.
+	* Returns the fn's return value. Use this for the 95% case.
+	*/
+	async within(init, fn) {
+		const handle = await this.span(init);
+		try {
+			const result = await fn(handle);
+			await handle.end();
+			return result;
+		} catch (err) {
+			await handle.fail(err instanceof Error ? err : String(err));
+			throw err;
+		}
+	}
+};
+function cryptoRandomId() {
+	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Helper to build an LLM span handle args object from a provider-shaped response. */
+function llmSpanFromProvider(args) {
+	return {
+		name: args.name ?? args.model,
+		model: args.model,
+		messages: args.messages,
+		output: args.output,
+		inputTokens: args.usage?.inputTokens,
+		outputTokens: args.usage?.outputTokens,
+		cachedTokens: args.usage?.cachedTokens,
+		cacheWriteTokens: args.usage?.cacheWriteTokens,
+		reasoningTokens: args.usage?.reasoningTokens,
+		costUsd: args.costUsd,
+		finishReason: args.finishReason
+	};
+}
+//#endregion
+export { llmSpanFromProvider as n, TraceEmitter as t };
+
+//# sourceMappingURL=emitter-CPBAhxum.js.map

package/dist/emitter-CPBAhxum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter-CPBAhxum.js","names":[],"sources":["../src/trace/emitter.ts"],"sourcesContent":["/**\n * TraceEmitter — hierarchical span builder that auto-parents using an\n * internal stack. One emitter per Run; emitters do NOT share state.\n *\n * Convenience methods (`llm`, `tool`, `retrieval`, `judge`, `sandbox`)\n * return a `SpanHandle` with `.end()` / `.fail()` so callers don't\n * have to thread spanIds manually. For async workflows that can't use\n * the stack (e.g. fan-out parallel calls), pass `parentSpanId`\n * explicitly.\n */\n\nimport type {\n  Artifact,\n  BudgetLedgerEntry,\n  EventKind,\n  JudgeSpan,\n  LlmSpan,\n  Message,\n  RetrievalSpan,\n  Run,\n  RunOutcome,\n  SandboxSpan,\n  Span,\n  SpanKind,\n  ToolSpan,\n  TraceEvent,\n} from './schema'\nimport type { TraceStore } from './store'\n\nexport interface SpanHandle<S extends Span = Span> {\n  span: S\n  end(patch?: Partial<S>): Promise<void>\n  fail(error: string | Error, patch?: Partial<S>): Promise<void>\n}\n\nexport interface RunCompleteHookContext {\n  runId: string\n  emitter: TraceEmitter\n  store: TraceStore\n  /** Outcome the caller passed to `endRun` (undefined for `abortRun`). */\n  outcome?: RunOutcome\n  /** Final run status. */\n  status: 'completed' | 'failed' | 'aborted'\n}\n\nexport type RunCompleteHook = (ctx: RunCompleteHookContext) => Promise<void> | void\n\nexport interface TraceEmitterOptions {\n  runId?: string\n  /** Inject a clock for deterministic tests. */\n  now?: () => number\n  /** Inject an id generator for deterministic tests. */\n  id?: () => string\n  /**\n   * Hooks fired after `endRun` / `abortRun` writes the final run state.\n   * Designed for trace-analyst auto-execution, integrity assertions, and\n   * outbound notifications. Hooks run sequentially in the order supplied.\n   *\n   * By default a hook that throws is swallowed and logged as a `note` event\n   * on the run — auto-orchestration must not crash the underlying flow.\n   * Set `hookErrors: 'throw'` to propagate.\n   */\n  onRunComplete?: RunCompleteHook[]\n  /** `'swallow'` (default) | `'throw'`. */\n  hookErrors?: 'swallow' | 'throw'\n}\n\nexport class TraceEmitter {\n  private store: TraceStore\n  private stack: string[] = []\n  private _runId: string\n  private now: () => number\n  private id: () => string\n  private hooks: RunCompleteHook[]\n  private hookErrors: 'swallow' | 'throw'\n\n  constructor(store: TraceStore, options: TraceEmitterOptions = {}) {\n    this.store = store\n    this.now = options.now ?? (() => Date.now())\n    this.id = options.id ?? (() => cryptoRandomId())\n    this._runId = options.runId ?? this.id()\n    this.hooks = options.onRunComplete ?? []\n    this.hookErrors = options.hookErrors ?? 'swallow'\n  }\n\n  get runId(): string {\n    return this._runId\n  }\n\n  get traceStore(): TraceStore {\n    return this.store\n  }\n\n  /** Append a hook after construction (e.g. attach the trace analyst). */\n  addRunCompleteHook(hook: RunCompleteHook): void {\n    this.hooks.push(hook)\n  }\n\n  // ── Run lifecycle ──────────────────────────────────────────────────\n\n  /**\n   * Begin a Run.\n   *\n   * `scenarioId` is required on the persisted Run shape — every Run downstream\n   * gets a non-empty scenarioId so filters and aggregations stay simple — but\n   * the INPUT here accepts it as optional. When omitted, startRun substitutes\n   * a sensible default (`run.layer ?? run.tags?.['kind'] ?? 'runtime'`) so\n   * runtime / operator / meta-eval runs that have no curated-scenario corpus\n   * to anchor to don't have to invent placeholder strings at the call site.\n   */\n  async startRun(\n    run: Omit<Run, 'runId' | 'scenarioId' | 'startedAt' | 'status'> & { scenarioId?: string },\n  ): Promise<Run> {\n    const scenarioId = run.scenarioId ?? run.layer ?? run.tags?.kind ?? 'runtime'\n    const full: Run = {\n      ...run,\n      scenarioId,\n      runId: this._runId,\n      startedAt: this.now(),\n      status: 'running',\n    }\n    await this.store.appendRun(full)\n    return full\n  }\n\n  async endRun(outcome?: RunOutcome): Promise<void> {\n    const status: 'completed' | 'failed' = outcome?.pass === false ? 'failed' : 'completed'\n    await this.store.updateRun(this._runId, { endedAt: this.now(), status, outcome })\n    await this.runHooks({ runId: this._runId, emitter: this, store: this.store, outcome, status })\n  }\n\n  async abortRun(reason: string): Promise<void> {\n    const outcome = { pass: false, notes: reason }\n    await this.store.updateRun(this._runId, {\n      endedAt: this.now(),\n      status: 'aborted',\n      outcome,\n    })\n    await this.runHooks({\n      runId: this._runId,\n      emitter: this,\n      store: this.store,\n      outcome,\n      status: 'aborted',\n    })\n  }\n\n  private async runHooks(ctx: RunCompleteHookContext): Promise<void> {\n    for (const hook of this.hooks) {\n      try {\n        await hook(ctx)\n      } catch (err) {\n        if (this.hookErrors === 'throw') throw err\n        try {\n          await this.store.appendEvent({\n            eventId: this.id(),\n            runId: this._runId,\n            kind: 'log',\n            timestamp: this.now(),\n            payload: {\n              source: 'run_complete_hook',\n              error: err instanceof Error ? err.message : String(err),\n            },\n          })\n        } catch {\n          // best-effort\n        }\n      }\n    }\n  }\n\n  // ── Generic span ───────────────────────────────────────────────────\n\n  async span<S extends Span = Span>(\n    init: {\n      kind: SpanKind\n      name: string\n      parentSpanId?: string\n      attributes?: Record<string, unknown>\n    } & Partial<Omit<S, 'spanId' | 'runId' | 'startedAt' | 'kind' | 'name'>>,\n  ): Promise<SpanHandle<S>> {\n    const spanId = this.id()\n    const parent = init.parentSpanId ?? this.stack[this.stack.length - 1]\n    const span = {\n      spanId,\n      parentSpanId: parent,\n      runId: this._runId,\n      startedAt: this.now(),\n      ...init,\n    } as unknown as S\n    await this.store.appendSpan(span)\n    this.stack.push(spanId)\n    return this.handle<S>(span)\n  }\n\n  private handle<S extends Span>(span: S): SpanHandle<S> {\n    return {\n      span,\n      end: async (patch?: Partial<S>) => {\n        const endedAt = this.now()\n        await this.store.updateSpan(span.spanId, {\n          endedAt,\n          status: 'ok',\n          ...patch,\n        } as Partial<Span>)\n        this.pop(span.spanId)\n      },\n      fail: async (error: string | Error, patch?: Partial<S>) => {\n        const endedAt = this.now()\n        const errStr = error instanceof Error ? error.message : error\n        await this.store.updateSpan(span.spanId, {\n          endedAt,\n          status: 'error',\n          error: errStr,\n          ...patch,\n        } as Partial<Span>)\n        this.pop(span.spanId)\n      },\n    }\n  }\n\n  private pop(spanId: string): void {\n    const idx = this.stack.lastIndexOf(spanId)\n    if (idx >= 0) this.stack.splice(idx, 1)\n  }\n\n  // ── Typed span conveniences ────────────────────────────────────────\n\n  llm(\n    init: Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>,\n  ): Promise<SpanHandle<LlmSpan>> {\n    return this.span<LlmSpan>({ kind: 'llm', ...init })\n  }\n\n  tool(\n    init: Omit<ToolSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>,\n  ): Promise<SpanHandle<ToolSpan>> {\n    return this.span<ToolSpan>({ kind: 'tool', ...init })\n  }\n\n  retrieval(\n    init: Omit<RetrievalSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>,\n  ): Promise<SpanHandle<RetrievalSpan>> {\n    return this.span<RetrievalSpan>({ kind: 'retrieval', ...init })\n  }\n\n  async recordJudge(\n    verdict: Omit<JudgeSpan, 'spanId' | 'runId' | 'kind' | 'startedAt' | 'endedAt'>,\n  ): Promise<JudgeSpan> {\n    const spanId = this.id()\n    const now = this.now()\n    const full: JudgeSpan = {\n      spanId,\n      runId: this._runId,\n      kind: 'judge',\n      startedAt: now,\n      endedAt: now,\n      status: 'ok',\n      ...verdict,\n    }\n    await this.store.appendSpan(full)\n    return full\n  }\n\n  sandbox(\n    init: Omit<SandboxSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>,\n  ): Promise<SpanHandle<SandboxSpan>> {\n    return this.span<SandboxSpan>({ kind: 'sandbox', ...init })\n  }\n\n  // ── Events ─────────────────────────────────────────────────────────\n\n  async emit(event: {\n    kind: EventKind\n    spanId?: string\n    payload?: Record<string, unknown>\n  }): Promise<TraceEvent> {\n    const full: TraceEvent = {\n      eventId: this.id(),\n      runId: this._runId,\n      spanId: event.spanId ?? this.stack[this.stack.length - 1],\n      kind: event.kind,\n      timestamp: this.now(),\n      payload: event.payload ?? {},\n    }\n    await this.store.appendEvent(full)\n    return full\n  }\n\n  // ── Budget ledger ──────────────────────────────────────────────────\n\n  async recordBudget(\n    entry: Omit<BudgetLedgerEntry, 'runId' | 'timestamp'> & { timestamp?: number },\n  ): Promise<BudgetLedgerEntry> {\n    const full: BudgetLedgerEntry = {\n      runId: this._runId,\n      timestamp: entry.timestamp ?? this.now(),\n      dimension: entry.dimension,\n      limit: entry.limit,\n      consumed: entry.consumed,\n      remaining: entry.remaining,\n      breached: entry.breached,\n      spanId: entry.spanId ?? this.stack[this.stack.length - 1],\n    }\n    await this.store.appendBudgetEntry(full)\n    if (full.breached) {\n      await this.emit({\n        kind: 'budget_breach',\n        spanId: full.spanId,\n        payload: { dimension: full.dimension, limit: full.limit, consumed: full.consumed },\n      })\n    }\n    return full\n  }\n\n  // ── Artifacts ──────────────────────────────────────────────────────\n\n  async recordArtifact(artifact: Omit<Artifact, 'artifactId' | 'runId'>): Promise<Artifact> {\n    const full: Artifact = { artifactId: this.id(), runId: this._runId, ...artifact }\n    await this.store.appendArtifact(full)\n    return full\n  }\n\n  // ── Nested composition ─────────────────────────────────────────────\n\n  /**\n   * Runs `fn` inside a span; auto-ends on success, auto-fails on throw.\n   * Returns the fn's return value. Use this for the 95% case.\n   */\n  async within<T>(\n    init: Parameters<TraceEmitter['span']>[0],\n    fn: (handle: SpanHandle) => Promise<T>,\n  ): Promise<T> {\n    const handle = await this.span(init)\n    try {\n      const result = await fn(handle)\n      await handle.end()\n      return result\n    } catch (err) {\n      await handle.fail(err instanceof Error ? err : String(err))\n      throw err\n    }\n  }\n}\n\n// Helpers -------------------------------------------------------------\n\nfunction cryptoRandomId(): string {\n  if (typeof globalThis.crypto?.randomUUID === 'function') return globalThis.crypto.randomUUID()\n  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`\n}\n\n/** Helper to build an LLM span handle args object from a provider-shaped response. */\nexport function llmSpanFromProvider(args: {\n  name?: string\n  model: string\n  messages: Message[]\n  output: string\n  usage?: {\n    inputTokens?: number\n    outputTokens?: number\n    cachedTokens?: number\n    cacheWriteTokens?: number\n    reasoningTokens?: number\n  }\n  costUsd?: number\n  finishReason?: string\n}): Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'> {\n  return {\n    name: args.name ?? args.model,\n    model: args.model,\n    messages: args.messages,\n    output: args.output,\n    inputTokens: args.usage?.inputTokens,\n    outputTokens: args.usage?.outputTokens,\n    cachedTokens: args.usage?.cachedTokens,\n    cacheWriteTokens: args.usage?.cacheWriteTokens,\n    reasoningTokens: args.usage?.reasoningTokens,\n    costUsd: args.costUsd,\n    finishReason: args.finishReason,\n  }\n}\n"],"mappings":"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"}

package/dist/emitter-DGQGoLyj.d.ts

@@ -0,0 +1,113 @@
+import { C as TraceEvent, S as ToolSpan, _ as Span, c as JudgeSpan, d as RetrievalSpan, f as Run, g as SandboxSpan, i as EventKind, l as LlmSpan, m as RunOutcome, n as BudgetLedgerEntry, t as Artifact, u as Message, y as SpanKind } from "./schema-BtVldJ3T.js";
+import { s as TraceStore } from "./store-CT9YIIve.js";
+//#region src/trace/emitter.d.ts
+interface SpanHandle<S extends Span = Span> {
+  span: S;
+  end(patch?: Partial<S>): Promise<void>;
+  fail(error: string | Error, patch?: Partial<S>): Promise<void>;
+}
+interface RunCompleteHookContext {
+  runId: string;
+  emitter: TraceEmitter;
+  store: TraceStore;
+  /** Outcome the caller passed to `endRun` (undefined for `abortRun`). */
+  outcome?: RunOutcome;
+  /** Final run status. */
+  status: 'completed' | 'failed' | 'aborted';
+}
+type RunCompleteHook = (ctx: RunCompleteHookContext) => Promise<void> | void;
+interface TraceEmitterOptions {
+  runId?: string;
+  /** Inject a clock for deterministic tests. */
+  now?: () => number;
+  /** Inject an id generator for deterministic tests. */
+  id?: () => string;
+  /**
+   * Hooks fired after `endRun` / `abortRun` writes the final run state.
+   * Designed for trace-analyst auto-execution, integrity assertions, and
+   * outbound notifications. Hooks run sequentially in the order supplied.
+   *
+   * By default a hook that throws is swallowed and logged as a `note` event
+   * on the run — auto-orchestration must not crash the underlying flow.
+   * Set `hookErrors: 'throw'` to propagate.
+   */
+  onRunComplete?: RunCompleteHook[];
+  /** `'swallow'` (default) | `'throw'`. */
+  hookErrors?: 'swallow' | 'throw';
+}
+declare class TraceEmitter {
+  private store;
+  private stack;
+  private _runId;
+  private now;
+  private id;
+  private hooks;
+  private hookErrors;
+  constructor(store: TraceStore, options?: TraceEmitterOptions);
+  get runId(): string;
+  get traceStore(): TraceStore;
+  /** Append a hook after construction (e.g. attach the trace analyst). */
+  addRunCompleteHook(hook: RunCompleteHook): void;
+  /**
+   * Begin a Run.
+   *
+   * `scenarioId` is required on the persisted Run shape — every Run downstream
+   * gets a non-empty scenarioId so filters and aggregations stay simple — but
+   * the INPUT here accepts it as optional. When omitted, startRun substitutes
+   * a sensible default (`run.layer ?? run.tags?.['kind'] ?? 'runtime'`) so
+   * runtime / operator / meta-eval runs that have no curated-scenario corpus
+   * to anchor to don't have to invent placeholder strings at the call site.
+   */
+  startRun(run: Omit<Run, 'runId' | 'scenarioId' | 'startedAt' | 'status'> & {
+    scenarioId?: string;
+  }): Promise<Run>;
+  endRun(outcome?: RunOutcome): Promise<void>;
+  abortRun(reason: string): Promise<void>;
+  private runHooks;
+  span<S extends Span = Span>(init: {
+    kind: SpanKind;
+    name: string;
+    parentSpanId?: string;
+    attributes?: Record<string, unknown>;
+  } & Partial<Omit<S, 'spanId' | 'runId' | 'startedAt' | 'kind' | 'name'>>): Promise<SpanHandle<S>>;
+  private handle;
+  private pop;
+  llm(init: Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<LlmSpan>>;
+  tool(init: Omit<ToolSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<ToolSpan>>;
+  retrieval(init: Omit<RetrievalSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<RetrievalSpan>>;
+  recordJudge(verdict: Omit<JudgeSpan, 'spanId' | 'runId' | 'kind' | 'startedAt' | 'endedAt'>): Promise<JudgeSpan>;
+  sandbox(init: Omit<SandboxSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<SandboxSpan>>;
+  emit(event: {
+    kind: EventKind;
+    spanId?: string;
+    payload?: Record<string, unknown>;
+  }): Promise<TraceEvent>;
+  recordBudget(entry: Omit<BudgetLedgerEntry, 'runId' | 'timestamp'> & {
+    timestamp?: number;
+  }): Promise<BudgetLedgerEntry>;
+  recordArtifact(artifact: Omit<Artifact, 'artifactId' | 'runId'>): Promise<Artifact>;
+  /**
+   * Runs `fn` inside a span; auto-ends on success, auto-fails on throw.
+   * Returns the fn's return value. Use this for the 95% case.
+   */
+  within<T>(init: Parameters<TraceEmitter['span']>[0], fn: (handle: SpanHandle) => Promise<T>): Promise<T>;
+}
+/** Helper to build an LLM span handle args object from a provider-shaped response. */
+declare function llmSpanFromProvider(args: {
+  name?: string;
+  model: string;
+  messages: Message[];
+  output: string;
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+  };
+  costUsd?: number;
+  finishReason?: string;
+}): Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>;
+//#endregion
+export { TraceEmitterOptions as a, TraceEmitter as i, RunCompleteHookContext as n, llmSpanFromProvider as o, SpanHandle as r, RunCompleteHook as t };
+//# sourceMappingURL=emitter-DGQGoLyj.d.ts.map

package/dist/emitter-DGQGoLyj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter-DGQGoLyj.d.ts","names":[],"sources":["../src/trace/emitter.ts"],"mappings":";;;UA6BiB,WAAW,UAAU,OAAO;EAC3C,MAAM;EACN,IAAI,QAAQ,QAAQ,KAAK;EACzB,KAAK,gBAAgB,OAAO,QAAQ,QAAQ,KAAK;;UAGlC;EACf;EACA,SAAS;EACT,OAAO;;EAEP,UAAU;;EAEV;;KAGU,mBAAmB,KAAK,2BAA2B;UAE9C;EACf;;EAEA;;EAEA;;;;;;;;;;EAUA,gBAAgB;;EAEhB;;cAGW;UACH;UACA;UACA;UACA;UACA;UACA;UACA;EAER,YAAY,OAAO,YAAY,UAAS;MASpC;MAIA,cAAc;;EAKlB,mBAAmB,MAAM;;;;;;;;;;;EAgBnB,SACJ,KAAK,KAAK;IAA0D;MACnE,QAAQ;EAaL,OAAO,UAAU,aAAa;EAM9B,SAAS,iBAAiB;UAgBlB;EA0BR,KAAK,UAAU,OAAO,MAC1B;IACE,MAAM;IACN;IACA;IACA,aAAa;MACX,QAAQ,KAAK,0DAChB,QAAQ,WAAW;UAed;UA0BA;EAOR,IACE,MAAM,KAAK,sDACV,QAAQ,WAAW;EAItB,KACE,MAAM,KAAK,uDACV,QAAQ,WAAW;EAItB,UACE,MAAM,KAAK,4DACV,QAAQ,WAAW;EAIhB,YACJ,SAAS,KAAK,oEACb,QAAQ;EAgBX,QACE,MAAM,KAAK,0DACV,QAAQ,WAAW;EAMhB,KAAK;IACT,MAAM;IACN;IACA,UAAU;MACR,QAAQ;EAeN,aACJ,OAAO,KAAK;IAA8C;MACzD,QAAQ;EAwBL,eAAe,UAAU,KAAK,oCAAoC,QAAQ;;;;;EAY1E,OAAO,GACX,MAAM,WAAW,0BACjB,KAAK,QAAQ,eAAe,QAAQ,KACnC,QAAQ;;;iBAqBG,oBAAoB;EAClC;EACA;EACA,UAAU;EACV;EACA;IACE;IACA;IACA;IACA;IACA;;EAEF;EACA;IACE,KAAK"}

package/dist/errors-8YnH8WlF.js

@@ -0,0 +1,64 @@
+//#region src/errors.ts
+/**
+* Base class for every contract error this package throws — carries the stable
+* string `code` taxonomy so consumers can `instanceof`-match or switch on `code`.
+*/
+var AgentEvalError = class extends Error {
+	/** Stable string code. Survives minification; safe to switch on. */
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = this.constructor.name;
+		this.code = code;
+	}
+};
+/** Caller passed invalid arguments (out of range, mutually-exclusive options, bad shape). */
+var ValidationError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("validation", message, options);
+	}
+};
+/** A named resource (run, span, rubric, scenario, dataset row, route) does not exist. */
+var NotFoundError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("not_found", message, options);
+	}
+};
+/** Configuration missing or malformed (`HOME` unset, required image not supplied, env var absent). */
+var ConfigError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("config", message, options);
+	}
+};
+/**
+* A run is missing the artifacts a launch-grade check requires:
+* raw HTTP capture absent, no LLM spans, route assertion failed, run-end
+* assertion tripped. Block ship on this; do not catch and move on.
+*/
+var CaptureIntegrityError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("capture_integrity", message, options);
+	}
+};
+/** A judge call failed in a way that's not retryable: schema parse failure, bad rubric, conflicting dimensions. */
+var JudgeError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("judge", message, options);
+	}
+};
+/** A verifier signalled a hard failure (compile, test, schema) — distinct from a low judge score. */
+var VerificationError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("verification", message, options);
+	}
+};
+/** Replay cache cannot satisfy a request: miss with no fallback, sink lacks list(), unsupported URL. */
+var ReplayError = class extends AgentEvalError {
+	constructor(message, options) {
+		super("replay", message, options);
+	}
+};
+//#endregion
+export { NotFoundError as a, VerificationError as c, JudgeError as i, CaptureIntegrityError as n, ReplayError as o, ConfigError as r, ValidationError as s, AgentEvalError as t };
+
+//# sourceMappingURL=errors-8YnH8WlF.js.map

package/dist/errors-8YnH8WlF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-8YnH8WlF.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * Error taxonomy for `@tangle-network/agent-eval`.\n *\n * Every error this package throws as part of its *public contract* extends\n * `AgentEvalError`. Consumers can pattern-match by `instanceof <Subclass>` or\n * by the stable string `code` carried on the base class.\n *\n * The codes are stable across minor versions; new codes can be added, but\n * existing codes never change meaning. New subclasses are non-breaking.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error`s on purpose — they're programmer-mistake assertions,\n * not consumer-catchable contract failures.\n */\n\nexport type AgentEvalErrorCode =\n  | 'validation'\n  | 'not_found'\n  | 'config'\n  | 'capture_integrity'\n  | 'judge'\n  | 'verification'\n  | 'replay'\n  | 'backend_integrity'\n  | 'profile_matrix'\n\n/**\n * Base class for every contract error this package throws — carries the stable\n * string `code` taxonomy so consumers can `instanceof`-match or switch on `code`.\n */\nexport class AgentEvalError extends Error {\n  /** Stable string code. Survives minification; safe to switch on. */\n  readonly code: AgentEvalErrorCode\n\n  constructor(code: AgentEvalErrorCode, message: string, options?: { cause?: unknown }) {\n    super(message, options)\n    this.name = this.constructor.name\n    this.code = code\n  }\n}\n\n/** Caller passed invalid arguments (out of range, mutually-exclusive options, bad shape). */\nexport class ValidationError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/** A named resource (run, span, rubric, scenario, dataset row, route) does not exist. */\nexport class NotFoundError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('not_found', message, options)\n  }\n}\n\n/** Configuration missing or malformed (`HOME` unset, required image not supplied, env var absent). */\nexport class ConfigError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('config', message, options)\n  }\n}\n\n/**\n * A run is missing the artifacts a launch-grade check requires:\n * raw HTTP capture absent, no LLM spans, route assertion failed, run-end\n * assertion tripped. Block ship on this; do not catch and move on.\n */\nexport class CaptureIntegrityError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('capture_integrity', message, options)\n  }\n}\n\n/** A judge call failed in a way that's not retryable: schema parse failure, bad rubric, conflicting dimensions. */\nexport class JudgeError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('judge', message, options)\n  }\n}\n\n/** A verifier signalled a hard failure (compile, test, schema) — distinct from a low judge score. */\nexport class VerificationError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('verification', message, options)\n  }\n}\n\n/** Replay cache cannot satisfy a request: miss with no fallback, sink lacks list(), unsupported URL. */\nexport class ReplayError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('replay', message, options)\n  }\n}\n"],"mappings":";;;;;AA8BA,IAAa,iBAAb,cAAoC,MAAM;;CAExC;CAEA,YAAY,MAA0B,SAAiB,SAA+B;EACpF,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO,KAAK,YAAY;EAC7B,KAAK,OAAO;CACd;AACF;;AAGA,IAAa,kBAAb,cAAqC,eAAe;CAClD,YAAY,SAAiB,SAA+B;EAC1D,MAAM,cAAc,SAAS,OAAO;CACtC;AACF;;AAGA,IAAa,gBAAb,cAAmC,eAAe;CAChD,YAAY,SAAiB,SAA+B;EAC1D,MAAM,aAAa,SAAS,OAAO;CACrC;AACF;;AAGA,IAAa,cAAb,cAAiC,eAAe;CAC9C,YAAY,SAAiB,SAA+B;EAC1D,MAAM,UAAU,SAAS,OAAO;CAClC;AACF;;;;;;AAOA,IAAa,wBAAb,cAA2C,eAAe;CACxD,YAAY,SAAiB,SAA+B;EAC1D,MAAM,qBAAqB,SAAS,OAAO;CAC7C;AACF;;AAGA,IAAa,aAAb,cAAgC,eAAe;CAC7C,YAAY,SAAiB,SAA+B;EAC1D,MAAM,SAAS,SAAS,OAAO;CACjC;AACF;;AAGA,IAAa,oBAAb,cAAuC,eAAe;CACpD,YAAY,SAAiB,SAA+B;EAC1D,MAAM,gBAAgB,SAAS,OAAO;CACxC;AACF;;AAGA,IAAa,cAAb,cAAiC,eAAe;CAC9C,YAAY,SAAiB,SAA+B;EAC1D,MAAM,UAAU,SAAS,OAAO;CAClC;AACF"}

package/dist/errors-CEk209JS.d.ts

@@ -0,0 +1,76 @@
+//#region src/errors.d.ts
+/**
+ * Error taxonomy for `@tangle-network/agent-eval`.
+ *
+ * Every error this package throws as part of its *public contract* extends
+ * `AgentEvalError`. Consumers can pattern-match by `instanceof <Subclass>` or
+ * by the stable string `code` carried on the base class.
+ *
+ * The codes are stable across minor versions; new codes can be added, but
+ * existing codes never change meaning. New subclasses are non-breaking.
+ *
+ * Internal invariant guards (`throw new Error('this should never happen')`)
+ * remain plain `Error`s on purpose — they're programmer-mistake assertions,
+ * not consumer-catchable contract failures.
+ */
+type AgentEvalErrorCode = 'validation' | 'not_found' | 'config' | 'capture_integrity' | 'judge' | 'verification' | 'replay' | 'backend_integrity' | 'profile_matrix';
+/**
+ * Base class for every contract error this package throws — carries the stable
+ * string `code` taxonomy so consumers can `instanceof`-match or switch on `code`.
+ */
+declare class AgentEvalError extends Error {
+  /** Stable string code. Survives minification; safe to switch on. */
+  readonly code: AgentEvalErrorCode;
+  constructor(code: AgentEvalErrorCode, message: string, options?: {
+    cause?: unknown;
+  });
+}
+/** Caller passed invalid arguments (out of range, mutually-exclusive options, bad shape). */
+declare class ValidationError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/** A named resource (run, span, rubric, scenario, dataset row, route) does not exist. */
+declare class NotFoundError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/** Configuration missing or malformed (`HOME` unset, required image not supplied, env var absent). */
+declare class ConfigError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ * A run is missing the artifacts a launch-grade check requires:
+ * raw HTTP capture absent, no LLM spans, route assertion failed, run-end
+ * assertion tripped. Block ship on this; do not catch and move on.
+ */
+declare class CaptureIntegrityError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/** A judge call failed in a way that's not retryable: schema parse failure, bad rubric, conflicting dimensions. */
+declare class JudgeError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/** A verifier signalled a hard failure (compile, test, schema) — distinct from a low judge score. */
+declare class VerificationError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/** Replay cache cannot satisfy a request: miss with no fallback, sink lacks list(), unsupported URL. */
+declare class ReplayError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+export { JudgeError as a, ValidationError as c, ConfigError as i, VerificationError as l, AgentEvalErrorCode as n, NotFoundError as o, CaptureIntegrityError as r, ReplayError as s, AgentEvalError as t };
+//# sourceMappingURL=errors-CEk209JS.d.ts.map

package/dist/errors-CEk209JS.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-CEk209JS.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;;;;;KAeY;;;;;cAeC,uBAAuB;;WAEzB,MAAM;EAEf,YAAY,MAAM,oBAAoB,iBAAiB;IAAY;;;;cAQxD,wBAAwB;EACnC,YAAY,iBAAiB;IAAY;;;;cAM9B,sBAAsB;EACjC,YAAY,iBAAiB;IAAY;;;;cAM9B,oBAAoB;EAC/B,YAAY,iBAAiB;IAAY;;;;;;;;cAU9B,8BAA8B;EACzC,YAAY,iBAAiB;IAAY;;;;cAM9B,mBAAmB;EAC9B,YAAY,iBAAiB;IAAY;;;;cAM9B,0BAA0B;EACrC,YAAY,iBAAiB;IAAY;;;;cAM9B,oBAAoB;EAC/B,YAAY,iBAAiB;IAAY"}