bitfab 0.66.0 → 0.67.0

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

@@ -1,5 +1,5 @@
 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 { 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-CcYPHER5.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 { r as importOptionalPeer, t as loadBamlModule } from "./bamlPeer-CIVwS68E.js";
 import superjson from "superjson";
@@ -4713,6 +4713,61 @@ function extractContextFromCollector(collector) {
 		return null;
 	}
 }
+const BOUND_FUNCTION_NAME_PREFIX = /^bound /;
+function discoveredSpanType(definition, nodeConfiguration) {
+	const ownType = definition.baml === true ? "llm" : "function";
+	if (nodeConfiguration === void 0) return ownType;
+	if (definition.baml === true && 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 +4991,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 +5002,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 +5026,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 +5100,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 +5114,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) : invokeFn);
 				},
 				invokeNestedRoot(nestedName, nestedFunctionName, inputs, invokeFn, entry, link, spanDetails) {
 					if (excluded.has(nestedName) || excluded.has(nestedFunctionName) || !recordsSpan(entry, nestedName, true)) return invokeFn();
@@ -5328,18 +5386,17 @@ 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;
 	}
 	withSpan(traceFunctionKey, optionsOrFn, maybeFn) {
@@ -5978,7 +6035,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-CcYPHER5.js").then((n) => n.a);
 				await flushTraces(3e4);
 			} finally {
 				unrecorded = activeTraceStates.delete(traceId);
@@ -6166,7 +6223,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-CcYPHER5.js").then((n) => n.a);
 	await flushTraces(3e4);
 	return {
 		pipeline,
@@ -6183,4 +6240,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-CFDoTgXw.js.map