bitfab 0.66.0 → 0.68.0

package/dist/{src-CL5eQlNk.js → src-DyEKM7yn.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { C as readEnv$1, S as MixedTracingError, _ as getReplayContext, b as gitRunner, c as recordCallerTraceMetadata, f as ROOT_TRACE_FUNCTION_KEY_FIELD, g as MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES, h as makeSpanOrigin, i as flushTraces, l as retireTraceMetadata, m as isFrameworkInstrumentation, n as SPAN_TYPES, o as unrefTimer, p as SimulationPlan, r as experimentIdWireFields, s as callerTraceMetadata, t as HttpClient, v as replayContextReady, w as __version__, x as BitfabError, y as runWithReplayContext } from "./http-D91qP2J-.js";
-import { a as clearAutoTraceNodeConfiguration, b as isAsyncStorageInitDone, c as runAsAutoTraceRootFunction, d as runWithAutoTraceRootContext, g as runWithCaptureSuppressed, h as isCaptureSuppressed, l as runWithAutoTraceEntry, m as writeOnce, n as __bitfabAutoTraceActive, o as currentAutoTraceEntries, p as warnOnce, s as invokeThroughAutoTraceEntries, u as runWithAutoTraceNodeConfiguration, v as asyncStorageReady, y as createAsyncLocalStorage } from "./autoTrace-O40k8f5M.js";
+import { C as readEnv$1, S as MixedTracingError, _ as getReplayContext, b as gitRunner, c as recordCallerTraceMetadata, f as ROOT_TRACE_FUNCTION_KEY_FIELD, g as MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES, h as makeSpanOrigin, i as flushTraces, l as retireTraceMetadata, m as isFrameworkInstrumentation, n as SPAN_TYPES, o as unrefTimer, p as SimulationPlan, r as experimentIdWireFields, s as callerTraceMetadata, t as HttpClient, v as replayContextReady, w as __version__, x as BitfabError, y as runWithReplayContext } from "./http-_cgR_DM2.js";
+import { S as isAsyncStorageInitDone, _ as isCaptureSuppressed, b as asyncStorageReady, d as runWithAutoTraceEntry, f as runWithAutoTraceNodeConfiguration, g as writeOnce, h as warnOnce, l as invokeThroughAutoTraceEntries, o as clearAutoTraceNodeConfiguration, p as runWithAutoTraceRootContext, r as __bitfabAutoTraceActive, s as currentAutoTraceEntries, u as runAsAutoTraceRootFunction, v as runWithCaptureSuppressed, x as createAsyncLocalStorage } from "./autoTrace-CVt9EDyo.js";
 import { r as importOptionalPeer, t as loadBamlModule } from "./bamlPeer-CIVwS68E.js";
 import superjson from "superjson";
 //#region src/categories.ts
@@ -1407,6 +1407,89 @@ var GradersClient = class {
 	}
 };
 //#endregion
+//#region src/jev.ts
+const JEV_PROVIDER = "typesafe";
+const JEV_WATCH_STORAGE_SYMBOL = Symbol.for("bitfab.jevWatchStorage");
+const repliesRecordedByAutoTrace = /* @__PURE__ */ new WeakSet();
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null;
+}
+function isJevReply(value) {
+	return isRecord$3(value) && typeof value.model === "string" && isRecord$3(value.usage);
+}
+function tokenCount(usage, key) {
+	const count = usage[key];
+	return typeof count === "number" ? count : null;
+}
+function jevContext(reply, durationMs) {
+	if (!isJevReply(reply)) return null;
+	const context = {
+		provider: JEV_PROVIDER,
+		model: reply.model
+	};
+	const inputTokens = tokenCount(reply.usage, "input_tokens");
+	const outputTokens = tokenCount(reply.usage, "output_tokens");
+	if (inputTokens !== null) context.inputTokens = inputTokens;
+	if (outputTokens !== null) context.outputTokens = outputTokens;
+	context.durationMs = durationMs;
+	return context;
+}
+function recordJevReply(span, reply, durationMs) {
+	try {
+		const context = jevContext(reply, durationMs);
+		if (context) span.addContext(context);
+	} catch {}
+}
+let jevWatchStorage = null;
+function watchStorage() {
+	if (jevWatchStorage) return jevWatchStorage;
+	const shared = globalThis;
+	const existing = shared[JEV_WATCH_STORAGE_SYMBOL];
+	jevWatchStorage = existing ?? createAsyncLocalStorage();
+	if (jevWatchStorage && !existing) shared[JEV_WATCH_STORAGE_SYMBOL] = jevWatchStorage;
+	return jevWatchStorage;
+}
+function watchJevUsage(fn) {
+	const storage = watchStorage();
+	const watch = {
+		recorded: false,
+		parent: storage?.getStore() ?? null
+	};
+	return {
+		watch,
+		result: storage ? storage.run(watch, fn) : fn()
+	};
+}
+function markEnclosingWatches(watch) {
+	for (let current = watch.parent; current; current = current.parent) current.recorded = true;
+}
+function recordWatchedJevReply(span, watch, reply, durationMs) {
+	if (watch.recorded || isRecordedByAutoTrace(reply)) {
+		markEnclosingWatches(watch);
+		return;
+	}
+	if (!isJevReply(reply)) return;
+	recordJevReply(span, reply, durationMs);
+	repliesRecordedByAutoTrace.add(reply);
+	markEnclosingWatches(watch);
+}
+function isRecordedByAutoTrace(reply) {
+	return isRecord$3(reply) && repliesRecordedByAutoTrace.has(reply);
+}
+function recordAutoTracedJev(invokeFn, span) {
+	const startedAt = Date.now();
+	const { watch, result } = watchJevUsage(invokeFn);
+	const settle = (reply) => {
+		recordWatchedJevReply(span, watch, reply, Date.now() - startedAt);
+	};
+	if (result instanceof Promise) return result.then((reply) => {
+		settle(reply);
+		return reply;
+	});
+	settle(result);
+	return result;
+}
+//#endregion
 //#region src/langgraph.ts
 const LANGSMITH_HIDDEN_TAG = "langsmith:hidden";
 const CHAIN_RUN_TYPES = /* @__PURE__ */ new Set([
@@ -4713,6 +4796,62 @@ function extractContextFromCollector(collector) {
 		return null;
 	}
 }
+const BOUND_FUNCTION_NAME_PREFIX = /^bound /;
+function discoveredSpanType(definition, nodeConfiguration) {
+	const recordsModelCall = definition.baml === true || definition.jev === true;
+	const ownType = recordsModelCall ? "llm" : "function";
+	if (nodeConfiguration === void 0) return ownType;
+	if (recordsModelCall && nodeConfiguration.defaultType === true) return ownType;
+	return nodeConfiguration.type ?? ownType;
+}
+const collectorsRecordedByAutoTrace = /* @__PURE__ */ new WeakSet();
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectorsIn(options) {
+	const collector = options.collector;
+	if (collector === void 0 || collector === null) return [];
+	return Array.isArray(collector) ? collector : [collector];
+}
+function recordBamlCollector(collector) {
+	try {
+		const prompt = extractPromptFromCollector(collector);
+		if (prompt) getCurrentSpan().setPrompt(prompt);
+		const metadata = extractContextFromCollector(collector);
+		if (metadata) getCurrentSpan().addContext(metadata);
+	} catch {}
+}
+function invokeBamlWithCollector(invokeFn, CollectorClass) {
+	const collector = new CollectorClass("bitfab-baml-tracing");
+	let existingCollectors = [];
+	const result = invokeFn((callerOptions, clientOptions) => {
+		const caller = isPlainObject(callerOptions) ? callerOptions : {};
+		const client = isPlainObject(clientOptions) ? clientOptions : {};
+		existingCollectors = collectorsIn(caller.collector === void 0 ? client : caller);
+		return {
+			...caller,
+			collector: [...existingCollectors, collector]
+		};
+	});
+	const settle = () => {
+		for (const existing of existingCollectors) if (typeof existing === "object" && existing !== null) collectorsRecordedByAutoTrace.add(existing);
+		recordBamlCollector(collector);
+	};
+	if (result instanceof Promise) return result.then((value) => {
+		settle();
+		return value;
+	});
+	settle();
+	return result;
+}
+function invokeAutoTracedBaml(invokeFn, isAsync) {
+	if (cachedCollectorClass) return invokeBamlWithCollector(invokeFn, cachedCollectorClass);
+	if (cachedCollectorClass === null || !isAsync) {
+		loadCollectorClass();
+		return invokeFn();
+	}
+	return loadCollectorClass().then((CollectorClass) => CollectorClass ? invokeBamlWithCollector(invokeFn, CollectorClass) : invokeFn());
+}
 function isSpanType(value) {
 	return SPAN_TYPES.some((spanType) => spanType === value);
 }
@@ -4936,7 +5075,7 @@ var Bitfab = class {
 		const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
 		if (!fn) throw new BitfabError("bitfab.withNode requires a function");
 		const configuration = this.resolveNodeConfiguration(options);
-		const functionName = internalFunctionName ?? fn.name;
+		const functionName = (internalFunctionName ?? fn.name).replace(BOUND_FUNCTION_NAME_PREFIX, "");
 		if (functionName === "") throw new BitfabError("bitfab.withNode requires a named function so the subtree transform can bind its configuration to the correct call.");
 		return this.createAutoTraceNode(configuration, fn, functionName);
 	}
@@ -4947,6 +5086,7 @@ var Bitfab = class {
 		return {
 			capture,
 			type: options.type ?? "custom",
+			...options.type === void 0 && { defaultType: true },
 			...options.name !== void 0 && { name: options.name },
 			...experimentId !== void 0 && { experimentId },
 			...options.mockOnReplay !== void 0 && { mockOnReplay: options.mockOnReplay },
@@ -4970,6 +5110,7 @@ var Bitfab = class {
 	createAutoTraceRoot(traceFunctionKey, name, options, fn, rootFunctionName = "") {
 		const self = this;
 		self.simulationPlan.refresh();
+		loadCollectorClass();
 		const runRootFunction = (receiver, args) => runAsAutoTraceRootFunction(rootFunctionName, () => fn.apply(receiver, args));
 		const maxDepth = autoTraceLimit(options.maxDepth, DEFAULT_AUTO_TRACE_MAX_DEPTH);
 		const maxCapturedSubtreeSpans = autoTraceLimit(options.maxCapturedSubtreeSpans, DEFAULT_AUTO_TRACE_MAX_CAPTURED_SUBTREE_SPANS);
@@ -5043,7 +5184,7 @@ var Bitfab = class {
 					const nodeExperimentId = nodeConfiguration === void 0 ? void 0 : resolveSpanExperimentId(nodeConfiguration);
 					const childOptions = {
 						name: spanName,
-						type: nodeConfiguration?.type ?? "function",
+						type: discoveredSpanType(definition, nodeConfiguration),
 						captureWhen: "nested",
 						surface: "opt-out",
 						instrumentation: "trace",
@@ -5057,7 +5198,8 @@ var Bitfab = class {
 						...nodeConfiguration?.replayReusable !== void 0 && { replayReusable: nodeConfiguration.replayReusable },
 						...nodeConfiguration?.finalize !== void 0 && { finalize: nodeConfiguration.finalize }
 					};
-					return openChild(entry, childOptions, inputs, definition.async === true, invokeFn);
+					const isAsync = definition.async === true;
+					return openChild(entry, childOptions, inputs, isAsync, definition.baml === true ? () => invokeAutoTracedBaml(invokeFn, isAsync) : definition.jev === true ? () => recordAutoTracedJev(invokeFn, getCurrentSpan()) : invokeFn);
 				},
 				invokeNestedRoot(nestedName, nestedFunctionName, inputs, invokeFn, entry, link, spanDetails) {
 					if (excluded.has(nestedName) || excluded.has(nestedFunctionName) || !recordsSpan(entry, nestedName, true)) return invokeFn();
@@ -5328,18 +5470,37 @@ var Bitfab = class {
 			}
 			const result = await trackedMethod.bind(trackedClient)(...args);
 			wrappedFn.collector = collector;
-			try {
-				const prompt = extractPromptFromCollector(collector);
-				if (prompt) getCurrentSpan().setPrompt(prompt);
-				const metadata = extractContextFromCollector(collector);
-				if (metadata) getCurrentSpan().addContext(metadata);
-			} catch {}
+			if (!collectorsRecordedByAutoTrace.has(collector)) recordBamlCollector(collector);
 			try {
 				options?.onCollector?.(collector);
 			} catch {}
 			return result;
 		};
 		wrappedFn.collector = null;
+		Object.defineProperty(wrappedFn, "name", {
+			configurable: true,
+			value: methodName
+		});
+		return wrappedFn;
+	}
+	wrapJev(method, options) {
+		const methodName = method.name.replace(BOUND_FUNCTION_NAME_PREFIX, "");
+		if (!methodName) throw new BitfabError("wrapJev requires a named function (e.g., jev.systemOne.bind(jev)).");
+		const wrappedFn = async (...args) => {
+			const span = getCurrentSpan();
+			const startedAt = Date.now();
+			const { watch, result } = watchJevUsage(() => method(...args));
+			const reply = await result;
+			recordWatchedJevReply(span, watch, reply, Date.now() - startedAt);
+			try {
+				options?.onReply?.(reply);
+			} catch {}
+			return reply;
+		};
+		Object.defineProperty(wrappedFn, "name", {
+			configurable: true,
+			value: methodName
+		});
 		return wrappedFn;
 	}
 	withSpan(traceFunctionKey, optionsOrFn, maybeFn) {
@@ -5978,7 +6139,7 @@ var Bitfab = class {
 			await runWithSeedContext({ traceId }, async () => target(...args));
 		} finally {
 			try {
-				const { flushTraces } = await import("./http-D91qP2J-.js").then((n) => n.a);
+				const { flushTraces } = await import("./http-_cgR_DM2.js").then((n) => n.a);
 				await flushTraces(3e4);
 			} finally {
 				unrecorded = activeTraceStates.delete(traceId);
@@ -6064,6 +6225,9 @@ var BitfabFunction = class {
 	wrapBAML(methodOrClient, maybeMethodOrOptions, maybeOptions) {
 		return this.client.wrapBAML(methodOrClient, maybeMethodOrOptions, maybeOptions);
 	}
+	wrapJev(method, options) {
+		return this.client.wrapJev(method, options);
+	}
 };
 //#endregion
 //#region src/finalizers.ts
@@ -6166,7 +6330,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
 		metadata: seedCase.metadata,
 		sessionId: seedCase.sessionId
 	}));
-	const { flushTraces } = await import("./http-D91qP2J-.js").then((n) => n.a);
+	const { flushTraces } = await import("./http-_cgR_DM2.js").then((n) => n.a);
 	await flushTraces(3e4);
 	return {
 		pipeline,
@@ -6183,4 +6347,4 @@ function resolveTraceFunctionKey(registration) {
 //#endregion
 export { ExperimentsClient as A, BitfabOpenAIAgentHandler as C, GradersClient as D, BitfabLangGraphCallbackHandler as E, BitfabClaudeAgentHandler as F, DEFAULT_SERVICE_URL as I, AssertionCategoriesClient as L, DatasetsClient as M, GraderRerunError as N, LabelsClient as O, GraderRerunTimeoutError as P, CategoriesClient as R, OrganizationMembersClient as S, BitfabLangGraphIntegration as T, BITFAB_PROGRESS_PREFIX as _, Bitfab as a, reportReplayProgress as b, getCurrentSpan as c, BitfabOpenAITracingProcessor as d, AssertionGenerationError as f, BitfabRivetIntegration as g, SpansClient as h, finalizers as i, SUPPORTED_PROVIDERS as j, VerdictsClient as k, getCurrentTrace as l, TracesClient as m, reseedFromRegistry as n, BitfabFunction as o, AssertionGenerationTimeoutError as p, seedFromRegistry as r, getCurrentReplayBranch as s, defineReplayRegistry as t, BitfabVercelAiHandler as u, DbBranchReplayError as v, NO_MOCK_OVERRIDE as w, serializeReplayResult as x, ReplayError as y };
 
-//# sourceMappingURL=src-CL5eQlNk.js.map
+//# sourceMappingURL=src-DyEKM7yn.js.map