bitfab 0.66.0 → 0.68.0

package/dist/{src-rJcHXJEz.cjs → src-Dze8o7iU.cjs}

@@ -1,6 +1,6 @@
 const require_bamlPeer = require("./bamlPeer-BUoZgNxZ.cjs");
-const require_http = require("./http-DIz8mEMq.cjs");
-const require_autoTrace = require("./autoTrace-CQw0qMBt.cjs");
+const require_http = require("./http-psFF1ptn.cjs");
+const require_autoTrace = require("./autoTrace-BikML0lX.cjs");
 let superjson = require("superjson");
 superjson = require_bamlPeer.__toESM(superjson, 1);
 //#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 ?? require_autoTrace.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 require_http.SPAN_TYPES.some((spanType) => spanType === value);
 }
@@ -4936,7 +5075,7 @@ var Bitfab = class {
 		const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
 		if (!fn) throw new require_http.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 require_http.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) => require_autoTrace.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 require_http.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 Promise.resolve().then(() => require("./http-DIz8mEMq.cjs")).then((n) => n.http_exports);
+				const { flushTraces } = await Promise.resolve().then(() => require("./http-psFF1ptn.cjs")).then((n) => n.http_exports);
 				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 Promise.resolve().then(() => require("./http-DIz8mEMq.cjs")).then((n) => n.http_exports);
+	const { flushTraces } = await Promise.resolve().then(() => require("./http-psFF1ptn.cjs")).then((n) => n.http_exports);
 	await flushTraces(3e4);
 	return {
 		pipeline,
@@ -6410,4 +6574,4 @@ Object.defineProperty(exports, "serializeReplayResult", {
 	}
 });
 
-//# sourceMappingURL=src-rJcHXJEz.cjs.map
+//# sourceMappingURL=src-Dze8o7iU.cjs.map