@lmnr-ai/lmnr 0.8.39 → 0.8.41

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
-const require_dist = require("./dist-oS06mAi1.cjs");
+const require_dist = require("./dist-BNoIH9xW.cjs");
 const require_consts = require("./consts-DV6_Ea-8.cjs");
 let _opentelemetry_api = require("@opentelemetry/api");
 let _opentelemetry_context_async_hooks = require("@opentelemetry/context-async-hooks");
@@ -41,6 +41,25 @@ let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
 let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 let node_diagnostics_channel = require("node:diagnostics_channel");
 node_diagnostics_channel = require_rolldown_runtime.__toESM(node_diagnostics_channel);
+//#region src/datasets/prng.ts
+const UINT32 = 4294967296;
+const seededPerm = (n, seed) => {
+	let state = seed >>> 0;
+	const next = () => {
+		state = state + 1831565813 >>> 0;
+		let t = state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / UINT32;
+	};
+	const ix = Array.from({ length: n }, (_, i) => i);
+	for (let i = n - 1; i > 0; i--) {
+		const j = Math.floor(next() * (i + 1));
+		[ix[i], ix[j]] = [ix[j], ix[i]];
+	}
+	return ix;
+};
+//#endregion
 //#region src/datasets.ts
 const DEFAULT_FETCH_SIZE = 25;
 var EvaluationDataset = class {
@@ -49,13 +68,66 @@ var EvaluationDataset = class {
 		for (let i = Math.max(start, 0); i < Math.min(end, await this.size()); i++) result.push(await this.get(i));
 		return result;
 	}
+	sourceDataset() {}
+	take(n) {
+		return new Transformed(this, async (base) => {
+			if (!Number.isInteger(n)) throw new Error(`take count ${n} is not an integer`);
+			const size = await base.size();
+			const count = Math.max(0, Math.min(n, size));
+			return Array.from({ length: count }, (_, i) => i);
+		});
+	}
+	select(indices) {
+		const selected = [...indices];
+		return new Transformed(this, async (base) => {
+			const size = await base.size();
+			for (const index of selected) {
+				if (!Number.isInteger(index)) throw new Error(`select index ${index} is not an integer`);
+				if (index < 0 || index >= size) throw new Error(`select index ${index} is out of range for dataset of size ${size}`);
+			}
+			return selected;
+		});
+	}
+	shuffle({ seed = 0 } = {}) {
+		return new Transformed(this, async (base) => seededPerm(await base.size(), seed));
+	}
+};
+var Transformed = class extends EvaluationDataset {
+	constructor(base, resolve) {
+		super();
+		this.indices = null;
+		this.resolving = null;
+		this.base = base;
+		this.resolve = resolve;
+	}
+	resolveIndices() {
+		if (this.indices !== null) return Promise.resolve(this.indices);
+		if (this.resolving === null) this.resolving = this.resolve(this.base).then((indices) => {
+			this.indices = indices;
+			return indices;
+		}).catch((err) => {
+			this.resolving = null;
+			throw err;
+		});
+		return this.resolving;
+	}
+	async size() {
+		return (await this.resolveIndices()).length;
+	}
+	async get(index) {
+		const indices = await this.resolveIndices();
+		if (index < 0 || index >= indices.length) throw new Error(`Index ${index} is out of range for dataset of size ${indices.length}`);
+		return await this.base.get(indices[index]);
+	}
+	sourceDataset() {
+		return this.base.sourceDataset();
+	}
 };
 var LaminarDataset = class extends EvaluationDataset {
 	constructor(name, options) {
 		super();
-		this.fetchedItems = [];
+		this.pages = /* @__PURE__ */ new Map();
 		this.len = null;
-		this.offset = 0;
 		this.client = void 0;
 		if (!name && !options?.id) throw new Error("Either name or id must be provided");
 		if (name && options?.id) throw new Error("Only one of name or id must be provided");
@@ -66,25 +138,42 @@ var LaminarDataset = class extends EvaluationDataset {
 	setClient(client) {
 		this.client = client;
 	}
-	async fetchBatch() {
+	sourceDataset() {
+		return this;
+	}
+	fetchPage(offset) {
+		const existing = this.pages.get(offset);
+		if (existing) return existing;
+		const pending = this.doFetchPage(offset).catch((err) => {
+			this.pages.delete(offset);
+			throw err;
+		});
+		this.pages.set(offset, pending);
+		return pending;
+	}
+	async doFetchPage(offset) {
 		if (!this.client) throw new Error("Client not set");
 		const identifier = this.id ? { id: this.id } : { name: this.name };
 		const resp = await this.client.datasets.pull({
 			...identifier,
-			offset: this.offset,
+			offset,
 			limit: this.fetchSize
 		});
-		this.fetchedItems = this.fetchedItems.concat(resp.items);
-		this.offset = this.fetchedItems.length;
 		if (this.len === null) this.len = resp.totalCount;
+		return resp.items;
 	}
 	async size() {
-		if (this.len === null) await this.fetchBatch();
+		if (this.len === null) await this.fetchPage(0);
 		return this.len;
 	}
 	async get(index) {
-		if (index >= this.fetchedItems.length) await this.fetchBatch();
-		return this.fetchedItems[index];
+		if (index < 0) throw new Error(`Index ${index} is out of range`);
+		if (this.len !== null && index >= this.len) throw new Error(`Index ${index} is out of range for dataset of size ${this.len}`);
+		const offset = Math.floor(index / this.fetchSize) * this.fetchSize;
+		const page = await this.fetchPage(offset);
+		const local = index - offset;
+		if (local >= page.length) throw new Error(`Index ${index} is out of range for dataset of size ${this.len ?? "unknown"}`);
+		return page[local];
 	}
 	/**
 	* Push data from files to this dataset.
@@ -94,7 +183,7 @@ var LaminarDataset = class extends EvaluationDataset {
 	*/
 	async push(paths, recursive = false) {
 		if (!this.client) throw new Error("Client not set");
-		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-Bf15ARiL.cjs")).then((n) => n.file_utils_exports);
+		const { loadFromPaths } = await Promise.resolve().then(() => require("./file-utils-B7VBQSna.cjs")).then((n) => n.file_utils_exports);
 		const data = await loadFromPaths(Array.isArray(paths) ? paths : [paths], recursive);
 		if (data.length === 0) {
 			console.warn("No data to push. Skipping");
@@ -1063,11 +1152,11 @@ var LaminarSpan = class LaminarSpan {
 	}
 	setInput(input) {
 		const finalInput = typeof input === "string" ? input : JSON.stringify(input);
-		this._span.setAttribute(require_dist.SPAN_INPUT, finalInput);
+		this._span.setAttribute(require_dist.SPAN_INPUT, require_dist.truncateSpanPayload(finalInput, "input"));
 	}
 	setOutput(output) {
 		const finalOutput = typeof output === "string" ? output : JSON.stringify(output);
-		this._span.setAttribute(require_dist.SPAN_OUTPUT, finalOutput);
+		this._span.setAttribute(require_dist.SPAN_OUTPUT, require_dist.truncateSpanPayload(finalOutput, "output"));
 	}
 	setTags(tags) {
 		this._span.setAttribute(`${require_dist.ASSOCIATION_PROPERTIES}.tags`, Array.from(new Set(tags)));
@@ -1340,12 +1429,181 @@ const BEDROCK_USE_ENV = "CLAUDE_CODE_USE_BEDROCK";
 const BEDROCK_AWS_REGION_ENV = "AWS_REGION";
 const VERTEX_BASE_URL_ENV = "ANTHROPIC_VERTEX_BASE_URL";
 const VERTEX_USE_ENV = "CLAUDE_CODE_USE_VERTEX";
+const PROXY_BASE_URL_ENV_KEYS = [
+	"ANTHROPIC_BASE_URL",
+	FOUNDRY_BASE_URL_ENV,
+	BEDROCK_BASE_URL_ENV,
+	VERTEX_BASE_URL_ENV
+];
+const PROVIDER_BASE_URL_ENV_KEYS = [
+	[FOUNDRY_BASE_URL_ENV, FOUNDRY_USE_ENV],
+	[BEDROCK_BASE_URL_ENV, BEDROCK_USE_ENV],
+	[VERTEX_BASE_URL_ENV, VERTEX_USE_ENV]
+];
+const PROXY_ENV_KEYS = [
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"http_proxy",
+	"https_proxy"
+];
+const PROXY_NEUTRALIZED_ENV_KEYS = [...PROXY_ENV_KEYS, FOUNDRY_RESOURCE_ENV];
+const UPSTREAM_SETTINGS_EXCLUDED_ENV_KEYS = PROXY_ENV_KEYS;
 const activeProxyServers = /* @__PURE__ */ new Set();
 let globalShutdownRegistered = false;
 /**
-* Check if environment variable value is truthy (equals '1')
+* Check whether an env value enables a feature.
+*
+* Claude Code accepts `1`, `true`, `yes`, and `on` (case-insensitive) — verified
+* against the bundled CLI. Accepting only `"1"` would miss a provider the CLI
+* considers enabled, so we would blank its routing keys without pinning a base
+* URL and break the run.
 */
-const isTruthyEnv = (value) => value === "1";
+const isTruthyEnv = (value) => {
+	if (typeof value !== "string") return value === true;
+	return [
+		"1",
+		"true",
+		"yes",
+		"on"
+	].includes(value.trim().toLowerCase());
+};
+/**
+* Whether a provider flag is enabled in the given env, using the CLI's own
+* truthiness rules.
+*
+* Exported so the subprocess-env pin path shares ONE definition of "enabled"
+* with `getEnvVarsToRemove` / `buildProxyFlagSettings`. If they disagree, the
+* resource gets stripped without a base URL being pinned and the CLI hard-fails.
+*/
+const isProviderEnabledInEnv = (env, useKey) => isTruthyEnv(env[useKey]);
+/**
+* Load a Claude settings JSON file, or `null` when it could not be read.
+*
+* `null` (unreadable / malformed / not a JSON object) is deliberately distinct
+* from `{}` (a valid but empty settings file): callers that would otherwise
+* REPLACE a user's settings need to know they failed to read it.
+*/
+const loadSettingsFile = (filePath) => {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return null;
+};
+const settingsEnvBlock = (settings) => {
+	const env = settings.env;
+	if (!env || typeof env !== "object" || Array.isArray(env)) return {};
+	const result = {};
+	for (const [key, value] of Object.entries(env)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") result[key] = String(value);
+	return result;
+};
+/**
+* Read the merged `env` block from Claude Code's on-disk settings layers.
+*
+* Claude Code applies these to the CLI session with HIGHER priority than the
+* subprocess environment, so a user with `ANTHROPIC_BASE_URL` in
+* `~/.claude/settings.json` silently bypasses our proxy. We read them to resolve
+* the real upstream and to detect conflicts.
+*
+* Precedence (highest first): local project, shared project, user.
+*
+* `settingSources` mirrors `options.settingSources` and gates which layers are
+* read: `undefined` means the CLI loads all of them, an array means only those,
+* and `[]` disables on-disk settings entirely. Honoring it matters because
+* reading a layer the CLI was told to ignore would resolve an upstream the CLI
+* never uses, pointing the proxy at an unintended host.
+*/
+const readClaudeSettingsEnv = (cwd, settingSources) => {
+	const sessionCwd = cwd ?? process.cwd();
+	const userDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+	const layers = [
+		["user", path.join(userDir, "settings.json")],
+		["project", path.join(sessionCwd, ".claude", "settings.json")],
+		["local", path.join(sessionCwd, ".claude", "settings.local.json")]
+	];
+	const merged = {};
+	for (const [source, filePath] of layers) {
+		if (settingSources !== void 0 && !settingSources.includes(source)) continue;
+		Object.assign(merged, settingsEnvBlock(loadSettingsFile(filePath) ?? {}));
+	}
+	return merged;
+};
+/**
+* Read the `env` block out of the caller's `options.settings` (the flag layer).
+*
+* This layer OUTRANKS every on-disk layer, so a gateway or provider config that
+* lives only here is what the CLI would actually use — and
+* `buildProxyFlagSettings` is about to overwrite those keys with the proxy URL.
+* Upstream resolution must therefore see it FIRST, or we forward to the wrong
+* host (or to the default endpoint) while the caller's gateway is silently lost.
+*
+* Returns `{}` for a value we could not read; the caller's own bail-out logic in
+* `buildProxyFlagSettings` handles that case.
+*/
+const flagSettingsEnv = (existing, cwd) => {
+	if (typeof existing === "object" && existing !== null) return settingsEnvBlock(existing);
+	if (typeof existing !== "string" || !existing.trim()) return {};
+	const trimmed = existing.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return settingsEnvBlock(parsed);
+		} catch {}
+		return {};
+	}
+	return settingsEnvBlock(loadSettingsFile(path.isAbsolute(trimmed) ? trimmed : path.join(cwd ?? process.cwd(), trimmed)) ?? {});
+};
+/**
+* Build the `--settings` value that forces the CLI through our proxy.
+*
+* Claude Code resolves `env` from its settings layers with higher priority than
+* the subprocess environment, so rewriting `options.env` alone leaves a user with
+* `ANTHROPIC_BASE_URL` in `~/.claude/settings.json` talking straight to their
+* upstream while the proxy sees zero traffic (lmnr#2167). `--settings` is the
+* highest user-controlled layer, so writing the proxy URL there wins without ever
+* touching the user's files on disk.
+*
+* Layers merge per key, so keys we simply omit keep their lower-layer value.
+* Redirecting keys are therefore blanked rather than dropped.
+*
+* Returns the value to assign to `options.settings`, or `null` when the caller's
+* existing value is a file path we could not read (in that case the path must be
+* left alone so the CLI can still resolve it itself).
+*/
+const buildProxyFlagSettings = (existing, proxyUrl, cwd, settingSources) => {
+	let settingsObj = {};
+	if (typeof existing === "object" && existing !== null) settingsObj = { ...existing };
+	else if (typeof existing === "string" && existing.trim()) {
+		const trimmed = existing.trim();
+		if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+			let parsed;
+			try {
+				parsed = JSON.parse(trimmed);
+			} catch {
+				return null;
+			}
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+			settingsObj = parsed;
+		} else {
+			const loaded = loadSettingsFile(path.isAbsolute(trimmed) ? trimmed : path.join(cwd ?? process.cwd(), trimmed));
+			if (loaded === null) return null;
+			settingsObj = loaded;
+		}
+	}
+	const envDict = { ...settingsEnvBlock(settingsObj) };
+	const settingsEnv = readClaudeSettingsEnv(cwd, settingSources);
+	const inPlay = (key) => key in envDict || key in settingsEnv || process.env[key] !== void 0;
+	envDict.ANTHROPIC_BASE_URL = proxyUrl;
+	for (const [baseUrlKey, useKey] of PROVIDER_BASE_URL_ENV_KEYS) {
+		if (isTruthyEnv(envDict[useKey]) || isTruthyEnv(settingsEnv[useKey]) || isTruthyEnv(process.env[useKey]) || inPlay(baseUrlKey)) envDict[baseUrlKey] = proxyUrl;
+		if (baseUrlKey === FOUNDRY_BASE_URL_ENV && envDict[baseUrlKey] === proxyUrl) envDict[FOUNDRY_RESOURCE_ENV] = "";
+	}
+	for (const key of PROXY_NEUTRALIZED_ENV_KEYS) if (key in settingsEnv || key in envDict || process.env[key] !== void 0) envDict[key] = "";
+	return {
+		...settingsObj,
+		env: envDict
+	};
+};
 /**
 * Read region for a given profile from ~/.aws/config.
 */
@@ -1384,17 +1642,27 @@ const getRegionFromAwsConfig = (profile) => {
 * 4. ANTHROPIC_BASE_URL - standard Anthropic API base URL
 * 5. Fall back to default (https://api.anthropic.com)
 *
-* For each environment variable, checks envDict first, then process.env as fallback.
+* For each environment variable, checks envDict first, then process.env, then
+* Claude Code's on-disk settings `env` block. The settings layer is checked last
+* as a source for the *upstream* URL, but note it wins over process env inside
+* the CLI itself — see `buildProxyFlagSettings`.
 *
 * @param envDict - Dictionary of environment variables (e.g., from options.env)
 * @param fallback - Fallback URL if no other source found (default: DEFAULT_ANTHROPIC_BASE_URL)
+* @param cwd - Session root used to locate project settings (`options.cwd`)
 * @returns Resolved target URL, or null if provider is misconfigured
 */
-const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL) => {
-	const getEnvValue = (key) => envDict[key] || process.env[key];
-	const httpsProxy = getEnvValue("HTTPS_PROXY");
+const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL, cwd, settingSources, settings) => {
+	const flagEnv = flagSettingsEnv(settings, cwd);
+	const settingsEnv = readClaudeSettingsEnv(cwd, settingSources);
+	const getEnvValue = (key) => {
+		const value = envDict[key] || process.env[key];
+		if (value || UPSTREAM_SETTINGS_EXCLUDED_ENV_KEYS.includes(key)) return value;
+		return flagEnv[key] || settingsEnv[key];
+	};
+	const httpsProxy = getEnvValue("HTTPS_PROXY") || getEnvValue("https_proxy");
 	if (httpsProxy) return httpsProxy.replace(/\/$/, "");
-	const httpProxy = getEnvValue("HTTP_PROXY");
+	const httpProxy = getEnvValue("HTTP_PROXY") || getEnvValue("http_proxy");
 	if (httpProxy) return httpProxy.replace(/\/$/, "");
 	if (isTruthyEnv(getEnvValue(FOUNDRY_USE_ENV))) {
 		const foundryBaseUrl = getEnvValue(FOUNDRY_BASE_URL_ENV);
@@ -1430,9 +1698,10 @@ const resolveTargetUrlFromEnv = (envDict, fallback = DEFAULT_ANTHROPIC_BASE_URL)
 * @param envDict - Dictionary of environment variables
 * @returns Array of environment variable keys to remove
 */
-const getEnvVarsToRemove = (envDict) => {
-	const toRemove = ["HTTPS_PROXY", "HTTP_PROXY"];
-	const getEnvValue = (key) => envDict[key] || process.env[key];
+const getEnvVarsToRemove = (envDict, cwd, settingSources) => {
+	const toRemove = [...PROXY_ENV_KEYS];
+	const settingsEnv = readClaudeSettingsEnv(cwd, settingSources);
+	const getEnvValue = (key) => envDict[key] || process.env[key] || settingsEnv[key];
 	if (isTruthyEnv(getEnvValue(FOUNDRY_USE_ENV))) toRemove.push(FOUNDRY_RESOURCE_ENV);
 	return toRemove;
 };
@@ -1507,14 +1776,14 @@ const registerGlobalProxyShutdown = () => {
 * Create and start a new claude-code proxy server instance
 * Each call creates an independent proxy on a unique port
 */
-const createProxyInstance = async ({ env }) => {
+const createProxyInstance = async ({ env, cwd, settingSources, settings, targetUrl: resolvedTargetUrl }) => {
 	try {
 		const port = await findAvailablePort(DEFAULT_CC_PROXY_PORT, CC_PROXY_PORT_ATTEMPTS);
 		if (port === null) {
 			logger$20.warn("Unable to allocate port for cc-proxy.");
 			return null;
 		}
-		const targetUrl = resolveTargetUrlFromEnv(env);
+		const targetUrl = resolvedTargetUrl ?? resolveTargetUrlFromEnv(env, void 0, cwd, settingSources, settings);
 		if (!targetUrl) {
 			logger$20.warn("Unable to resolve target URL for cc-proxy (provider misconfigured).");
 			return null;
@@ -1651,24 +1920,41 @@ function instrumentClaudeAgentQuery(originalQuery) {
 					...process.env,
 					...params.options?.env ?? {}
 				};
-				const targetUrl = resolveTargetUrlFromEnv(mergedEnv);
-				proxyInstance = await createProxyInstance({ env: mergedEnv });
+				const sessionCwd = typeof params.options?.cwd === "string" ? params.options.cwd : void 0;
+				const settingSources = Array.isArray(params.options?.settingSources) ? params.options.settingSources : void 0;
+				const callerSettings = params.options?.settings;
+				const targetUrl = resolveTargetUrlFromEnv(mergedEnv, void 0, sessionCwd, settingSources, callerSettings);
+				proxyInstance = await createProxyInstance({
+					env: mergedEnv,
+					cwd: sessionCwd,
+					settingSources,
+					settings: callerSettings,
+					targetUrl
+				});
 				if (proxyInstance && targetUrl) {
 					logger$19.debug(`Using proxy on port ${proxyInstance.port}`);
 					await Laminar.withSpan(span, async () => {
 						logger$19.debug("Setting trace to proxy instance...");
 						await setTraceToProxyInstance(proxyInstance);
 					});
-					const varsToRemove = getEnvVarsToRemove(mergedEnv);
+					const varsToRemove = getEnvVarsToRemove(mergedEnv, sessionCwd, settingSources);
 					if (!params.options) params.options = {};
 					if (!params.options.env) params.options.env = {};
 					params.options.env = { ...mergedEnv };
 					params.options.env.ANTHROPIC_BASE_URL = proxyInstance.baseUrl;
 					params.options.env.ANTHROPIC_ORIGINAL_BASE_URL = targetUrl;
 					for (const varName of varsToRemove) delete params.options.env[varName];
-					if (params.options.env.CLAUDE_CODE_USE_FOUNDRY === "1") params.options.env.ANTHROPIC_FOUNDRY_BASE_URL = proxyInstance.baseUrl;
-					if (params.options.env.CLAUDE_CODE_USE_BEDROCK === "1") params.options.env.ANTHROPIC_BEDROCK_BASE_URL = proxyInstance.baseUrl;
-					if (params.options.env.CLAUDE_CODE_USE_VERTEX === "1") params.options.env.ANTHROPIC_VERTEX_BASE_URL = proxyInstance.baseUrl;
+					const subprocessEnv = params.options.env;
+					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_FOUNDRY")) subprocessEnv.ANTHROPIC_FOUNDRY_BASE_URL = proxyInstance.baseUrl;
+					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_BEDROCK")) subprocessEnv.ANTHROPIC_BEDROCK_BASE_URL = proxyInstance.baseUrl;
+					if (isProviderEnabledInEnv(subprocessEnv, "CLAUDE_CODE_USE_VERTEX")) subprocessEnv.ANTHROPIC_VERTEX_BASE_URL = proxyInstance.baseUrl;
+					const flagSettings = buildProxyFlagSettings(callerSettings, proxyInstance.baseUrl, sessionCwd, settingSources);
+					if (flagSettings === null) logger$19.warn(`Could not read options.settings ${JSON.stringify(callerSettings)}; Claude Code settings that define a base URL will bypass the Laminar proxy and produce no LLM spans.`);
+					else {
+						params.options.settings = flagSettings;
+						const conflicting = Object.entries(readClaudeSettingsEnv(sessionCwd, settingSources)).filter(([key, value]) => PROXY_BASE_URL_ENV_KEYS.includes(key) && value !== "" && value !== proxyInstance.baseUrl).map(([key]) => key);
+						if (conflicting.length > 0) logger$19.info(`Claude Code settings define ${conflicting.sort().join(", ")}, which outranks the subprocess environment. Injected settings so the Laminar proxy at ${proxyInstance.baseUrl} still intercepts API traffic; your settings files were not modified.`);
+					}
 				} else logger$19.debug("No claude proxy server available. Proceeding without proxy.");
 				const originalGenerator = originalQuery(params);
 				for await (const message of originalGenerator) {
@@ -6604,9 +6890,9 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 	return _opentelemetry_api.context.with(entityContext, () => getTracer().startActiveSpan(name, { attributes: spanAttributes }, entityContext, (span) => {
 		if (shouldSendTraces() && !ignoreInput) try {
 			const spanInput = inputParameters ?? args;
-			if (input !== void 0) span.setAttribute(require_dist.SPAN_INPUT, typeof input === "string" ? input : serialize(input));
-			else if (spanInput.length === 1 && typeof spanInput[0] === "object" && !(spanInput[0] instanceof Map)) span.setAttribute(require_dist.SPAN_INPUT, typeof spanInput[0] === "string" ? spanInput[0] : serialize(spanInput[0]));
-			else span.setAttribute(require_dist.SPAN_INPUT, serialize(spanInput.length > 0 ? spanInput : {}));
+			if (input !== void 0) span.setAttribute(require_dist.SPAN_INPUT, typeof input === "string" ? require_dist.truncateSpanPayload(input, "input") : serialize(input, "input"));
+			else if (spanInput.length === 1 && typeof spanInput[0] === "object" && !(spanInput[0] instanceof Map)) span.setAttribute(require_dist.SPAN_INPUT, typeof spanInput[0] === "string" ? require_dist.truncateSpanPayload(spanInput[0], "input") : serialize(spanInput[0], "input"));
+			else span.setAttribute(require_dist.SPAN_INPUT, serialize(spanInput.length > 0 ? spanInput : {}, "input"));
 		} catch (error) {
 			logger$4.warn("Failed to serialize input: " + require_dist.errorMessage(error));
 		}
@@ -6659,7 +6945,7 @@ function observeBase({ name, contextProperties, spanAttributes, input, ignoreInp
 		}
 		if (streamInfo.type !== null) return handleStreamResult(res, streamInfo, span, ignoreOutput, serialize);
 		try {
-			if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_dist.SPAN_OUTPUT, typeof res === "string" ? res : serialize(res));
+			if (shouldSendTraces() && !ignoreOutput) span.setAttribute(require_dist.SPAN_OUTPUT, typeof res === "string" ? require_dist.truncateSpanPayload(res, "output") : serialize(res));
 		} catch (error) {
 			logger$4.warn("Failed to serialize output: " + require_dist.errorMessage(error));
 		} finally {
@@ -6687,7 +6973,7 @@ const normalizePayload = (payload, seen) => {
 	}
 	return payload;
 };
-const serialize = (payload) => JSON.stringify(normalizePayload(payload, /* @__PURE__ */ new WeakSet()));
+const serialize = (payload, kind = "output") => require_dist.truncateSpanPayload(JSON.stringify(normalizePayload(payload, /* @__PURE__ */ new WeakSet())), kind);
 //#endregion
 //#region src/decorators.ts
 const logger$3 = require_dist.initializeLogger();
@@ -7064,6 +7350,7 @@ var Evaluation = class {
 		this.frontendPort = config?.frontendPort;
 		this.progressReporter = new EvaluationReporter(config?.baseUrl, config?.frontendPort);
 		this.data = data;
+		this.datasetSource = data instanceof EvaluationDataset ? data.sourceDataset() : void 0;
 		this.executor = executor;
 		this.evaluators = evaluators;
 		this.groupName = groupName;
@@ -7110,22 +7397,24 @@ var Evaluation = class {
 	}
 	async run() {
 		if (this.isFinished) throw new Error("Evaluation is already finished");
-		if (this.data instanceof LaminarDataset) {
-			this.data.setClient(this.client);
-			if (!this.data.id) try {
-				const datasets = await this.client.datasets.getDatasetByName(this.data.name);
-				if (datasets.length > 0) this.data.id = datasets[0].id;
-				else logger$2.warn(`Dataset ${this.data.name} not found`);
+		if (this.data instanceof EvaluationDataset) {
+			const source = this.datasetSource;
+			source?.setClient(this.client);
+			if (source && !source.id) try {
+				const datasets = await this.client.datasets.getDatasetByName(source.name);
+				if (datasets.length > 0) source.id = datasets[0].id;
+				else logger$2.warn(`Dataset ${source.name} not found`);
 			} catch (error) {
-				logger$2.warn(`Error getting dataset ${this.data.name}: ` + require_dist.errorMessage(error));
+				logger$2.warn(`Error getting dataset ${source.name}: ` + require_dist.errorMessage(error));
 			}
 		}
 		let resultDatapoints;
 		try {
+			const length = await this.getLength();
 			const evaluation = await this.client.evals.init(this.name, this.groupName, withSessionMetadata(this.metadata));
 			const url = getEvaluationUrl(evaluation.projectId, evaluation.id, this.progressReporter.baseUrl, this.frontendPort);
 			process.stdout.write(`\nCheck results at ${url}\n`);
-			this.progressReporter.start({ length: await this.getLength() });
+			this.progressReporter.start({ length });
 			resultDatapoints = await this.evaluateInBatches(evaluation.id);
 			const averageScores = getAverageScores(resultDatapoints);
 			if (this.uploadPromises.length > 0) await Promise.all(this.uploadPromises);
@@ -7206,8 +7495,8 @@ var Evaluation = class {
 				executorSpanId,
 				index
 			};
-			if (this.data instanceof LaminarDataset && this.data.id && datapoint.id && datapoint.createdAt) partialDatapoint.datasetLink = {
-				datasetId: this.data.id,
+			if (this.datasetSource?.id && datapoint.id && datapoint.createdAt) partialDatapoint.datasetLink = {
+				datasetId: this.datasetSource.id,
 				datapointId: datapoint.id,
 				createdAt: datapoint.createdAt
 			};
@@ -7261,8 +7550,8 @@ var Evaluation = class {
 				executorSpanId,
 				index
 			};
-			if (this.data instanceof LaminarDataset && this.data.id && datapoint.id && datapoint.createdAt) resultDatapoint.datasetLink = {
-				datasetId: this.data.id,
+			if (this.datasetSource?.id && datapoint.id && datapoint.createdAt) resultDatapoint.datasetLink = {
+				datasetId: this.datasetSource.id,
 				datapointId: datapoint.id,
 				createdAt: datapoint.createdAt
 			};