@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/chunk-DRYIUNWY.js

@@ -1,622 +0,0 @@
-import {
-  FAILURE_CLASSES
-} from "./chunk-MA6HLL3S.js";
-
-// src/hosted/types.ts
-var HOSTED_WIRE_VERSION = "2026-07-24.v1";
-
-// src/hosted/schemas.ts
-import { z } from "zod";
-var finiteNumber = z.number().finite();
-var nonNegativeNumber = finiteNumber.nonnegative();
-var nonNegativeInteger = z.number().int().nonnegative();
-var nonEmptyString = z.string().min(1).refine((value) => value.trim().length > 0, "must not be blank");
-var attributeValue = z.union([z.string(), finiteNumber, z.boolean()]);
-var attributes = z.record(z.string(), attributeValue);
-var FailureClassSchema = z.custom(
-  (value) => typeof value === "string" && FAILURE_CLASSES.includes(value),
-  `expected one of ${FAILURE_CLASSES.join(", ")}`
-);
-var UINT64_MAX = 18446744073709551615n;
-var UnixNanoTimestampSchema = z.string().regex(/^(0|[1-9][0-9]*)$/, "expected an unsigned base-10 integer string").refine((value) => BigInt(value) <= UINT64_MAX, "must fit in an unsigned 64-bit integer");
-var GainDistributionBinSchema = z.object({
-  lo: finiteNumber,
-  hi: finiteNumber,
-  count: nonNegativeInteger
-}).strict();
-var ScalarDistributionSchema = z.object({
-  n: nonNegativeInteger,
-  mean: finiteNumber.nullable(),
-  p50: finiteNumber.nullable(),
-  p95: finiteNumber.nullable(),
-  stddev: nonNegativeNumber.nullable(),
-  min: finiteNumber.nullable(),
-  max: finiteNumber.nullable(),
-  histogram: z.array(GainDistributionBinSchema),
-  tailRuns: z.array(
-    z.object({
-      runId: nonEmptyString,
-      score: finiteNumber
-    }).strict()
-  ).optional()
-}).strict().superRefine((distribution, ctx) => {
-  const values = [
-    distribution.mean,
-    distribution.p50,
-    distribution.p95,
-    distribution.stddev,
-    distribution.min,
-    distribution.max
-  ];
-  if (distribution.n === 0 && values.some((value) => value !== null)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "distribution values must be null when n is 0"
-    });
-  }
-  if (distribution.n > 0 && values.some((value) => value === null)) {
-    ctx.addIssue({
-      code: "custom",
-      message: "distribution values must be numbers when n is greater than 0"
-    });
-  }
-  if (distribution.min !== null && distribution.max !== null && distribution.min > distribution.max) {
-    ctx.addIssue({ code: "custom", path: ["min"], message: "min must not exceed max" });
-  }
-});
-var TokenUsageInsightSchema = z.object({
-  input: ScalarDistributionSchema,
-  output: ScalarDistributionSchema,
-  reasoning: ScalarDistributionSchema,
-  cached: ScalarDistributionSchema,
-  cacheWrite: ScalarDistributionSchema,
-  totals: z.object({
-    input: nonNegativeNumber,
-    output: nonNegativeNumber,
-    reasoning: nonNegativeNumber,
-    cached: nonNegativeNumber,
-    cacheWrite: nonNegativeNumber
-  }).strict()
-}).strict();
-var ExecutionErrorOutcomeCellSchema = z.object({
-  withErrors: nonNegativeInteger,
-  withoutErrors: nonNegativeInteger,
-  unreported: nonNegativeInteger
-}).strict();
-var ExecutionInsightSchema = z.object({
-  durationMs: ScalarDistributionSchema,
-  queueMs: ScalarDistributionSchema,
-  tokenUsage: TokenUsageInsightSchema,
-  aggregateUsage: z.object({
-    runs: nonNegativeInteger,
-    tokenUsage: TokenUsageInsightSchema,
-    costUsd: ScalarDistributionSchema,
-    totalCostUsd: nonNegativeNumber
-  }).strict(),
-  models: z.array(
-    z.object({
-      model: nonEmptyString,
-      runs: nonNegativeInteger
-    }).strict()
-  ),
-  modelCalls: z.object({
-    runs: nonNegativeInteger,
-    events: nonNegativeInteger,
-    reportingRuns: nonNegativeInteger
-  }).strict(),
-  executionErrors: z.object({
-    runs: nonNegativeInteger,
-    fraction: finiteNumber.min(0).max(1).nullable(),
-    events: nonNegativeInteger,
-    reportingRuns: nonNegativeInteger,
-    errorSpanEvents: nonNegativeInteger,
-    errorSpanReportingRuns: nonNegativeInteger,
-    byTerminalOutcome: z.object({
-      succeeded: ExecutionErrorOutcomeCellSchema,
-      failed: ExecutionErrorOutcomeCellSchema,
-      cancelled: ExecutionErrorOutcomeCellSchema,
-      incomplete: ExecutionErrorOutcomeCellSchema,
-      unknown: ExecutionErrorOutcomeCellSchema
-    }).strict()
-  }).strict(),
-  terminalOutcomes: z.object({
-    succeeded: nonNegativeInteger,
-    failed: nonNegativeInteger,
-    cancelled: nonNegativeInteger,
-    incomplete: nonNegativeInteger,
-    unknown: nonNegativeInteger
-  }).strict()
-}).strict();
-var CostProvenanceSummarySchema = z.object({
-  observed: z.object({
-    n: nonNegativeInteger,
-    totalUsd: nonNegativeNumber
-  }).strict(),
-  estimated: z.object({
-    n: nonNegativeInteger,
-    totalUsd: nonNegativeNumber
-  }).strict(),
-  uncaptured: z.object({ n: nonNegativeInteger }).strict(),
-  knownFraction: finiteNumber.min(0).max(1)
-}).strict();
-var ParetoFigureSpecSchema = z.object({
-  kind: z.literal("pareto-cost-quality"),
-  split: z.enum(["search", "holdout"]),
-  points: z.array(
-    z.object({
-      candidateId: nonEmptyString,
-      cost: nonNegativeNumber,
-      quality: finiteNumber,
-      n: nonNegativeInteger,
-      onFrontier: z.boolean(),
-      gate: z.enum(["promote", "reject"]).optional()
-    }).strict()
-  ),
-  axes: z.object({ x: z.literal("costUsd"), y: z.literal("score") }).strict()
-}).strict();
-var ContinuousAgreementSchema = z.object({
-  weightedKappa: finiteNumber,
-  icc: finiteNumber,
-  pearson: finiteNumber,
-  spearman: finiteNumber,
-  ci: z.object({
-    icc: z.tuple([finiteNumber, finiteNumber]),
-    weightedKappa: z.tuple([finiteNumber, finiteNumber])
-  }).strict(),
-  n: nonNegativeInteger,
-  raters: nonNegativeInteger
-}).strict();
-var JudgeInsightSchema = z.object({
-  n: nonNegativeInteger,
-  meanScore: finiteNumber,
-  calibration: ContinuousAgreementSchema.optional(),
-  positionalBias: finiteNumber.optional(),
-  selfPreference: finiteNumber.optional(),
-  verbosityBias: finiteNumber.optional()
-}).strict();
-var InterRaterInsightSchema = z.object({
-  raters: nonNegativeInteger,
-  jointlyRated: nonNegativeInteger,
-  kappa: finiteNumber,
-  icc: finiteNumber,
-  pearson: finiteNumber,
-  spearman: finiteNumber,
-  perPair: z.record(z.string(), finiteNumber),
-  disagreementCases: z.array(
-    z.object({
-      runId: nonEmptyString,
-      ratings: z.array(
-        z.object({
-          rater: nonEmptyString,
-          score: finiteNumber
-        }).strict()
-      ),
-      range: nonNegativeNumber
-    }).strict()
-  )
-}).strict();
-var LiftInsightSchema = z.object({
-  baselineMean: finiteNumber,
-  candidateMean: finiteNumber,
-  delta: finiteNumber,
-  ci95: z.tuple([finiteNumber, finiteNumber]),
-  pValue: finiteNumber.min(0).max(1),
-  n: nonNegativeInteger,
-  unpairedBaseline: nonNegativeInteger,
-  unpairedCandidate: nonNegativeInteger,
-  cohensD: finiteNumber.nullable(),
-  mde: nonNegativeNumber,
-  requiredN: nonNegativeInteger.nullable()
-}).strict();
-var FailureClusterInsightSchema = z.object({
-  clusters: z.array(
-    z.object({
-      id: nonEmptyString,
-      name: nonEmptyString,
-      share: finiteNumber.min(0).max(1),
-      exemplars: z.array(nonEmptyString).max(5),
-      suggestedFix: nonEmptyString.optional()
-    }).strict()
-  ),
-  totalFailures: nonNegativeInteger
-}).strict();
-var ContaminationInsightSchema = z.object({
-  leaks: nonNegativeInteger,
-  holdoutAuditPassed: z.boolean(),
-  details: z.array(
-    z.object({
-      runId: nonEmptyString,
-      canary: nonEmptyString,
-      matched: nonEmptyString
-    }).strict()
-  ).optional()
-}).strict();
-var OutcomeCorrelationInsightSchema = z.object({
-  metric: nonEmptyString,
-  n: nonNegativeInteger,
-  pearson: finiteNumber,
-  spearman: finiteNumber,
-  rewardModel: z.object({
-    intercept: finiteNumber,
-    slope: finiteNumber,
-    r2: finiteNumber
-  }).strict().optional()
-}).strict();
-var ReleaseSummarySchema = z.object({
-  status: z.enum(["pass", "warn", "fail"]),
-  axes: z.array(
-    z.object({
-      name: z.enum(["quality-lift", "contamination", "composite-distribution"]),
-      status: z.enum(["pass", "warn", "fail", "not_evaluated"]),
-      detail: nonEmptyString
-    }).strict()
-  ),
-  issues: z.array(z.string())
-}).strict();
-var MetricDeltaSchema = z.object({
-  current: finiteNumber,
-  baseline: finiteNumber,
-  delta: finiteNumber,
-  ci95: z.tuple([finiteNumber, finiteNumber]),
-  pValue: finiteNumber.min(0).max(1),
-  cohensD: finiteNumber,
-  baselineN: nonNegativeInteger,
-  currentN: nonNegativeInteger,
-  significant: z.boolean()
-}).strict();
-var PriorPeriodComparisonSchema = z.object({
-  baselineN: nonNegativeInteger,
-  currentN: nonNegativeInteger,
-  windowLabel: nonEmptyString.optional(),
-  metrics: z.record(z.string(), MetricDeltaSchema),
-  regressedMetrics: z.array(nonEmptyString),
-  improvedMetrics: z.array(nonEmptyString)
-}).strict();
-var RecommendationSchema = z.object({
-  priority: z.enum(["critical", "high", "medium", "low"]),
-  kind: z.enum(["ship", "hold", "investigate", "fix", "recalibrate", "expand-corpus"]),
-  title: nonEmptyString,
-  detail: nonEmptyString,
-  evidencePath: nonEmptyString.optional()
-}).strict();
-var InsightReportSchema = z.object({
-  n: nonNegativeInteger,
-  execution: ExecutionInsightSchema,
-  composite: ScalarDistributionSchema,
-  perDimension: z.record(z.string(), ScalarDistributionSchema),
-  costQuality: z.object({
-    cost: ScalarDistributionSchema,
-    pareto: ParetoFigureSpecSchema,
-    provenance: CostProvenanceSummarySchema.optional(),
-    degraded: z.object({
-      cost: nonEmptyString.optional(),
-      pareto: nonEmptyString.optional()
-    }).strict().optional()
-  }).strict(),
-  judges: z.record(z.string(), JudgeInsightSchema),
-  interRater: InterRaterInsightSchema.optional(),
-  lift: LiftInsightSchema.optional(),
-  failureClusters: FailureClusterInsightSchema.optional(),
-  contamination: ContaminationInsightSchema.optional(),
-  outcomeCorrelation: OutcomeCorrelationInsightSchema.optional(),
-  release: ReleaseSummarySchema,
-  priorPeriodComparison: PriorPeriodComparisonSchema.optional(),
-  failureClasses: z.array(
-    z.object({
-      failureClass: FailureClassSchema,
-      count: nonNegativeInteger,
-      share: finiteNumber.min(0).max(1)
-    }).strict()
-  ).optional(),
-  recommendations: z.array(RecommendationSchema)
-}).strict();
-var sha256Digest = z.custom(
-  (value) => typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value),
-  "expected sha256:<64 lowercase hex characters>"
-);
-var MutableSurfaceSchema = z.union([
-  z.string(),
-  z.object({
-    kind: z.literal("components"),
-    components: z.record(z.string(), z.string())
-  }).strict(),
-  z.object({
-    kind: z.literal("code"),
-    worktreeRef: nonEmptyString,
-    baseRef: nonEmptyString,
-    baseCommit: nonEmptyString,
-    baseTree: nonEmptyString,
-    candidateCommit: nonEmptyString,
-    candidateTree: nonEmptyString,
-    patch: z.object({
-      format: z.literal("git-diff-binary"),
-      sha256: sha256Digest,
-      byteLength: nonNegativeInteger
-    }).strict(),
-    summary: z.string().optional()
-  }).strict()
-]);
-var RunTerminalOutcomeSchema = z.enum([
-  "succeeded",
-  "failed",
-  "cancelled",
-  "incomplete",
-  "unknown"
-]);
-var EvalRunCellScoreSchema = z.object({
-  scenarioId: nonEmptyString,
-  rep: nonNegativeInteger,
-  compositeMean: finiteNumber.nullable(),
-  dimensions: z.record(z.string(), z.record(z.string(), finiteNumber)),
-  terminalOutcome: RunTerminalOutcomeSchema,
-  executionErrorCount: nonNegativeInteger.nullable(),
-  errorMessage: z.string().optional()
-}).strict();
-var EvalRunGenerationSnapshotSchema = z.object({
-  index: nonNegativeInteger,
-  surfaceHash: nonEmptyString,
-  surface: MutableSurfaceSchema.optional(),
-  cells: z.array(EvalRunCellScoreSchema),
-  compositeMean: finiteNumber.nullable(),
-  costUsd: nonNegativeNumber,
-  durationMs: nonNegativeNumber
-}).strict();
-var EvalRunStatusSchema = z.enum([
-  "started",
-  "baseline-complete",
-  "generation-complete",
-  "gate-decided",
-  "finished",
-  "errored"
-]);
-var GateDecisionSchema = z.enum([
-  "ship",
-  "hold",
-  "need_more_work",
-  "model_ceiling",
-  "arch_ceiling"
-]);
-var EvalRunEventSchema = z.object({
-  runId: nonEmptyString,
-  runDir: nonEmptyString,
-  timestamp: z.string().datetime({ offset: true }),
-  status: EvalRunStatusSchema,
-  labels: z.record(z.string(), z.string()),
-  baseline: EvalRunGenerationSnapshotSchema.optional(),
-  generations: z.array(EvalRunGenerationSnapshotSchema),
-  gateDecision: GateDecisionSchema.optional(),
-  holdoutLift: finiteNumber.optional(),
-  totalCostUsd: nonNegativeNumber,
-  totalDurationMs: nonNegativeNumber,
-  errorMessage: z.string().optional(),
-  insightReport: InsightReportSchema.optional()
-}).strict().superRefine((event, ctx) => {
-  if (event.baseline && event.baseline.index !== 0) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["baseline", "index"],
-      message: "baseline index must be 0"
-    });
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (let i = 0; i < event.generations.length; i++) {
-    const index = event.generations[i].index;
-    if (seen.has(index)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["generations", i, "index"],
-        message: `duplicate generation index ${index}`
-      });
-    }
-    seen.add(index);
-  }
-  if (event.status === "errored" && !event.errorMessage?.trim()) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["errorMessage"],
-      message: "errorMessage is required when status is errored"
-    });
-  }
-});
-var TraceSpanEventEntrySchema = z.object({
-  timeUnixNano: UnixNanoTimestampSchema,
-  name: nonEmptyString,
-  attributes: attributes.optional()
-}).strict();
-var TraceSpanEventSchema = z.object({
-  traceId: nonEmptyString,
-  spanId: nonEmptyString,
-  parentSpanId: nonEmptyString.optional(),
-  name: nonEmptyString,
-  startTimeUnixNano: UnixNanoTimestampSchema,
-  endTimeUnixNano: UnixNanoTimestampSchema,
-  attributes,
-  events: z.array(TraceSpanEventEntrySchema).optional(),
-  status: z.object({
-    code: z.enum(["OK", "ERROR", "UNSET"]),
-    message: z.string().optional()
-  }).strict().optional(),
-  "tangle.runId": nonEmptyString.optional(),
-  "tangle.generation": nonNegativeInteger.optional(),
-  "tangle.cellId": nonEmptyString.optional(),
-  "tangle.scenarioId": nonEmptyString.optional()
-}).strict().refine((span) => BigInt(span.endTimeUnixNano) >= BigInt(span.startTimeUnixNano), {
-  path: ["endTimeUnixNano"],
-  message: "endTimeUnixNano must be greater than or equal to startTimeUnixNano"
-});
-var IngestEvalRunsEnvelopeSchema = z.object({
-  wireVersion: z.literal(HOSTED_WIRE_VERSION),
-  events: z.array(z.unknown())
-}).strict();
-var IngestTracesEnvelopeSchema = z.object({
-  wireVersion: z.literal(HOSTED_WIRE_VERSION),
-  spans: z.array(z.unknown())
-}).strict();
-var IngestEvalRunsRequestSchema = z.object({
-  wireVersion: z.literal(HOSTED_WIRE_VERSION),
-  events: z.array(EvalRunEventSchema)
-}).strict();
-var IngestTracesRequestSchema = z.object({
-  wireVersion: z.literal(HOSTED_WIRE_VERSION),
-  spans: z.array(TraceSpanEventSchema)
-}).strict();
-var IngestResponseSchema = z.object({
-  accepted: nonNegativeInteger,
-  rejected: z.array(
-    z.object({
-      index: nonNegativeInteger,
-      reason: nonEmptyString
-    }).strict()
-  )
-}).strict();
-
-// src/hosted/client.ts
-var MAX_IDEMPOTENCY_KEY_LENGTH = 256;
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function normalizeHostedBase(endpoint) {
-  return endpoint.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
-}
-function resolveIdempotencyKey(key) {
-  const resolved = key ?? globalThis.crypto.randomUUID();
-  if (resolved.trim().length === 0) throw new Error("idempotency key must not be blank");
-  if (resolved.length > MAX_IDEMPOTENCY_KEY_LENGTH) {
-    throw new Error(`idempotency key must be at most ${MAX_IDEMPOTENCY_KEY_LENGTH} characters`);
-  }
-  return resolved;
-}
-function responseValidationReason(error) {
-  return error.issues.map(
-    (issue) => `${issue.path.length > 0 ? issue.path.map(String).join(".") : "value"}: ${issue.message}`
-  ).join("; ");
-}
-async function post(tenant, path, body, opts = {}) {
-  const timeoutMs = tenant.timeoutMs ?? 3e4;
-  const maxRetries = tenant.retries ?? 2;
-  const f = tenant.fetchImpl ?? ((...args) => fetch(...args));
-  const base = normalizeHostedBase(tenant.endpoint);
-  const url = `${base}${path}`;
-  const idempotencyKey = resolveIdempotencyKey(opts.idempotencyKey);
-  const headers = {
-    "content-type": "application/json",
-    authorization: `Bearer ${tenant.apiKey}`,
-    "x-tangle-tenant-id": tenant.tenantId,
-    "x-tangle-wire-version": HOSTED_WIRE_VERSION,
-    "idempotency-key": idempotencyKey
-  };
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    const ourTimeout = AbortSignal.timeout(timeoutMs);
-    const combinedSignal = opts.signal ? AbortSignal.any([opts.signal, ourTimeout]) : ourTimeout;
-    let res;
-    try {
-      res = await f(url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body),
-        signal: combinedSignal
-      });
-    } catch (err) {
-      if (opts.signal?.aborted) throw err;
-      lastError = err;
-      if (attempt === maxRetries) throw err;
-      await sleep(2 ** attempt * 200 + Math.random() * 200);
-      continue;
-    }
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      const error = new Error(`hosted ingest ${url} failed (${res.status}): ${text.slice(0, 500)}`);
-      const retryable = res.status >= 500 || res.status === 408 || res.status === 429;
-      if (!retryable || attempt === maxRetries) throw error;
-      lastError = error;
-      await sleep(2 ** attempt * 200 + Math.random() * 200);
-      continue;
-    }
-    let rawResponse;
-    try {
-      rawResponse = await res.json();
-    } catch (error) {
-      throw new Error(`hosted ingest ${url} returned invalid JSON`, { cause: error });
-    }
-    const parsed = IngestResponseSchema.safeParse(rawResponse);
-    if (!parsed.success) {
-      throw new Error(
-        `hosted ingest ${url} returned an invalid response: ${responseValidationReason(parsed.error)}`
-      );
-    }
-    return parsed.data;
-  }
-  throw lastError ?? new Error("hosted ingest exhausted retries");
-}
-function createHostedClient(tenant) {
-  if (normalizeHostedBase(tenant.endpoint).length === 0) throw new Error("endpoint is required");
-  if (tenant.apiKey.trim().length === 0) throw new Error("apiKey is required");
-  if (tenant.tenantId.trim().length === 0) throw new Error("tenantId is required");
-  if (tenant.timeoutMs !== void 0 && (!Number.isFinite(tenant.timeoutMs) || tenant.timeoutMs <= 0)) {
-    throw new Error("timeoutMs must be greater than 0");
-  }
-  if (tenant.retries !== void 0 && (!Number.isInteger(tenant.retries) || tenant.retries < 0)) {
-    throw new Error("retries must be a non-negative integer");
-  }
-  return {
-    tenant,
-    wireVersion: HOSTED_WIRE_VERSION,
-    async ingestEvalRun(event, idempotencyKey) {
-      return this.ingestEvalRuns([event], idempotencyKey);
-    },
-    async ingestEvalRuns(events, idempotencyKey) {
-      const body = IngestEvalRunsRequestSchema.parse({
-        wireVersion: HOSTED_WIRE_VERSION,
-        events
-      });
-      return post(tenant, "/v1/ingest/eval-runs", body, {
-        idempotencyKey
-      });
-    },
-    async ingestTraces(spans, idempotencyKey) {
-      const body = IngestTracesRequestSchema.parse({
-        wireVersion: HOSTED_WIRE_VERSION,
-        spans
-      });
-      return post(tenant, "/v1/ingest/traces", body, {
-        idempotencyKey
-      });
-    }
-  };
-}
-function hostedTenantFromEnv(overrides = {}) {
-  const env = overrides.env ?? process.env;
-  const endpoint = (overrides.endpoint ?? env.TANGLE_INGEST_URL ?? env.TANGLE_ORCHESTRATOR_URL)?.trim();
-  const apiKey = (overrides.apiKey ?? env.TANGLE_INGEST_API_KEY ?? env.TANGLE_API_KEY)?.trim();
-  const tenantId = (overrides.tenantId ?? env.TANGLE_TENANT_ID)?.trim();
-  if (!endpoint || !apiKey || !tenantId) return void 0;
-  const tenant = { endpoint: endpoint.replace(/\/+$/, ""), apiKey, tenantId };
-  if (overrides.fetchImpl) tenant.fetchImpl = overrides.fetchImpl;
-  if (overrides.timeoutMs !== void 0) tenant.timeoutMs = overrides.timeoutMs;
-  if (overrides.retries !== void 0) tenant.retries = overrides.retries;
-  return tenant;
-}
-function hostedClientFromEnv(overrides = {}) {
-  const tenant = hostedTenantFromEnv(overrides);
-  return tenant ? createHostedClient(tenant) : void 0;
-}
-
-export {
-  HOSTED_WIRE_VERSION,
-  UnixNanoTimestampSchema,
-  InsightReportSchema,
-  MutableSurfaceSchema,
-  RunTerminalOutcomeSchema,
-  EvalRunCellScoreSchema,
-  EvalRunGenerationSnapshotSchema,
-  EvalRunEventSchema,
-  TraceSpanEventSchema,
-  IngestEvalRunsRequestSchema,
-  IngestTracesRequestSchema,
-  IngestResponseSchema,
-  createHostedClient,
-  hostedTenantFromEnv,
-  hostedClientFromEnv
-};
-//# sourceMappingURL=chunk-DRYIUNWY.js.map