@tangle-network/agent-eval 0.190.1 → 0.192.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"client-BhEyAdfe.d.ts","names":[],"sources":["../src/hosted/types.ts","../src/hosted/client.ts"],"mappings":";;;;cAgCa;KACD,2BAA2B;;UAKtB;;EAEf;;EAEA;;EAEA,yBAAyB;;EAEzB;;;KAMU;UAQK;;EAEf;;EAEA;;EAEA;;EAEA,YAAY,eAAe;;EAE3B,iBAAiB;;EAEjB;;EAEA;;UAGe;;EAEf;;;EAGA;;;EAGA,UAAU;;EAEV,OAAO;;EAEP;;EAEA;;EAEA;;;;;;;UAQe;;EAEf;;EAEA;;EAEA;;EAEA,QAAQ;;EAER,QAAQ;;EAER,WAAW;;EAEX,aAAa;;EAEb,eAAe;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;EAMA,gBAAgB;;;;;;KASN;;;;;;UAOK;EACf;EACA;EACA;EACA;EACA,mBAAmB;EACnB,iBAAiB;EACjB,YAAY;EACZ,SAAS;IACP,cAAc;IACd;IACA,aAAa;;EAEf;IAAW;IAAgC;;;EAE3C;;EAEA;;EAEA;;EAEA;;UAKe;EACf,aAAa;EACb,QAAQ;;UAGO;EACf,aAAa;EACb,OAAO;;UAGQ;;EAEf;;EAEA,UAAU;IAAQ;IAAe;;;;;UC1JlB;;EAEf;;EAEA;;EAEA;;EAEA,mBAAmB;;EAEnB;;EAEA;;UAGe;EACf,cAAc,OAAO,cAAc,0BAA0B,QAAQ;EACrE,eAAe,QAAQ,gBAAgB,0BAA0B,QAAQ;EACzE,aAAa,OAAO,kBAAkB,0BAA0B,QAAQ;WAC/D,QAAQ;WACR,aAAa;;iBAyGR,mBAAmB,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsE1C,oBACd,YAAW,QAAQ;EAAkB,MAAM;IAC1C;iBAiBa,oBACd,YAAW,QAAQ;EAAkB,MAAM;IAC1C"}

package/dist/client-QwJpsNYU.js

@@ -1,655 +0,0 @@
-import { t as FAILURE_CLASSES } from "./schema-CSf6qWgZ.js";
-import { z } from "zod";
-//#region src/hosted/types.ts
-const HOSTED_WIRE_VERSION = "2026-07-24.v1";
-//#endregion
-//#region src/hosted/schemas.ts
-const finiteNumber = z.number().finite();
-const nonNegativeNumber = finiteNumber.nonnegative();
-const nonNegativeInteger = z.number().int().nonnegative();
-const nonEmptyString = z.string().min(1).refine((value) => value.trim().length > 0, "must not be blank");
-const attributeValue = z.union([
-	z.string(),
-	finiteNumber,
-	z.boolean()
-]);
-const attributes = z.record(z.string(), attributeValue);
-const FailureClassSchema = z.custom((value) => typeof value === "string" && FAILURE_CLASSES.includes(value), `expected one of ${FAILURE_CLASSES.join(", ")}`);
-const UINT64_MAX = 18446744073709551615n;
-const 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");
-const GainDistributionBinSchema = z.object({
-	lo: finiteNumber,
-	hi: finiteNumber,
-	count: nonNegativeInteger
-}).strict();
-const 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"
-	});
-});
-const 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();
-const ExecutionErrorOutcomeCellSchema = z.object({
-	withErrors: nonNegativeInteger,
-	withoutErrors: nonNegativeInteger,
-	unreported: nonNegativeInteger
-}).strict();
-const 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();
-const CostProvenanceSummarySchema = z.object({
-	observed: z.object({
-		n: nonNegativeInteger,
-		totalUsd: nonNegativeNumber
-	}).strict(),
-	estimated: z.object({
-		n: nonNegativeInteger,
-		totalUsd: nonNegativeNumber
-	}).strict(),
-	lowerBound: z.object({
-		n: nonNegativeInteger,
-		floorUsd: nonNegativeNumber
-	}).strict(),
-	uncaptured: z.object({ n: nonNegativeInteger }).strict(),
-	knownFraction: finiteNumber.min(0).max(1)
-}).strict();
-const 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();
-const 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();
-const JudgeInsightSchema = z.object({
-	n: nonNegativeInteger,
-	meanScore: finiteNumber,
-	calibration: ContinuousAgreementSchema.optional(),
-	positionalBias: finiteNumber.optional(),
-	selfPreference: finiteNumber.optional(),
-	verbosityBias: finiteNumber.optional()
-}).strict();
-const 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();
-const LiftInsightSchema = z.object({
-	baselineMean: finiteNumber,
-	candidateMean: finiteNumber,
-	delta: finiteNumber,
-	ci95: z.tuple([finiteNumber, finiteNumber]),
-	pValue: finiteNumber.min(0).max(1).nullable(),
-	n: nonNegativeInteger,
-	pairedRunN: nonNegativeInteger.optional(),
-	independentUnitIds: z.array(nonEmptyString).optional(),
-	minimumRequired: z.number().int().positive(),
-	decisionEligible: z.boolean(),
-	unpairedBaseline: nonNegativeInteger,
-	unpairedCandidate: nonNegativeInteger,
-	cohensD: finiteNumber.nullable(),
-	mde: nonNegativeNumber,
-	requiredN: nonNegativeInteger.nullable()
-}).strict();
-const 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();
-const ContaminationInsightSchema = z.object({
-	leaks: nonNegativeInteger,
-	holdoutAuditPassed: z.boolean(),
-	details: z.array(z.object({
-		runId: nonEmptyString,
-		canary: nonEmptyString,
-		matched: nonEmptyString
-	}).strict()).optional()
-}).strict();
-const OutcomeCorrelationInsightSchema = z.object({
-	metric: nonEmptyString,
-	n: nonNegativeInteger,
-	pearson: finiteNumber,
-	spearman: finiteNumber,
-	rewardModel: z.object({
-		intercept: finiteNumber,
-		slope: finiteNumber,
-		r2: finiteNumber
-	}).strict().optional()
-}).strict();
-const 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();
-const MetricDeltaBaseSchema = z.object({
-	current: finiteNumber,
-	baseline: finiteNumber,
-	delta: finiteNumber,
-	baselineN: nonNegativeInteger,
-	currentN: nonNegativeInteger
-}).strict();
-const MetricDeltaSchema = z.discriminatedUnion("status", [MetricDeltaBaseSchema.extend({
-	status: z.literal("ok"),
-	ci95: z.tuple([finiteNumber, finiteNumber]),
-	pValue: finiteNumber.min(0).max(1),
-	cohensD: finiteNumber,
-	significant: z.boolean()
-}), MetricDeltaBaseSchema.extend({
-	status: z.enum(["insufficient-sample", "zero-variance"]),
-	ci95: z.null(),
-	pValue: z.null(),
-	cohensD: z.null(),
-	significant: z.literal(false)
-})]);
-const PriorPeriodComparisonSchema = z.object({
-	baselineN: nonNegativeInteger,
-	currentN: nonNegativeInteger,
-	windowLabel: nonEmptyString.optional(),
-	metrics: z.record(z.string(), MetricDeltaSchema),
-	regressedMetrics: z.array(nonEmptyString),
-	improvedMetrics: z.array(nonEmptyString),
-	inconclusiveMetrics: z.array(nonEmptyString)
-}).strict();
-const 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();
-const 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();
-const sha256Digest = z.custom((value) => typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value), "expected sha256:<64 lowercase hex characters>");
-const 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()
-]);
-const RunTerminalOutcomeSchema = z.enum([
-	"succeeded",
-	"failed",
-	"cancelled",
-	"incomplete",
-	"unknown"
-]);
-const 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();
-const EvalRunGenerationSnapshotSchema = z.object({
-	index: nonNegativeInteger,
-	surfaceHash: nonEmptyString,
-	surface: MutableSurfaceSchema.optional(),
-	cells: z.array(EvalRunCellScoreSchema),
-	compositeMean: finiteNumber.nullable(),
-	costUsd: nonNegativeNumber,
-	durationMs: nonNegativeNumber
-}).strict();
-const EvalRunStatusSchema = z.enum([
-	"started",
-	"baseline-complete",
-	"generation-complete",
-	"gate-decided",
-	"finished",
-	"errored"
-]);
-const GateDecisionSchema = z.enum([
-	"ship",
-	"hold",
-	"need_more_work",
-	"model_ceiling",
-	"arch_ceiling"
-]);
-const 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"
-	});
-});
-const TraceSpanEventEntrySchema = z.object({
-	timeUnixNano: UnixNanoTimestampSchema,
-	name: nonEmptyString,
-	attributes: attributes.optional()
-}).strict();
-const 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"
-});
-z.object({
-	wireVersion: z.literal(HOSTED_WIRE_VERSION),
-	events: z.array(z.unknown())
-}).strict();
-z.object({
-	wireVersion: z.literal(HOSTED_WIRE_VERSION),
-	spans: z.array(z.unknown())
-}).strict();
-const IngestEvalRunsRequestSchema = z.object({
-	wireVersion: z.literal(HOSTED_WIRE_VERSION),
-	events: z.array(EvalRunEventSchema)
-}).strict();
-const IngestTracesRequestSchema = z.object({
-	wireVersion: z.literal(HOSTED_WIRE_VERSION),
-	spans: z.array(TraceSpanEventSchema)
-}).strict();
-const IngestResponseSchema = z.object({
-	accepted: nonNegativeInteger,
-	rejected: z.array(z.object({
-		index: nonNegativeInteger,
-		reason: nonEmptyString
-	}).strict())
-}).strict();
-//#endregion
-//#region src/hosted/client.ts
-/**
-* # Hosted-tier ingest client.
-*
-* Ships eval-run events + trace spans to any orchestrator (ours, a
-* partner's self-hosted one, or a future open implementation) that
-* speaks the wire format in `./types.ts`.
-*
-* Three modes:
-*   - **Ours:** point at `https://orchestrator.tangle.tools` (the host root —
-*     the client appends the versioned `/v1/ingest/...` path itself; a trailing
-*     `/v1` on the endpoint is tolerated and normalized away). We handle ingest
-*     + storage + dashboard.
-*   - **Self-hosted:** point at whatever URL runs the reference receiver
-*     from `examples/hosted-ingest-server/`.
-*   - **Off (default):** when `hostedTenant` is unset, nothing is sent.
-*     Everything stays local.
-*/
-const 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 url = `${normalizeHostedBase(tenant.endpoint)}${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 = /* @__PURE__ */ new Error(`hosted ingest ${url} failed (${res.status}): ${text.slice(0, 500)}`);
-			if (!(res.status >= 500 || res.status === 408 || res.status === 429) || 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 ?? /* @__PURE__ */ 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) {
-			return post(tenant, "/v1/ingest/eval-runs", IngestEvalRunsRequestSchema.parse({
-				wireVersion: HOSTED_WIRE_VERSION,
-				events
-			}), { idempotencyKey });
-		},
-		async ingestTraces(spans, idempotencyKey) {
-			return post(tenant, "/v1/ingest/traces", IngestTracesRequestSchema.parse({
-				wireVersion: HOSTED_WIRE_VERSION,
-				spans
-			}), { idempotencyKey });
-		}
-	};
-}
-/**
-* 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.
-*/
-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;
-}
-//#endregion
-export { IngestEvalRunsRequestSchema as a, InsightReportSchema as c, HOSTED_WIRE_VERSION as d, EvalRunEventSchema as i, TraceSpanEventSchema as l, hostedClientFromEnv as n, IngestResponseSchema as o, hostedTenantFromEnv as r, IngestTracesRequestSchema as s, createHostedClient as t, UnixNanoTimestampSchema as u };
-
-//# sourceMappingURL=client-QwJpsNYU.js.map