@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/client-C97NMzqi.d.ts

@@ -0,0 +1,581 @@
+import { l as RunTerminalOutcome } from "./run-record-CnZu_gjl.js";
+import { o as FailureClass } from "./schema-BtVldJ3T.js";
+import { r as ContinuousAgreement } from "./judge-calibration-DFtEMlde.js";
+import { _ as GateDecision, j as MutableSurface } from "./types-k9tZGKUg.js";
+import { i as ParetoFigureSpec, t as GainDistributionBin } from "./summary-report-Cj9gdw4i.js";
+//#region src/contract/insight-report.d.ts
+interface InsightReport {
+  /** Number of runs analyzed. */
+  n: number;
+  /** Runtime facts carried by the run records. These describe execution,
+   *  not task quality: duration, queueing, token categories, models,
+   *  execution errors, and terminal outcomes. */
+  execution: ExecutionInsight;
+  /** Composite-score distribution across all runs. Always present. */
+  composite: ScalarDistribution;
+  /** Per-dimension distributions for every dimension that appeared in any
+   *  run's judge scores. Empty when no judge scores were recorded. */
+  perDimension: Record<string, ScalarDistribution>;
+  /** Cost/quality distribution and Pareto frontier. */
+  costQuality: {
+    cost: ScalarDistribution;
+    pareto: ParetoFigureSpec;
+    /** Cost source coverage. `uncaptured` rows are excluded from the USD
+     *  distribution and Pareto chart; observed and estimated totals remain
+     *  separate so reports never present estimates as billed spend. */
+    provenance?: CostProvenanceSummary;
+    /** Set when the cost/quality view is degraded because the input data
+     *  doesn't fully support it — e.g. all `costUsd` were zero, or only a
+     *  single candidate appears (so the Pareto is a single point). The
+     *  named fields name the degraded sub-view, free-text the reason. */
+    degraded?: {
+      cost?: string;
+      pareto?: string;
+    };
+  };
+  /** Per-judge calibration + bias detection. Populated for every judge name
+   *  that appears in `outcome.judgeScores`. Bias fields require either a
+   *  gold reference or multi-rater data. */
+  judges: Record<string, JudgeInsight>;
+  /** Inter-rater agreement when multiple judges scored the same runs.
+   *  Includes pairwise kappa and the specific run ids where raters
+   *  disagree — the cases worth a human meeting. */
+  interRater?: InterRaterInsight;
+  /** Pairwise lift (baseline → candidate) with bootstrap CI. Present when
+   *  `RunRecord.splitTag` includes both `holdout` and search/dev splits,
+   *  or when caller passes an explicit baseline/candidate split. */
+  lift?: LiftInsight;
+  /** Failure clusters with exemplars. Populated when an AnalystRegistry
+   *  is wired in `analyzeRuns({ analyst })`. */
+  failureClusters?: FailureClusterInsight;
+  /** Canary leak count + holdout audit status. Populated when canary
+   *  scenarios are passed in. */
+  contamination?: ContaminationInsight;
+  /** Correlation between judge composite and a downstream outcome the
+   *  caller supplies (engagement, revenue, downstream pass rate, etc.).
+   *  When present, the optional reward model is the model that maps
+   *  judge scores → predicted outcome. */
+  outcomeCorrelation?: OutcomeCorrelationInsight;
+  /** Aggregate release-readiness summary. A consumer needing the full
+   *  substrate `ReleaseConfidenceScorecard` (SLO-axis evaluation,
+   *  ActionableSideInfo bag) calls `evaluateReleaseConfidence()` directly;
+   *  this summary captures the analyzeRuns-derived axes. */
+  release: ReleaseSummary;
+  /** Delta vs a prior period when `baselineRuns` is passed. Per-metric
+   *  current vs baseline with Welch CI + Cohen's d + significance flag.
+   *  Answers "did my last change help?" — the customer-conversion question.
+   *  Surfaced metrics: composite, cost, duration, tokenUsage, plus any
+   *  per-dimension judge metric present in both windows. */
+  priorPeriodComparison?: PriorPeriodComparison;
+  /** Model-free task-failure breakdown from `RunRecord.failureClass`, ranked
+   *  by count descending. Domain-specific `failureMode` detail is retained on
+   *  each record but never creates a second aggregation vocabulary. */
+  failureClasses?: FailureClassTally[];
+  /** Top-N actionable recommendations, ranked by priority. The packet's
+   *  human-readable layer; the numeric sections are the evidence. */
+  recommendations: Recommendation[];
+}
+interface CostProvenanceSummary {
+  observed: {
+    n: number;
+    totalUsd: number;
+  };
+  estimated: {
+    n: number;
+    totalUsd: number;
+  };
+  uncaptured: {
+    n: number;
+  };
+  knownFraction: number;
+}
+interface ExecutionInsight {
+  /** End-to-end wall time for every run. */
+  durationMs: ScalarDistribution;
+  /** Queue time for the subset of runs that recorded it. */
+  queueMs: ScalarDistribution;
+  /** Token distributions plus corpus totals. Optional token categories use
+   *  distribution `n` to disclose how many runs recorded that category. */
+  tokenUsage: TokenUsageInsight;
+  /** Usage reported only by orchestration or agent aggregate spans.
+   *  Kept separate because it may duplicate model-call telemetry in other traces. */
+  aggregateUsage: {
+    runs: number;
+    tokenUsage: TokenUsageInsight;
+    costUsd: ScalarDistribution;
+    totalCostUsd: number;
+  };
+  /** Stable model counts, largest cohort first. */
+  models: Array<{
+    model: string;
+    runs: number;
+  }>;
+  /** Model-call coverage. `events` is available only from producers that
+   *  record `outcome.raw.llm_span_count`; `runs` also recognizes non-zero
+   *  token usage from other producers. */
+  modelCalls: {
+    runs: number;
+    events: number;
+    reportingRuns: number;
+  };
+  /** Runs with explicit execution-error telemetry. This is independent of
+   *  whether the root run ultimately succeeded, failed, or has no terminal
+   *  evidence. */
+  executionErrors: {
+    runs: number;
+    /** Share among runs that supplied an execution-error count.
+     *  `null` when no run supplied error telemetry. */
+    fraction: number | null;
+    /** Execution-error events reported through the canonical count. */
+    events: number;
+    /** Runs that supplied an execution-error count, including explicit zeroes. */
+    reportingRuns: number;
+    /** Exact sum of `outcome.raw.error_span_count`, kept separate from other errors. */
+    errorSpanEvents: number;
+    /** Runs that supplied `outcome.raw.error_span_count`, including explicit zeroes. */
+    errorSpanReportingRuns: number;
+    /**
+     * Error-telemetry coverage crossed with independently reported terminal
+     * outcomes. `unreported` is distinct from a reported zero.
+     */
+    byTerminalOutcome: Record<RunTerminalOutcome, ExecutionErrorOutcomeCell>;
+  };
+  /** Root-run or process outcomes. Missing `RunRecord.terminalOutcome` values
+   *  count as `unknown`; child-span status never changes these counts. */
+  terminalOutcomes: {
+    succeeded: number;
+    failed: number;
+    cancelled: number;
+    incomplete: number;
+    unknown: number;
+  };
+}
+interface ExecutionErrorOutcomeCell {
+  /** Runs that explicitly reported one or more execution errors. */
+  withErrors: number;
+  /** Runs that explicitly reported zero execution errors. */
+  withoutErrors: number;
+  /** Runs with no execution-error count from the producer. */
+  unreported: number;
+}
+interface TokenUsageInsight {
+  input: ScalarDistribution;
+  output: ScalarDistribution;
+  reasoning: ScalarDistribution;
+  cached: ScalarDistribution;
+  cacheWrite: ScalarDistribution;
+  totals: {
+    input: number;
+    output: number;
+    reasoning: number;
+    cached: number;
+    cacheWrite: number;
+  };
+}
+/** Distributional summary of a scalar-valued metric. */
+interface ScalarDistribution {
+  /** Sample count after dropping non-finite values. */
+  n: number;
+  /** Null when `n` is zero. */
+  mean: number | null;
+  /** Null when `n` is zero. */
+  p50: number | null;
+  /** Null when `n` is zero. */
+  p95: number | null;
+  /** Null when `n` is zero. */
+  stddev: number | null;
+  /** Null when `n` is zero. */
+  min: number | null;
+  /** Null when `n` is zero. */
+  max: number | null;
+  /** Histogram bins using `agent-eval`'s `gainHistogram` primitive. */
+  histogram: GainDistributionBin[];
+  /** Worst-N runs by score, ascending. Populated for the composite
+   *  distribution so the report names the runs a customer should
+   *  inspect first. Undefined when the distribution was computed from a
+   *  raw value list with no run identity (e.g. cost). */
+  tailRuns?: Array<{
+    runId: string;
+    score: number;
+  }>;
+}
+interface JudgeInsight {
+  /** Number of times this judge scored a run. */
+  n: number;
+  /** Mean composite over this judge's runs. */
+  meanScore: number;
+  /** Calibration against a gold reference, when provided. Cohen's κ for
+   *  binary thresholding + continuous agreement metrics. */
+  calibration?: ContinuousAgreement;
+  /** Positional bias — when the judge sees options in different orders,
+   *  do its preferences track the content or the position? */
+  positionalBias?: number;
+  /** Self-preference — when the judge sees its own model's output vs a
+   *  competitor, does it over-pick its own? */
+  selfPreference?: number;
+  /** Verbosity bias — does the judge reward longer outputs regardless of
+   *  quality? */
+  verbosityBias?: number;
+}
+interface InterRaterInsight {
+  /** Number of raters whose scores were aggregated. */
+  raters: number;
+  /** Number of runs every rater scored. */
+  jointlyRated: number;
+  /** Multi-rater weighted kappa over the jointly rated runs. */
+  kappa: number;
+  /** Absolute agreement across raters, using ICC(2,1). */
+  icc: number;
+  /** Mean pairwise Pearson correlation. Correlation is not agreement. */
+  pearson: number;
+  /** Mean pairwise Spearman rank correlation. */
+  spearman: number;
+  /** Pairwise weighted kappa per rater pair (key = `"raterA::raterB"`). */
+  perPair: Record<string, number>;
+  /** Run ids where raters disagree the most — the high-value triage list. */
+  disagreementCases: Array<{
+    runId: string;
+    ratings: Array<{
+      rater: string;
+      score: number;
+    }>;
+    range: number;
+  }>;
+}
+interface LiftInsight {
+  baselineMean: number;
+  candidateMean: number;
+  /** Candidate − baseline. */
+  delta: number;
+  /** Lower / upper bound of bootstrap CI on the delta. */
+  ci95: [number, number];
+  /** Paired-t-test p-value. */
+  pValue: number;
+  /** Number of paired observations. */
+  n: number;
+  /** Scored baseline observations without a candidate match. */
+  unpairedBaseline: number;
+  /** Scored candidate observations without a baseline match. */
+  unpairedCandidate: number;
+  /** Cohen's dz for paired deltas; null when the observed delta variance is zero. */
+  cohensD: number | null;
+  /** Minimum detectable effect at current n, 80% power. */
+  mde: number;
+  /** Paired sample size needed to detect the standardized effect at 80% power. */
+  requiredN: number | null;
+}
+interface FailureClusterInsight {
+  /** All clusters identified by the registry, ranked by share descending. */
+  clusters: Array<{
+    id: string;
+    name: string;
+    /** Fraction of failed runs in this cluster, 0..1. */
+    share: number;
+    /** Exemplar `runId`s (≤ 5) the consumer can drill into. */
+    exemplars: string[];
+    /** Short LLM-generated suggested fix when the registry supports it. */
+    suggestedFix?: string;
+  }>;
+  totalFailures: number;
+}
+/** Model-free task-failure breakdown over canonical `RunRecord.failureClass`
+ *  values. Unlike semantic failure clusters, this is computed directly from
+ *  run records and does not require a model analyst. */
+interface FailureClassTally {
+  /** Canonical task-failure class. */
+  failureClass: FailureClass;
+  /** Number of failed runs carrying this class. */
+  count: number;
+  /** Share of the whole corpus, 0..1. */
+  share: number;
+}
+interface ContaminationInsight {
+  /** Canary phrases that leaked into outputs. */
+  leaks: number;
+  /** Holdout audit verdict — did any holdout-tagged run end up in the
+   *  search/dev pool, or vice versa? */
+  holdoutAuditPassed: boolean;
+  details?: Array<{
+    runId: string;
+    canary: string;
+    matched: string;
+  }>;
+}
+interface OutcomeCorrelationInsight {
+  /** What outcome the consumer is correlating against (e.g.
+   *  `'engagement_rate'`, `'approval_rate'`, `'downstream_pass'`). */
+  metric: string;
+  /** Number of (run, outcome) pairs used. */
+  n: number;
+  /** Pearson correlation between composite score and outcome. */
+  pearson: number;
+  /** Spearman rank correlation — robust to monotonic non-linearity. */
+  spearman: number;
+  /** When present, the simple linear reward model fit to the data. */
+  rewardModel?: {
+    intercept: number;
+    slope: number;
+    r2: number;
+  };
+}
+interface ReleaseSummary {
+  /** Overall verdict across axes — fail if any axis fails, else warn if any
+   *  warns, else pass. */
+  status: 'pass' | 'warn' | 'fail';
+  axes: Array<{
+    name: 'quality-lift' | 'contamination' | 'composite-distribution';
+    status: 'pass' | 'warn' | 'fail' | 'not_evaluated';
+    detail: string;
+  }>;
+  /** Free-form issues surfaced beyond the standard axes. Empty by default;
+   *  consumers can post-process to populate. */
+  issues: string[];
+}
+interface MetricDelta {
+  /** Current-period mean. */
+  current: number;
+  /** Baseline-period mean. */
+  baseline: number;
+  /** current - baseline. Positive means improved (or, for cost/duration,
+   *  the consumer-side interpretation: "higher current" — semantic
+   *  direction depends on the metric). */
+  delta: number;
+  /** Welch 95% confidence interval on the delta. Two-sample, unpaired —
+   *  the baseline and current run sets may have different scenarios. */
+  ci95: [number, number];
+  /** Welch t-test p-value (two-sided). */
+  pValue: number;
+  /** Cohen's d (pooled stddev). Effect size, signed. */
+  cohensD: number;
+  /** Sample sizes. */
+  baselineN: number;
+  currentN: number;
+  /** True when p < 0.05 AND |d| >= 0.2 (small-effect threshold). The
+   *  conjunction prevents large-effect-but-noisy and significant-but-
+   *  tiny from triggering recommendations. */
+  significant: boolean;
+}
+interface PriorPeriodComparison {
+  /** Sample counts. */
+  baselineN: number;
+  currentN: number;
+  /** Optional human-readable label — "vs prior 7 days", "vs v3 release". */
+  windowLabel?: string;
+  /** Every metric we could compare. Keys: 'composite', 'cost', 'duration',
+   *  'tokenUsage' for always-present ones; per-dimension keys when both
+   *  windows have judge scores on the same dimension. */
+  metrics: Record<string, MetricDelta>;
+  /** Metric names where current is significantly WORSE than baseline.
+   *  Direction-aware: for cost/duration, higher current = worse. */
+  regressedMetrics: string[];
+  /** Metric names where current is significantly BETTER than baseline. */
+  improvedMetrics: string[];
+}
+interface Recommendation {
+  priority: 'critical' | 'high' | 'medium' | 'low';
+  kind: 'ship' | 'hold' | 'investigate' | 'fix' | 'recalibrate' | 'expand-corpus';
+  title: string;
+  detail: string;
+  /** Optional pointer back into the report for the evidence. */
+  evidencePath?: string;
+}
+//#endregion
+//#region src/hosted/types.d.ts
+declare const HOSTED_WIRE_VERSION: '2026-07-24.v1';
+type HostedWireVersion = typeof HOSTED_WIRE_VERSION;
+/** Every ingest request carries these. */
+interface HostedIngestHeaders {
+  /** Bearer token. The orchestrator validates against the tenant key. */
+  authorization: `Bearer ${string}`;
+  /** Stable tenant id (the orchestrator-side primary key for the tenant). */
+  'x-tangle-tenant-id': string;
+  /** Wire-version pin so the server can reject incompatible payloads. */
+  'x-tangle-wire-version': HostedWireVersion;
+  /** Stable request key generated once and reused across retries. */
+  'idempotency-key': string;
+}
+/** Lifecycle stages of an eval-run as the substrate reports them. */
+type EvalRunStatus = 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
+interface EvalRunCellScore {
+  /** Stable scenario id from the consumer's scenario set. */
+  scenarioId: string;
+  /** Repetition index when reps > 1; 0 for the default. */
+  rep: number;
+  /** Composite score across successful judges, or null when unscored. */
+  compositeMean: number | null;
+  /** Per-judge and per-dimension scores; failed or missing judges are absent. */
+  dimensions: Record<string, Record<string, number>>;
+  /** Root execution result, kept separate from task quality. */
+  terminalOutcome: RunTerminalOutcome;
+  /** Canonical execution-error count, or null when the producer did not measure it. */
+  executionErrorCount: number | null;
+  /** Per-cell dispatch or judge error. Missing on success. */
+  errorMessage?: string;
+}
+interface EvalRunGenerationSnapshot {
+  /** Generation index. 0 is baseline. */
+  index: number;
+  /** Candidate surface fingerprint (stable hash) — pivot key into the
+   *  trace stream to fetch the underlying execution. */
+  surfaceHash: string;
+  /** The candidate surface itself. May be omitted to avoid PII when the
+   *  consumer prefers not to ship verbatim prompts. */
+  surface?: MutableSurface;
+  /** Per-cell scores for this generation. */
+  cells: EvalRunCellScore[];
+  /** Mean across scored cells, or null when no cell has a task-quality label. */
+  compositeMean: number | null;
+  /** Total $ spent across this generation. */
+  costUsd: number;
+  /** Wall-clock duration of this generation. */
+  durationMs: number;
+}
+/**
+ * The top-level eval-run event. One ingest call per logical eval-run;
+ * generations stream in incrementally via repeated calls with the same
+ * `runId`. The orchestrator deduplicates by `(runId, generation.index)`.
+ */
+interface EvalRunEvent {
+  /** Stable run id (the substrate's `runId`). UUID or substrate-generated. */
+  runId: string;
+  /** Where this run was happening — derived from `RunCampaignOptions.runDir`. */
+  runDir: string;
+  /** ISO-8601 timestamp the substrate recorded the event. */
+  timestamp: string;
+  /** Lifecycle stage this event represents. */
+  status: EvalRunStatus;
+  /** Free-form consumer tags (env, branch, model id, etc.). Searchable. */
+  labels: Record<string, string>;
+  /** Baseline campaign snapshot. Present when status >= baseline-complete. */
+  baseline?: EvalRunGenerationSnapshot;
+  /** Per-generation snapshots. Streams in; orchestrator appends. */
+  generations: EvalRunGenerationSnapshot[];
+  /** Final gate decision. Present when status >= gate-decided. */
+  gateDecision?: GateDecision;
+  /** Held-out lift = winner-on-holdout - baseline-on-holdout. */
+  holdoutLift?: number;
+  /** Total $ spent across baseline + every generation. */
+  totalCostUsd: number;
+  /** Total wall-clock duration. */
+  totalDurationMs: number;
+  /** Error message if status === 'errored'. */
+  errorMessage?: string;
+  /** Rigor packet emitted alongside the run — distributional summary,
+   *  paired-bootstrap lift CI, judge stats, inter-rater agreement,
+   *  contamination check, failure clusters (when an analyst is wired),
+   *  outcome correlation (when downstream signal is supplied), and the
+   *  recommendations the dashboard surfaces verbatim. */
+  insightReport?: InsightReport;
+}
+/**
+ * Canonical unsigned 64-bit integer encoded as a base-10 string.
+ * JSON numbers cannot represent OTLP nanosecond timestamps exactly.
+ */
+type UnixNanoTimestamp = string;
+/**
+ * OTel-shape span with a few additional attributes for eval-run pivoting.
+ * Compatible with any OTLP collector — `name`, `traceId`, `spanId`,
+ * `startTimeUnixNano`, `endTimeUnixNano`, `attributes` are stock OTel.
+ */
+interface TraceSpanEvent {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  name: string;
+  startTimeUnixNano: UnixNanoTimestamp;
+  endTimeUnixNano: UnixNanoTimestamp;
+  attributes: Record<string, string | number | boolean>;
+  events?: Array<{
+    timeUnixNano: UnixNanoTimestamp;
+    name: string;
+    attributes?: Record<string, string | number | boolean>;
+  }>;
+  status?: {
+    code: 'OK' | 'ERROR' | 'UNSET';
+    message?: string;
+  };
+  /** Pivot back into the eval-run stream. */
+  'tangle.runId'?: string;
+  /** Pivot to the specific generation. */
+  'tangle.generation'?: number;
+  /** Pivot to the specific cell. */
+  'tangle.cellId'?: string;
+  /** Pivot to the specific scenario. */
+  'tangle.scenarioId'?: string;
+}
+interface IngestEvalRunsRequest {
+  wireVersion: HostedWireVersion;
+  events: EvalRunEvent[];
+}
+interface IngestTracesRequest {
+  wireVersion: HostedWireVersion;
+  spans: TraceSpanEvent[];
+}
+interface IngestResponse {
+  /** Accepted events / spans count. */
+  accepted: number;
+  /** Rejected events with reasons (validation failures, dup idempotency key, etc.). */
+  rejected: Array<{
+    index: number;
+    reason: string;
+  }>;
+}
+//#endregion
+//#region src/hosted/client.d.ts
+interface HostedTenant {
+  /** Orchestrator endpoint base URL (no trailing slash). Required. */
+  endpoint: string;
+  /** Bearer token issued by the orchestrator. Required. */
+  apiKey: string;
+  /** Tenant id — the orchestrator's primary key for this consumer. Required. */
+  tenantId: string;
+  /** Optional `fetch` override (auth wrappers, custom agent, test mocks). */
+  fetchImpl?: typeof fetch;
+  /** Per-call timeout in ms. Default 30s. */
+  timeoutMs?: number;
+  /** Retries on 5xx / network errors. Default 2. */
+  retries?: number;
+}
+interface HostedClient {
+  ingestEvalRun(event: EvalRunEvent, idempotencyKey?: string): Promise<IngestResponse>;
+  ingestEvalRuns(events: EvalRunEvent[], idempotencyKey?: string): Promise<IngestResponse>;
+  ingestTraces(spans: TraceSpanEvent[], idempotencyKey?: string): Promise<IngestResponse>;
+  readonly tenant: HostedTenant;
+  readonly wireVersion: HostedWireVersion;
+}
+declare function createHostedClient(tenant: HostedTenant): HostedClient;
+/**
+ * Build a `HostedClient` from environment, or `undefined` when ingest is not
+ * configured — the canonical, fail-soft wiring every product uses so eval-run +
+ * trace provenance lands in the Intelligence dashboard with ONE call:
+ *
+ *   const hosted = hostedClientFromEnv()
+ *   // ...run the loop...
+ *   await emitLoopProvenance({ ..., hostedClient: hosted })  // no-op if undefined
+ *
+ * Returns `undefined` (NOT an error) when any of endpoint / apiKey / tenantId is
+ * missing — so a product wires the ship call unconditionally and it stays a
+ * no-op until the env is set. Env precedence:
+ *   - endpoint:  `TANGLE_INGEST_URL` → `TANGLE_ORCHESTRATOR_URL`
+ *   - apiKey:    `TANGLE_INGEST_API_KEY` → `TANGLE_API_KEY`
+ *   - tenantId:  `TANGLE_TENANT_ID`
+ * A trailing slash on the endpoint is stripped. Pass `overrides` to supply any
+ * field directly (e.g. a fixed `tenantId` per product) — overrides win over env.
+ */
+/**
+ * Build a {@link HostedTenant} config from env — the input `selfImprove`'s
+ * `hostedTenant` and `emitLoopProvenance` take. Same env precedence + overrides
+ * as {@link hostedClientFromEnv}; returns `undefined` (not an error) when any of
+ * endpoint / apiKey / tenantId is missing, so a product wires
+ * `hostedTenant: hostedTenantFromEnv({ tenantId: 'my-agent' })` unconditionally
+ * and it stays off until the env is set.
+ */
+declare function hostedTenantFromEnv(overrides?: Partial<HostedTenant> & {
+  env?: Record<string, string | undefined>;
+}): HostedTenant | undefined;
+declare function hostedClientFromEnv(overrides?: Partial<HostedTenant> & {
+  env?: Record<string, string | undefined>;
+}): HostedClient | undefined;
+//#endregion
+export { ScalarDistribution as A, InsightReport as C, OutcomeCorrelationInsight as D, LiftInsight as E, Recommendation as O, FailureClusterInsight as S, JudgeInsight as T, UnixNanoTimestamp as _, hostedTenantFromEnv as a, ExecutionInsight as b, EvalRunGenerationSnapshot as c, HostedIngestHeaders as d, HostedWireVersion as f, TraceSpanEvent as g, IngestTracesRequest as h, hostedClientFromEnv as i, TokenUsageInsight as j, ReleaseSummary as k, EvalRunStatus as l, IngestResponse as m, HostedTenant as n, EvalRunCellScore as o, IngestEvalRunsRequest as p, createHostedClient as r, EvalRunEvent as s, HostedClient as t, HOSTED_WIRE_VERSION as u, CostProvenanceSummary as v, InterRaterInsight as w, FailureClassTally as x, ExecutionErrorOutcomeCell as y };
+//# sourceMappingURL=client-C97NMzqi.d.ts.map

package/dist/client-C97NMzqi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-C97NMzqi.d.ts","names":[],"sources":["../src/contract/insight-report.ts","../src/hosted/types.ts","../src/hosted/client.ts"],"mappings":"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"}