@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/replay-DbhZ4Ked.d.ts

@@ -1,834 +0,0 @@
-import { c as ReplayError, l as ValidationError, o as LimitExceededError, r as CaptureIntegrityError, s as NotFoundError, t as AgentEvalError } from "./errors-CKPfb2aH.js";
-import { c as CostLedgerHandle } from "./cost-ledger-Bv_e8XHY.js";
-import { S as ToolSpan, f as Run } from "./schema-BtVldJ3T.js";
-import { a as RunRecord, l as RunTerminalOutcome, s as RunSplitTag, u as RunTokenUsage } from "./run-record-CF4Dwpxr.js";
-import { Ft as RawProviderSink, Pt as RawProviderEvent } from "./types-D216SgwM.js";
-import { s as TraceStore } from "./store-CT9YIIve.js";
-import { n as RunCompleteHookContext, t as RunCompleteHook } from "./emitter-DGQGoLyj.js";
-import { A as SearchSpanResult, B as ViewSpansResult, D as DatasetOverview, F as TraceAnalystFilters, H as ViewTraceResult, L as TraceAnalystSpanKind, R as TraceAnalystSpanStatus, S as BoundedTraceAnalysisStoreOptions, T as TraceAnalysisStoreContext, f as AnalystUsageReceipt, i as AnalystFinding, j as SearchTraceResult, k as QueryTracesPage, w as TraceAnalysisStore } from "./types-BvDKaULh.js";
-import { a as TraceAnalystLimits, i as TraceAnalysisEngineResult, n as TraceAnalysisEngine } from "./engine-3hL-XqwJ.js";
-import { t as TraceToolGroupName } from "./tool-groups-CZPGGlHf.js";
-//#region src/trace/otel.d.ts
-declare const OTEL_AGENT_EVAL_SCOPE: {
-  name: string;
-  version: string;
-};
-interface OtlpSpan {
-  traceId: string;
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  kind: number;
-  startTimeUnixNano: string;
-  endTimeUnixNano: string;
-  attributes: Array<{
-    key: string;
-    value: {
-      stringValue?: string;
-      intValue?: string;
-      doubleValue?: number;
-      boolValue?: boolean;
-    };
-  }>;
-  events?: Array<{
-    timeUnixNano: string;
-    name: string;
-    attributes?: OtlpSpan['attributes'];
-  }>;
-  status?: {
-    code: number;
-    message?: string;
-  };
-}
-interface OtlpResourceSpans {
-  resource: {
-    attributes: OtlpSpan['attributes'];
-  };
-  scopeSpans: Array<{
-    scope: typeof OTEL_AGENT_EVAL_SCOPE;
-    spans: OtlpSpan[];
-  }>;
-}
-interface OtlpExport {
-  resourceSpans: OtlpResourceSpans[];
-}
-/** Export a single run's spans + events in OTLP/JSON. */
-declare function exportRunAsOtlp(store: TraceStore, runId: string, resourceAttrs?: Record<string, string | number | boolean>): Promise<OtlpExport>;
-//#endregion
-//#region src/trace/otlp-attributes.d.ts
-type ToolSpanOtlpInput = Pick<ToolSpan, 'toolName' | 'args' | 'argsCaptured' | 'result' | 'latencyMs'>;
-type OtlpSpanRole = 'AGENT' | 'CHAIN' | 'EVALUATOR' | 'GUARDRAIL' | 'LLM' | 'SPAN' | 'TOOL' | 'UNKNOWN';
-interface OtlpSpanRoleInput {
-  name: string;
-  attributes: Record<string, unknown>;
-  kind?: string | null;
-}
-/**
- * Classify a span once for both measurement and error accounting.
- * An explicit OpenInference kind wins; untyped spans use the same tool and
- * model signals in online and offline intake.
- */
-declare function classifyOtlpSpanRole(input: OtlpSpanRoleInput): OtlpSpanRole;
-declare function isOtlpModelCall(input: OtlpSpanRoleInput): boolean;
-declare function applyToolSpanOtlpAttributes(attributes: Record<string, unknown>, span: ToolSpanOtlpInput): void;
-declare function traceSpanKindToOpenInferenceKind(kind: string): string;
-//#endregion
-//#region src/trace/otel-export.d.ts
-interface OtelExportConfig {
-  /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */
-  endpoint?: string;
-  /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */
-  headers?: Record<string, string>;
-  /** Batch size before flush. Default 64. */
-  batchSize?: number;
-  /** Flush interval ms. Default 5000. */
-  flushIntervalMs?: number;
-  /** Resource attributes stamped on every export. */
-  resourceAttributes?: Record<string, string | number | boolean>;
-  /** Service name. Default 'agent-eval'. */
-  serviceName?: string;
-}
-interface OtelExporter {
-  /** Called by the TraceEmitter on every span close. */
-  exportSpan(span: ExportableSpan): void;
-  /** Force flush pending spans. */
-  flush(): Promise<void>;
-  /** Shutdown cleanly — flushes remaining spans and stops the timer. */
-  shutdown(): Promise<void>;
-}
-interface ExportableSpan {
-  traceId: string;
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  kind: string;
-  startedAt: number;
-  endedAt?: number;
-  status?: string;
-  error?: string;
-  model?: string;
-  inputTokens?: number;
-  outputTokens?: number;
-  reasoningTokens?: number;
-  cachedTokens?: number;
-  cacheWriteTokens?: number;
-  costUsd?: number;
-  tool?: ToolSpanOtlpInput;
-  attributes?: Record<string, unknown>;
-}
-/**
- * Create an OTEL exporter. Returns undefined when no endpoint is configured
- * (neither via config nor env) — callers should check before attaching.
- */
-declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
-//#endregion
-//#region src/trace/otel-bridge.d.ts
-/**
- * Create a RunCompleteHook that exports all spans from the completed run
- * to the OTEL exporter, then flushes.
- */
-declare function otelRunCompleteHook(exporter: OtelExporter): RunCompleteHook;
-/**
- * Create an auto-exporting TraceStore wrapper that intercepts updateSpan
- * calls. When a span gets an endedAt, it's exported immediately. This
- * gives real-time streaming instead of batch-at-end.
- *
- * This is the preferred integration path: wrap the store before
- * constructing the TraceEmitter.
- */
-declare function createOtelTracingStore(inner: TraceStore, exporter: OtelExporter, traceId: string): TraceStore;
-//#endregion
-//#region src/trace/redact.d.ts
-/**
- * Redaction — remove PII / secrets from trace payloads before persist.
- *
- * Pre-persistence rules mean raw traces in storage are already scrubbed.
- * Unredacted variants (for debugging / post-mortems) live in a separate
- * storage layer with stricter access controls; this module only covers
- * the default scrub-then-persist path.
- *
- * Rules compose: pass an array of `RedactionRule`, each is applied in
- * order. Strings that match get replaced with a tagged sentinel so the
- * eval framework can count how many redactions happened per run
- * (surfaced via `redaction_applied` events).
- */
-interface RedactionRule {
-  id: string;
-  pattern: RegExp;
-  /** Replacement — e.g. '[PII:email]'. Defaults to `[redacted:{id}]`. */
-  replacement?: string;
-}
-interface RedactionReport {
-  redactionCount: number;
-  byRule: Record<string, number>;
-}
-/** OWASP / common-sense defaults — extend per-domain. */
-declare const DEFAULT_REDACTION_RULES: RedactionRule[];
-declare const REDACTION_VERSION = "1.0.0";
-/**
- * Redact a single string. Returns the new string and a per-rule count of
- * how many substitutions fired.
- */
-declare function redactString(input: string, rules?: RedactionRule[]): {
-  output: string;
-  report: RedactionReport;
-};
-/**
- * Walk a JSON-ish value applying `redactString` to every string leaf.
- * Arrays and plain objects are recursed; other types pass through
- * untouched. Circular references throw — traces should be tree-shaped.
- */
-declare function redactValue(value: unknown, rules?: RedactionRule[], report?: RedactionReport): {
-  value: unknown;
-  report: RedactionReport;
-};
-//#endregion
-//#region src/trace/store-to-otlp.d.ts
-interface TracesToOtlpResult {
-  /** Total spans emitted across every cell. */
-  spanCount: number;
-  /** Total run-anchor spans (one per Run) appended for analyst visibility. */
-  runCount: number;
-  /** Cells whose shards parsed cleanly. */
-  cellCount: number;
-  /** Cells that errored mid-conversion — surfaced so a partial conversion
-   *  isn't silently masked. */
-  cellErrorCount: number;
-}
-/**
- * A trace source the analyst should ingest. Two layouts are supported:
- *
- *   - `celled` (default): the root holds one cell subdirectory per
- *     persona/variant, each a `FileSystemTraceStore` (`runs.ndjson`,
- *     `spans.ndjson`, `events.ndjson`).
- *   - `flat`: the root is itself a single `FileSystemTraceStore` (e.g. a
- *     production-ingestion sidecar that appends one ndjson set directly under
- *     the chosen directory).
- */
-interface TraceStoreSource {
-  /** Absolute path to the trace store root. */
-  root: string;
-  /** Layout — `celled` (default) or `flat`. */
-  layout?: 'celled' | 'flat';
-  /** OTLP `service.name` for this source. Overrides the options default. */
-  serviceName?: string;
-}
-/** Domain hooks. The walker is generic; consumers inject the namespaced
- *  attributes that ride along on every run + span for analyst discovery. */
-interface TraceStoreToOtlpOptions {
-  /** Default OTLP `service.name` when a source doesn't set its own.
-   *  Default `agent-eval`. */
-  serviceName?: string;
-  /** Extra resource attributes per run, e.g.
-   *  `(run) => ({ 'legal.persona_id': run.tags?.personaId ?? '' })`. */
-  resourceAttributes?: (run: Run) => Record<string, unknown>;
-  /** Extra attributes on the per-run anchor span, e.g. domain outcome fields. */
-  runAttributes?: (run: Run) => Record<string, unknown>;
-}
-/**
- * Read every per-cell shard under each source root and write a flat OTLP-JSONL
- * view of the corpus to `outPath`. Each cell directory is a
- * `FileSystemTraceStore` — NDJSON append-only with size-based rotation;
- * `updateRun`/`updateSpan` append `{ id, ...patch, _update: true }` rows
- * rather than rewriting, so readers must merge those patches in (done here).
- *
- * A `string` source is treated as a celled root.
- */
-declare function convertTraceStoresToOtlp(source: string | TraceStoreSource | readonly TraceStoreSource[], outPath: string, opts?: TraceStoreToOtlpOptions): TracesToOtlpResult;
-//#endregion
-//#region src/trace-analyst/store-boundary.d.ts
-/** Apply the public validation, cancellation, not-found, and size rules to any adapter. */
-declare function createBoundedTraceAnalysisStore(source: TraceAnalysisStore, options?: BoundedTraceAnalysisStoreOptions): TraceAnalysisStore;
-//#endregion
-//#region src/trace-analyst/analyst.d.ts
-interface AnalyzeTracesInput {
-  question: string;
-  id?: string;
-  description?: string;
-  area?: string;
-}
-type AnalyzeTracesResult = TraceAnalysisEngineResult;
-interface AnalyzeTracesOptions {
-  /** OTLP JSONL path or a caller-owned store. */
-  source: string | TraceAnalysisStore;
-  /** Recursive research engine. */
-  engine: TraceAnalysisEngine;
-  /** Override the general trace-research policy. */
-  instructions?: string;
-  /** Smallest tool set that can answer the question. Default: all. */
-  toolGroup?: TraceToolGroupName;
-  limits?: Partial<TraceAnalystLimits>;
-  runId?: string;
-  budgetUsd?: number;
-  costLedger?: CostLedgerHandle;
-  costPhase?: string;
-  priorFindings?: readonly AnalystFinding[];
-  upstreamFindings?: readonly AnalystFinding[];
-  recordUsage?: (receipt: AnalystUsageReceipt) => void;
-  tags?: Record<string, string>;
-  log?: (message: string, fields?: Record<string, unknown>) => void;
-  signal?: AbortSignal;
-}
-/**
- * Answer one question by recursively inspecting a trace store.
- *
- * The returned answer, cited findings, engine steps, call counts, and runtime
- * identity are one audit record. A direct one-shot model call is not used.
- */
-declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
-//#endregion
-//#region src/trace-analyst/errors.d.ts
-/** Invalid trace-tool arguments, including malformed filters and regexes. */
-declare class TraceAnalysisValidationError extends ValidationError {
-  readonly code: 'validation';
-}
-/** A trace read cannot fit within a documented count or byte limit. */
-declare class TraceAnalysisLimitError extends LimitExceededError {
-  readonly code: 'limit_exceeded';
-  readonly operation: string;
-  readonly actual: number;
-  readonly limit: number;
-  constructor(operation: string, actual: number, limit: number, message?: string);
-}
-/** A supplied store returned a shape that violates the trace read contract. */
-declare class TraceAnalysisStoreContractError extends AgentEvalError {
-  readonly code: 'backend_integrity';
-  readonly operation: string;
-  constructor(operation: string, message: string, options?: {
-    cause?: unknown;
-  });
-}
-declare class TraceFileMissingError extends NotFoundError {
-  readonly code: 'not_found';
-  readonly path: string;
-  constructor(path: string);
-}
-declare class TraceFileTooLargeError extends TraceAnalysisLimitError {
-  readonly path: string;
-  readonly size_bytes: number;
-  readonly max_bytes: number;
-  constructor(path: string, size_bytes: number, max_bytes: number);
-}
-declare class TraceFileMalformedError extends CaptureIntegrityError {
-  readonly path: string;
-  readonly line_number: number;
-  readonly byte_offset: number;
-  constructor(path: string, line_number: number, byte_offset: number, cause?: unknown);
-}
-declare class TraceNotFoundError extends NotFoundError {
-  readonly code: 'not_found';
-  readonly trace_id: string;
-  constructor(trace_id: string);
-}
-declare class SpanNotFoundError extends NotFoundError {
-  readonly code: 'not_found';
-  readonly trace_id: string;
-  readonly span_id: string;
-  constructor(trace_id: string, span_id: string);
-}
-//#endregion
-//#region src/trace-analyst/hook.d.ts
-interface TraceAnalystHookOptions {
-  /**
-   * Options forwarded to `analyzeTraces`. The hook supplies the question
-   * if you don't pass one — defaulting to a launch-grade prompt that asks
-   * for failure modes, surprising findings, and a recommendation.
-   */
-  analyze: Omit<AnalyzeTracesOptions, 'source'> & {
-    source?: AnalyzeTracesOptions['source'];
-  };
-  /**
-   * Override the question. The default is intentionally generic:
-   * "Summarise what happened in this run, surface any failure modes,
-   *  surprising findings, or evidence the verdict is wrong."
-   */
-  question?: string;
-  /**
-   * Persist the result. The hook calls this with the analysis output and
-   * the run context. Common implementations write to a TraceAnalysisStore
-   * or append to a per-run JSONL.
-   */
-  save?: (result: AnalyzeTracesResult, ctx: RunCompleteHookContext) => Promise<void>;
-  /**
-   * Predicate gating execution per run. Default: every completed run.
-   * Use to skip aborted runs, debug runs, or runs without LLM activity.
-   */
-  shouldRun?: (ctx: RunCompleteHookContext) => boolean;
-  /**
-   * Optional gate: if set and returns false, the hook records the failure
-   * as a log event on the run instead of staying quiet. The caller can
-   * then trigger downstream alerts off `analyst_gate_failed` log events.
-   */
-  gateOn?: (result: AnalyzeTracesResult, ctx: RunCompleteHookContext) => boolean;
-}
-declare function traceAnalystOnRunComplete(opts: TraceAnalystHookOptions): RunCompleteHook;
-//#endregion
-//#region src/trace-analyst/insights.d.ts
-interface TraceInsightTask {
-  id: string;
-  name: string;
-  prompt?: string;
-  difficulty?: string;
-  tags?: string[];
-  outcome?: string;
-  score?: number;
-  gaps?: string[];
-}
-interface TraceInsightSuite {
-  name: string;
-  collectionId?: string;
-  tasks: TraceInsightTask[];
-}
-interface TraceInsightFinding {
-  kind: string;
-  severity?: string;
-  taskIds: string[];
-  evidence?: string;
-  proposedFixClass?: string;
-}
-interface TraceInsightQuestion {
-  id: string;
-  question: string;
-  why: string;
-}
-interface TraceInsightPanelRole {
-  id: string;
-  name: string;
-  responsibility: string;
-}
-interface TraceInsightPromptInput {
-  suite: TraceInsightSuite;
-  findings?: TraceInsightFinding[];
-  agent?: Record<string, unknown>;
-  totals?: Record<string, unknown>;
-  maxRepresentativeTraces?: number;
-}
-interface TraceInsightContext {
-  suite: TraceInsightSuite;
-  scope: string;
-  keywords: string[];
-  questions: TraceInsightQuestion[];
-  panel: TraceInsightPanelRole[];
-  findings: TraceInsightFinding[];
-  agent: Record<string, unknown> | null;
-  totals: Record<string, unknown> | null;
-}
-interface TraceInsightQualityGate {
-  id: string;
-  label: string;
-  passed: boolean;
-  severity: 'critical' | 'high' | 'medium' | 'low';
-  detail: string;
-}
-interface TraceInsightReadiness {
-  score: number;
-  grade: 'external-ready' | 'internal-review' | 'raw-analysis';
-  gates: TraceInsightQualityGate[];
-}
-declare function tokenizeDomainWords(value: string): string[];
-declare function inferDomainKeywords(suite: TraceInsightSuite): string[];
-declare function domainEvidencePattern(keywords: string[]): RegExp;
-declare function describeTraceInsightScope(suite: TraceInsightSuite): string;
-declare function planTraceInsightQuestions(input: TraceInsightPromptInput): TraceInsightQuestion[];
-declare function buildTraceInsightContext(input: TraceInsightPromptInput): TraceInsightContext;
-declare function scoreTraceInsightReadiness(context: TraceInsightContext): TraceInsightReadiness;
-declare function defaultTraceInsightPanel(): TraceInsightPanelRole[];
-declare function buildTraceInsightPrompt(input: TraceInsightPromptInput): string;
-//#endregion
-//#region src/trace/otlp-flat.d.ts
-type OtlpStatusCode = 'STATUS_CODE_OK' | 'STATUS_CODE_ERROR' | 'STATUS_CODE_UNSET';
-interface OtlpFlatLine {
-  trace_id: string;
-  span_id: string;
-  parent_span_id: string | null;
-  name: string;
-  kind: string;
-  start_time: string;
-  end_time: string;
-  status: {
-    code: OtlpStatusCode;
-    message?: string;
-  };
-  resource: {
-    attributes: Record<string, unknown>;
-  };
-  attributes: Record<string, unknown>;
-  events?: Array<{
-    name: string;
-    timeUnixNano?: string;
-    attributes?: Record<string, unknown>;
-  }>;
-}
-//#endregion
-//#region src/trace-analyst/otlp-flatten.d.ts
-interface FlattenOtlpOptions {
-  /** `'openinference'` (default) maps source per-span attributes into the
-   *  canonical OpenInference vocabulary the analyst readers consume. `'none'`
-   *  passes attributes through untouched. */
-  attributeVocabulary?: 'openinference' | 'none';
-  /** Override the numeric-kind → otlp-string mapping. */
-  kindMap?: Partial<Record<number, string>>;
-}
-declare function flattenOtlpExportToNdjson(otlpExport: OtlpExport, opts?: FlattenOtlpOptions): OtlpFlatLine[];
-//#endregion
-//#region src/trace-analyst/otlp-span.d.ts
-/**
- * The structural fields a flat OTLP-JSONL line projects to. `attributes`
- * is the merged resource+span attribute map (span overrides resource);
- * the named fields are the pivots every reader of a trace needs without
- * paying the full attribute materialisation.
- */
-interface ProjectedOtlpSpan {
-  trace_id: string;
-  span_id: string;
-  parent_span_id: string | null;
-  name: string;
-  kind: TraceAnalystSpanKind;
-  start_time: string;
-  end_time: string;
-  duration_ms: number;
-  status: TraceAnalystSpanStatus;
-  status_message: string | undefined;
-  service_name: string | null;
-  agent_name: string | null;
-  model_name: string | null;
-  tool_name: string | null;
-  /** Merged resource + span attributes, span winning on overlap. */
-  attributes: Record<string, unknown>;
-}
-/**
- * Project one parsed OTLP-JSONL object to `ProjectedOtlpSpan`, or `null`
- * when the line is missing the mandatory `trace_id` + `span_id`.
- */
-declare function projectOtlpFlatLine(raw: Record<string, unknown>): ProjectedOtlpSpan | null;
-declare function readOtlpStatus(raw: Record<string, unknown>): {
-  code: TraceAnalystSpanStatus;
-  message: string | undefined;
-};
-declare function inferOtlpKind(attrs: Record<string, unknown>): TraceAnalystSpanKind;
-/**
- * Flatten OTLP `attributes` + `resource.attributes` into a single
- * dotted-key map. Span attributes override resource attributes when keys
- * overlap. Nested objects/arrays are preserved as-is.
- */
-declare function extractOtlpAttributes(raw: Record<string, unknown>): Record<string, unknown>;
-declare function stringField(raw: Record<string, unknown>, key: string): string | undefined;
-declare function asString(v: unknown): string | null;
-/** First non-empty string value across a list of candidate attribute keys. */
-declare function firstStringAttr(attrs: Record<string, unknown>, keys: readonly string[]): string | null;
-//#endregion
-//#region src/trace-analyst/otlp-to-run-records.d.ts
-interface OtlpToRunRecordsOptions {
-  /** Logical experiment grouping for every produced record. */
-  experimentId: string;
-  /** Candidate (variant) id — the surface these traces exercised. The
-   *  bench passes the proposer label here so `compareOptimizationMethods` can pair rows. */
-  candidateId: string;
-  /** Split assignment for every produced record. Default `'holdout'` —
-   *  ingested traces are evidence, not the optimizer's training pool. */
-  splitTag?: RunSplitTag;
-  /** Git SHA the traces were produced from. Default `'unknown'`. */
-  commitSha?: string;
-  /** sha256 of the effective prompt surface. Default `'unknown'`. */
-  promptHash?: string;
-  /** sha256 of the effective config. Default `'unknown'`. */
-  configHash?: string;
-  /** RNG seed recorded on every row. Default 0. */
-  seed?: number;
-  /**
-   * Fallback model snapshot when the trace exposes no LLM model attribute
-   * OR exposes a bare alias `validateRunRecord` would reject. The trace's
-   * own model wins when it already carries a snapshot. Default
-   * `'unknown@otlp'` (opaque-snapshot form the validator accepts).
-   */
-  fallbackModel?: string;
-  /**
-   * USD per total token (input+output) used to price a trace when no
-   * per-span cost attribute is present. When unset, an unpriced trace
-   * records `costUsd: null` and `raw.cost_unpriced = 1`.
-   */
-  priceUsdPerToken?: number;
-  /**
-   * Map each OTLP `trace_id` to the logical run it belongs to. Use this when a
-   * provider emits several traces for one task attempt. All mapped traces are
-   * aggregated into one record; duplicate span ids remain isolated by their
-   * source trace. The callback must return a non-empty id for every trace.
-   *
-   * When omitted, every `trace_id` remains an independent run.
-   */
-  logicalRunIdForTrace?: (traceId: string) => string;
-  /**
-   * Score for a produced run's outcome (AppWorld `world.evaluate()` →
-   * TGC/SGC, or
-   * any [0,1] task-success signal). Keyed by the logical run id when
-   * `logicalRunIdForTrace` is supplied, otherwise by `trace_id`. When the map
-   * has no entry or the function returns undefined, the record remains
-   * unlabeled.
-   */
-  scoreForTrace?: (runId: string, span: TraceAggregate) => number | undefined;
-  /**
-   * Per-record judge metadata when an external judge produced the score.
-   * Keyed by the logical run id when supplied, otherwise by `trace_id`.
-   */
-  judgeMetadataForTrace?: (runId: string) => RunRecord['judgeMetadata'] | undefined;
-}
-/** A `RunRecord` plus the verbatim prompt/completion text when the trace's
- *  LLM spans exposed it. The text is NOT on the validated `RunRecord`
- *  (`outcome.raw` is numeric-only) but consumers ingesting full traces want
- *  it — so it rides alongside. */
-interface OtlpTraceRunRecord {
-  record: RunRecord;
-  /** Verbatim first-LLM-span `input.value`, when present. */
-  promptText?: string;
-  /** Verbatim last-LLM-span `output.value`, when present. */
-  completionText?: string;
-}
-/** Per-trace rollup the score callback can inspect. */
-interface TraceAggregate {
-  traceId: string;
-  /** Number of source OTLP traces folded into this run. */
-  sourceTraceCount: number;
-  /** Source OTLP trace ids folded into this run, sorted for deterministic audit output. */
-  sourceTraceIds: readonly string[];
-  spanCount: number;
-  llmSpanCount: number;
-  toolSpanCount: number;
-  agentSpanCount: number;
-  errorSpanCount: number;
-  executionErrorCount: number;
-  processErrorCount: number;
-  guardrailErrorCount: number;
-  judgeErrorCount: number;
-  propagatedErrorCount: number;
-  unclassifiedErrorCount: number;
-  tokenUsage: RunTokenUsage;
-  /** First error span's normalized status message, if any. */
-  firstErrorMessage?: string;
-  model: string;
-  startTime: string;
-  endTime: string;
-  wallMs: number;
-  /** Root-span terminal result. Child span errors do not change this value. */
-  terminalOutcome: RunTerminalOutcome;
-}
-/**
- * Parse + aggregate an OTLP traces.jsonl string into validated
- * `RunRecord[]` (one per trace). Use {@link otlpToTraceRunRecords} when you
- * also want the verbatim prompt/completion text alongside each record.
- */
-declare function otlpToRunRecords(otlpJsonl: string, opts: OtlpToRunRecordsOptions): RunRecord[];
-/**
- * Aggregate already-parsed OTLP flat rows without serializing them back to
- * JSONL. This is the in-memory counterpart to {@link otlpToRunRecords}; both
- * paths share projection, reconciliation, validation, and ordering.
- */
-declare function otlpRowsToRunRecords(rows: Iterable<object>, opts: OtlpToRunRecordsOptions): RunRecord[];
-/** As {@link otlpToRunRecords} but returns the prompt/completion text too. */
-declare function otlpToTraceRunRecords(otlpJsonl: string, opts: OtlpToRunRecordsOptions): OtlpTraceRunRecord[];
-/** Parsed-row counterpart to {@link otlpToTraceRunRecords}. */
-declare function otlpRowsToTraceRunRecords(rows: Iterable<object>, opts: OtlpToRunRecordsOptions): OtlpTraceRunRecord[];
-//#endregion
-//#region src/trace-analyst/prompts.d.ts
-/** General policy for recursive, evidence-backed trace analysis. */
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION = "Answer the question by inspecting the OTLP trace dataset with the available tools.\n\n1. Call getDatasetOverview first. Use its real trace ids and dataset size to plan the investigation.\n2. Narrow with queryTraces and countTraces before scanning large payloads.\n3. For a small trace, use viewTrace. For a large trace, use searchTrace and then viewSpans or searchSpan.\n4. Never invent a trace id, span id, tool result, error, frequency, or final outcome.\n5. When a search reports has_more, refine the query before drawing a conclusion.\n6. Use llm_query only over evidence already loaded. A recursive query cannot inspect traces itself.\n7. Cite exact evidence URIs returned by the tools. Include a short exact excerpt when it supports the claim.\n8. Return no finding when the available evidence cannot support one.\n\nThe prose answer must directly answer the question and state important uncertainty.\nThe findings array contains only actionable or decision-relevant claims supported by inspected evidence.";
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-research-v1-2026-07-30";
-//#endregion
-//#region src/trace-analyst/store-otlp.d.ts
-interface ToolSpansToTraceAnalysisStoreOptions {
-  /** Override the discovery (`viewTrace`) per-attribute byte cap. */
-  perAttributeViewBudget?: number;
-  /** Override the surgical (`viewSpans`) per-attribute byte cap. */
-  perAttributeSpanBudget?: number;
-  /** Override the per-call ceiling that triggers oversized summaries. */
-  perCallByteCeiling?: number;
-  /** Override the per-match text budget. */
-  perMatchTextBudget?: number;
-}
-type BufferedOtlpTraceStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
-interface OtlpFileTraceStoreOptions extends BufferedOtlpTraceStoreOptions {
-  /** Path to the OTLP-JSONL file. */
-  path: string;
-  /**
-   * Hard ceiling on the trace file size in bytes. The store reads the
-   * whole file into one Buffer and indexes it in memory, so an
-   * unbounded file OOMs the process. Above this size the store fails
-   * loud with `TraceFileTooLargeError` instead of degrading silently.
-   * Default 256 MiB.
-   */
-  maxFileBytes?: number;
-}
-declare abstract class BufferedOtlpTraceStore implements TraceAnalysisStore {
-  private readonly perAttributeViewBudget;
-  private readonly perAttributeSpanBudget;
-  private readonly perCallByteCeiling;
-  private readonly perMatchTextBudget;
-  private indexValue?;
-  private indexTask?;
-  private bufferValue?;
-  private bufferTask?;
-  constructor(opts: BufferedOtlpTraceStoreOptions);
-  hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean>;
-  hasSpans(opts: {
-    trace_id: string;
-    span_ids: readonly string[];
-  }, context?: TraceAnalysisStoreContext): Promise<string[]>;
-  getOverview(filters?: TraceAnalystFilters, context?: TraceAnalysisStoreContext): Promise<DatasetOverview>;
-  queryTraces(opts: {
-    filters?: TraceAnalystFilters;
-    limit: number;
-    offset?: number;
-  }, context?: TraceAnalysisStoreContext): Promise<QueryTracesPage>;
-  countTraces(filters?: TraceAnalystFilters, context?: TraceAnalysisStoreContext): Promise<number>;
-  viewTrace(opts: {
-    trace_id: string;
-    per_attribute_byte_cap?: number;
-  }, context?: TraceAnalysisStoreContext): Promise<ViewTraceResult>;
-  viewSpans(opts: {
-    trace_id: string;
-    span_ids: readonly string[];
-    per_attribute_byte_cap?: number;
-  }, context?: TraceAnalysisStoreContext): Promise<ViewSpansResult>;
-  searchTrace(opts: {
-    trace_id: string;
-    regex_pattern: string;
-    max_matches?: number;
-  }, context?: TraceAnalysisStoreContext): Promise<SearchTraceResult>;
-  searchSpan(opts: {
-    trace_id: string;
-    span_id: string;
-    regex_pattern: string;
-    max_matches?: number;
-  }, context?: TraceAnalysisStoreContext): Promise<SearchSpanResult>;
-  /** Force the index to materialise. Useful to amortise startup cost
-   *  before the first agent call. */
-  ensureIndexed(context?: TraceAnalysisStoreContext): Promise<void>;
-  private buffer;
-  protected abstract readBuffer(signal?: AbortSignal): Promise<Buffer>;
-  protected abstract sourcePath(): string;
-  private index;
-  private buildIndex;
-  private matchedTraces;
-  private toSummary;
-  private projectSpan;
-  private buildOversizedSummary;
-  private scanSpanForMatches;
-}
-declare class OtlpFileTraceStore extends BufferedOtlpTraceStore {
-  private readonly path;
-  private readonly maxFileBytes;
-  constructor(opts: OtlpFileTraceStoreOptions);
-  /** Stat-then-read so an oversized file fails loud before allocating the
-   *  source buffer. Missing files remain distinct from malformed traces. */
-  protected readBuffer(signal?: AbortSignal): Promise<Buffer>;
-  protected sourcePath(): string;
-}
-/** Build the bounded trace store directly from OpenInference JSONL text. */
-declare function otlpTextToTraceAnalysisStore(text: string, opts?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
-//#endregion
-//#region src/trace-analyst/store-tool-spans.d.ts
-/** Missing tool spans cannot distinguish a tool-free run from broken capture. */
-declare class ToolTraceMissingError extends CaptureIntegrityError {
-  constructor();
-}
-/**
- * Snapshot canonical tool spans into the read interface used by trace analysts.
- * One run becomes one trace while arguments, results, errors, and timing remain searchable.
- */
-declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, options?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
-//#endregion
-//#region src/replay.d.ts
-declare class ReplayCacheMissError extends ReplayError {
-  readonly url: string;
-  readonly requestKey: string;
-  constructor(url: string, requestKey: string, message?: string);
-}
-interface ReplayCacheEntry {
-  request: RawProviderEvent;
-  response: RawProviderEvent;
-}
-interface ReplayCacheStats {
-  total: number;
-  byProvider: Record<string, number>;
-  byModel: Record<string, number>;
-  /** Spans for which we have a request but no response (run aborted mid-call). */
-  orphanRequests: number;
-}
-/**
- * In-memory deterministic cache of (request → response) keyed on a stable
- * hash of the request body. Built from a `RawProviderSink` containing
- * paired `request` and `response` events from a previous run.
- *
- * The cache is the source of truth for replay; `createReplayFetch` is a
- * thin wrapper that reads from it.
- */
-declare class ReplayCache {
-  private byKey;
-  private orphans;
-  private byProvider;
-  private byModel;
-  /**
-   * Build a cache from a sink's events. The sink must implement `list()`.
-   * Filter by `runId` / `spanId` to scope to a specific replay.
-   */
-  static fromSink(sink: RawProviderSink, filter?: {
-    runId?: string;
-    spanId?: string;
-  }): Promise<ReplayCache>;
-  /** Build a cache from an in-memory event list. */
-  static fromEvents(events: RawProviderEvent[]): Promise<ReplayCache>;
-  /** Number of cacheable (request, response) pairs in the cache. */
-  size(): number;
-  stats(): ReplayCacheStats;
-  /** Iterate every cached `(request, response)` pair in insertion order. */
-  entries(): IterableIterator<ReplayCacheEntry>;
-  /**
-   * Look up a cached response by hashing the (model, messages, temperature,
-   * maxTokens, response_format) shape. Returns `undefined` on miss; the
-   * caller decides whether to throw, fall back to the network, or skip.
-   */
-  lookup(requestBody: unknown): Promise<ReplayCacheEntry | undefined>;
-}
-interface ReplayFetchOptions {
-  /**
-   * Behaviour on cache miss. Default `'throw'`. `'fallback'` calls the
-   * `fallbackFetch` (typically `globalThis.fetch`) so a partial replay can
-   * still complete; `'fail-closed'` returns a synthetic 599 response so the
-   * call site sees a non-retriable failure.
-   */
-  onMiss?: 'throw' | 'fallback' | 'fail-closed';
-  fallbackFetch?: typeof fetch;
-  /** Optional callback fired once per replayed call (for telemetry / counters). */
-  onHit?: (info: {
-    url: string;
-    provider: string;
-    model: string;
-  }) => void;
-  /** Optional callback fired on cache miss before the `onMiss` policy applies. */
-  onMissNotify?: (info: {
-    url: string;
-    requestBody: unknown;
-  }) => void;
-}
-/**
- * Build a `fetch`-shaped function that serves cached responses out of a
- * `ReplayCache` for any URL ending in `/chat/completions`. Pass through
- * `LlmClientOptions.fetch` and `callLlm` becomes free.
- *
- * Non-`/chat/completions` URLs are passed straight to the fallback fetch
- * (default: `globalThis.fetch`). This matters because non-LLM HTTP work
- * (judge HTTP servers, sandbox callbacks) sometimes flows through the same
- * `fetch` and shouldn't be intercepted.
- */
-declare function createReplayFetch(cache: ReplayCache, opts?: ReplayFetchOptions): typeof fetch;
-/**
- * Convenience iterator over `(request, response)` pairs in a sink — for
- * post-hoc scoring that doesn't need a `fetch` shim. The judge or scorer
- * runs purely in-process over cached LLM outputs.
- */
-declare function iterateRawCalls(sink: RawProviderSink, filter?: {
-  runId?: string;
-  spanId?: string;
-}): AsyncGenerator<ReplayCacheEntry>;
-//#endregion
-export { traceAnalystOnRunComplete as $, stringField as A, OtlpSpanRoleInput as At, TraceInsightReadiness as B, exportRunAsOtlp as Bt, ProjectedOtlpSpan as C, createOtelTracingStore as Ct, inferOtlpKind as D, OtelExporter as Dt, firstStringAttr as E, OtelExportConfig as Et, TraceInsightFinding as F, traceSpanKindToOpenInferenceKind as Ft, defaultTraceInsightPanel as G, TraceInsightTask as H, TraceInsightPanelRole as I, OTEL_AGENT_EVAL_SCOPE as It, inferDomainKeywords as J, describeTraceInsightScope as K, TraceInsightPromptInput as L, OtlpExport as Lt, flattenOtlpExportToNdjson as M, applyToolSpanOtlpAttributes as Mt, OtlpFlatLine as N, classifyOtlpSpanRole as Nt, projectOtlpFlatLine as O, createOtelExporter as Ot, TraceInsightContext as P, isOtlpModelCall as Pt, TraceAnalystHookOptions as Q, TraceInsightQualityGate as R, OtlpResourceSpans as Rt, otlpToTraceRunRecords as S, redactValue as St, extractOtlpAttributes as T, ExportableSpan as Tt, buildTraceInsightContext as U, TraceInsightSuite as V, buildTraceInsightPrompt as W, scoreTraceInsightReadiness as X, planTraceInsightQuestions as Y, tokenizeDomainWords as Z, OtlpTraceRunRecord as _, DEFAULT_REDACTION_RULES as _t, ReplayFetchOptions as a, TraceFileMissingError as at, otlpRowsToTraceRunRecords as b, RedactionRule as bt, ToolTraceMissingError as c, AnalyzeTracesInput as ct, OtlpFileTraceStoreOptions as d, analyzeTraces as dt, SpanNotFoundError as et, ToolSpansToTraceAnalysisStoreOptions as f, createBoundedTraceAnalysisStore as ft, OtlpToRunRecordsOptions as g, convertTraceStoresToOtlp as gt, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION as h, TracesToOtlpResult as ht, ReplayCacheStats as i, TraceFileMalformedError as it, FlattenOtlpOptions as j, ToolSpanOtlpInput as jt, readOtlpStatus as k, OtlpSpanRole as kt, toolSpansToTraceAnalysisStore as l, AnalyzeTracesOptions as lt, TRACE_ANALYST_ACTOR_DESCRIPTION as m, TraceStoreToOtlpOptions as mt, ReplayCacheEntry as n, TraceAnalysisStoreContractError as nt, createReplayFetch as o, TraceFileTooLargeError as ot, otlpTextToTraceAnalysisStore as p, TraceStoreSource as pt, domainEvidencePattern as q, ReplayCacheMissError as r, TraceAnalysisValidationError as rt, iterateRawCalls as s, TraceNotFoundError as st, ReplayCache as t, TraceAnalysisLimitError as tt, OtlpFileTraceStore as u, AnalyzeTracesResult as ut, TraceAggregate as v, REDACTION_VERSION as vt, asString as w, otelRunCompleteHook as wt, otlpToRunRecords as x, redactString as xt, otlpRowsToRunRecords as y, RedactionReport as yt, TraceInsightQuestion as z, OtlpSpan as zt };
-//# sourceMappingURL=replay-DbhZ4Ked.d.ts.map