@tangle-network/agent-eval 0.129.0 → 0.130.0

package/dist/client-CYzbdJOZ.js

@@ -0,0 +1,637 @@
+import { t as FAILURE_CLASSES } from "./schema-CRhEY1SO.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(),
+	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),
+	n: nonNegativeInteger,
+	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 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();
+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)
+}).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 { EvalRunEventSchema as a, IngestResponseSchema as c, MutableSurfaceSchema as d, RunTerminalOutcomeSchema as f, HOSTED_WIRE_VERSION as h, EvalRunCellScoreSchema as i, IngestTracesRequestSchema as l, UnixNanoTimestampSchema as m, hostedClientFromEnv as n, EvalRunGenerationSnapshotSchema as o, TraceSpanEventSchema as p, hostedTenantFromEnv as r, IngestEvalRunsRequestSchema as s, createHostedClient as t, InsightReportSchema as u };
+
+//# sourceMappingURL=client-CYzbdJOZ.js.map