@bitfab/sdk 0.69.0 → 0.71.0

package/dist/{src-Cn--d1sW.js → src-gqUT-PNr.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { C as BitfabError, E as __version__, S as gitRunner, T as readEnv$1, _ as MAX_SPAN_CARRIER_BYTES, b as replayContextReady, 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 byteLength, w as MixedTracingError, x as runWithReplayContext, y as getReplayContext } from "./http-CzKW7TgN.js";
+import { C as BitfabError, E as __version__, S as gitRunner, T as readEnv$1, _ as MAX_SPAN_CARRIER_BYTES, b as replayContextReady, 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 byteLength, w as MixedTracingError, x as runWithReplayContext, y as getReplayContext } from "./http-Dh6NfOpj.js";
 import { A as unmapOpenAiAgentsTrace, B as asyncStorageReady, C as recordAutoTracedClientCall, D as mapOpenAiAgentsTrace, E as endOpenAiAgentsSpan, F as warnOnce, H as isAsyncStorageInitDone, I as writeOnce, L as isCaptureSuppressed, M as installLangChainRunScopes, N as markLangChainRunRecorded, O as openAiAgentsParentSpanId, R as runWithCaptureSuppressed, S as frameworkRecordsClientCall, T as watchClientCall, V as createAsyncLocalStorage, _ as runWithAutoTraceRootContext, b as OPENROUTER, f as invokeThroughAutoTraceEntries, g as runWithAutoTraceNodeConfiguration, h as runWithAutoTraceFramesAt, j as forgetLangChainRun, k as openAiAgentsSpanChain, l as clearAutoTraceNodeConfiguration, m as runWithAutoTraceEntry, o as __bitfabAutoTraceActive, p as runAsAutoTraceRootFunction, u as currentAutoTraceEntries, v as ANTHROPIC, w as recordWatchedClientCall, x as clientCallProvider, y as OPENAI_RESPONSES } from "./autoTrace-kHOBg49M.js";
 import { t as importOptionalPeer } from "./optionalPeer-CczrzrXx.js";
 import { t as loadBamlModule } from "./bamlPeer-Dyeb3e5o.js";
@@ -3006,17 +3006,57 @@ var BitfabPiIntegration = class {
 };
 //#endregion
 //#region src/codeChange.ts
+const CODE_CHANGE_TYPES = [
+	"working-tree",
+	"last-branch",
+	"default-branch",
+	"skip",
+	"manual"
+];
+const CODE_CHANGE_CHOICES = "\"working-tree\" (uncommitted changes vs HEAD), \"last-branch\" (the diff against the branch this one was cut from), \"default-branch\" (the diff against the default branch), \"skip\" (no code change), or \"manual\" (pass the files yourself)";
+function isCodeChangeType(value) {
+	return CODE_CHANGE_TYPES.includes(value);
+}
+function validateCodeChange(request) {
+	const { codeChange, codeChangeDescription, codeChangeFiles } = request;
+	if (codeChange === void 0 || codeChange === null) throw new BitfabError(`replay needs a codeChange naming the code this run tests: ${CODE_CHANGE_CHOICES}.`);
+	if (!isCodeChangeType(codeChange)) throw new BitfabError(`Unknown codeChange ${JSON.stringify(codeChange)}. Pass ${CODE_CHANGE_CHOICES}.`);
+	const hasFiles = codeChangeFiles !== void 0 && codeChangeFiles !== null;
+	if (codeChange === "manual" && !hasFiles) throw new BitfabError("codeChange \"manual\" needs codeChangeFiles: the path and before/after contents of each edited file.");
+	if (codeChange !== "manual" && hasFiles) throw new BitfabError(`codeChangeFiles only applies with codeChange "manual" (got "${codeChange}").`);
+	if (codeChange === "skip" && codeChangeDescription !== void 0 && codeChangeDescription !== null) throw new BitfabError("codeChange \"skip\" attaches no code change, so it cannot take a codeChangeDescription.");
+	return codeChange;
+}
+async function resolveCodeChange(request, label) {
+	const codeChange = validateCodeChange(request);
+	const description = request.codeChangeDescription ?? void 0;
+	if (codeChange === "skip") return {};
+	if (codeChange === "manual") return {
+		description,
+		files: request.codeChangeFiles ?? []
+	};
+	const captured = await captureCodeChange(codeChange, label);
+	if (captured?.files === void 0 || captured.files.length === 0) {
+		try {
+			console.warn(`Bitfab: codeChange "${codeChange}" found no changed files, so this replay has no code change attached.`);
+		} catch {}
+		return { description };
+	}
+	return {
+		description: description ?? captured.description,
+		files: captured.files
+	};
+}
 const MAX_FILES = 60;
 const MAX_FILE_BYTES = 5e5;
 const MAX_TOTAL_BYTES = 2e6;
 const MAX_BRANCH_WALK = 1e3;
 const NUL = String.fromCharCode(0);
-async function resolveAutoCodeChange(label) {
+async function captureCodeChange(type, label) {
 	if (typeof process === "undefined") return null;
-	if (process.env?.BITFAB_DISABLE_CODE_CHANGE_CAPTURE) return null;
 	const fromEnv = await readCodeChangeFile();
 	if (fromEnv) return fromEnv;
-	return captureCodeChangeFromGit(process.cwd?.() ?? ".", label);
+	return captureCodeChangeFromGit(process.cwd?.() ?? ".", type, label);
 }
 async function readCodeChangeFile() {
 	const path = process.env?.BITFAB_CODE_CHANGE_PATH;
@@ -3035,7 +3075,7 @@ async function readCodeChangeFile() {
 		return null;
 	}
 }
-async function captureCodeChangeFromGit(cwd, label) {
+async function captureCodeChangeFromGit(cwd, type, label) {
 	let readFile;
 	try {
 		({readFile} = await import("fs/promises"));
@@ -3051,16 +3091,9 @@ async function captureCodeChangeFromGit(cwd, label) {
 	try {
 		const root = (await git(cwd, ["rev-parse", "--show-toplevel"]))?.trim();
 		if (!root) return null;
-		let resolved = await resolveBase(git, root);
+		const resolved = await resolveBase(git, root, type);
 		if (!resolved) return null;
-		let entries = await listChanges(git, root, resolved.base);
-		if (entries.length === 0 && resolved.base === "HEAD") {
-			const branchPoint = await resolveBranchPoint(git, root);
-			if (branchPoint) {
-				resolved = branchPoint;
-				entries = await listChanges(git, root, branchPoint.base);
-			}
-		}
+		const entries = await listChanges(git, root, resolved.base);
 		if (entries.length === 0) return null;
 		const { base, against } = resolved;
 		const blobBytes = async (ref, path) => {
@@ -3239,23 +3272,22 @@ async function resolveBranchPoint(git, root) {
 		against: `vs ${defaultBranch}`
 	} : null;
 }
-async function resolveBase(git, root) {
-	const forced = process.env?.BITFAB_CODE_CHANGE_BASE;
-	if (forced && await refExists(git, root, forced)) {
-		const base = (await git(root, [
-			"merge-base",
-			"HEAD",
-			forced
-		]))?.trim() || (await git(root, [
-			"rev-parse",
-			"--verify",
-			forced
-		]))?.trim() || null;
-		return base ? {
-			base,
-			against: `vs ${forced}`
-		} : null;
-	}
+async function resolveDefaultBranchPoint(git, root) {
+	const defaultBranch = await resolveDefaultBranch(git, root);
+	if (!defaultBranch) return null;
+	const base = (await git(root, [
+		"merge-base",
+		"HEAD",
+		defaultBranch
+	]))?.trim();
+	return base ? {
+		base,
+		against: `vs ${defaultBranch}`
+	} : null;
+}
+async function resolveBase(git, root, type) {
+	if (type === "last-branch") return resolveBranchPoint(git, root);
+	if (type === "default-branch") return resolveDefaultBranchPoint(git, root);
 	return await refExists(git, root, "HEAD") ? {
 		base: "HEAD",
 		against: "uncommitted (vs HEAD)"
@@ -3777,6 +3809,7 @@ const REPLAY_OPTION_NAMES = [
 	"notes",
 	"metadata",
 	"maxConcurrency",
+	"codeChange",
 	"codeChangeDescription",
 	"codeChangeFiles",
 	"mock",
@@ -4144,6 +4177,7 @@ function warnJudgeAssertionsDeprecated(write = console.warn) {
 	writeOnce("judgeAssertions-deprecated", JUDGE_ASSERTIONS_DEPRECATION_WARNING, write);
 }
 async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, registeredOverrides = []) {
+	const codeChangeType = validateCodeChange(options ?? {});
 	if (options?.judgeAssertions !== void 0) warnJudgeAssertionsDeprecated();
 	if (options?.resume !== void 0) validateResume(options.resume, options);
 	else if (options?.force === true) throw new BitfabError("force only applies when resuming an experiment. Pass it together with resume.");
@@ -4164,19 +4198,11 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
 	const maxConcurrency = options?.maxConcurrency ?? 10;
 	if (!Number.isInteger(maxConcurrency) || maxConcurrency < 1) throw new BitfabError(`maxConcurrency must be a positive integer (got ${maxConcurrency}).`);
 	await replayContextReady;
-	let codeChangeDescription = options?.codeChangeDescription;
-	let codeChangeFiles = options?.codeChangeFiles;
-	if (codeChangeFiles === void 0) {
-		const captured = await resolveAutoCodeChange(options?.name);
-		if (captured) {
-			codeChangeFiles = captured.files;
-			if (codeChangeDescription === void 0) codeChangeDescription = captured.description;
-		}
-	}
+	const { description: codeChangeDescription, files: codeChangeFiles } = await resolveCodeChange(options, options.name);
 	const includeDbBranchLease = dbBranchEnabled(options?.dbBranch) && options?.dryRun !== true;
 	let session;
 	if (options?.resume === void 0) {
-		const started = await httpClient.startReplay(traceFunctionKey, options?.traceIds ? void 0 : options?.limit ?? 5, options?.traceIds, options?.name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, options?.experimentGroupId, datasetIds, options?.graderIds, resolveDbBranchSettings(options?.dbBranch), requestedAttempts, options?.adaptInputs !== void 0, options?.onlyWithAssertions, options?.skipAssertionJudging === true || options?.judgeAssertions === false, options?.experimentalSelectiveReplay, options?.notes, options?.metadata, options?.dryRun === true, options?.experimentGroupName, safeReplayInvocation(() => buildReplayInvocation(Object.entries(cliFlags(options) ?? explicitReplayOptions(options)))));
+		const started = await httpClient.startReplay(traceFunctionKey, options?.traceIds ? void 0 : options?.limit ?? 5, options?.traceIds, options?.name, codeChangeDescription, codeChangeFiles, includeDbBranchLease, options?.experimentGroupId, datasetIds, options?.graderIds, resolveDbBranchSettings(options?.dbBranch), requestedAttempts, options?.adaptInputs !== void 0, options?.onlyWithAssertions, options?.skipAssertionJudging === true || options?.judgeAssertions === false, options?.experimentalSelectiveReplay, options?.notes, options?.metadata, options?.dryRun === true, options?.experimentGroupName, safeReplayInvocation(() => buildReplayInvocation(Object.entries(cliFlags(options) ?? explicitReplayOptions(options)))), codeChangeType);
 		if (started.items.length === 0) try {
 			console.warn(`Bitfab: no traces matched "${traceFunctionKey}", so this replay ran nothing. Capture a trace, or seed one with seedTrace, before replaying.`);
 		} catch {}
@@ -7012,7 +7038,7 @@ var Bitfab = class {
 			await runWithSeedContext({ traceId }, async () => target(...args));
 		} finally {
 			try {
-				const { flushTraces } = await import("./http-CzKW7TgN.js").then((n) => n.a);
+				const { flushTraces } = await import("./http-Dh6NfOpj.js").then((n) => n.a);
 				await flushTraces(3e4);
 			} finally {
 				unrecorded = activeTraceStates.delete(traceId);
@@ -7218,7 +7244,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
 		metadata: seedCase.metadata,
 		sessionId: seedCase.sessionId
 	}));
-	const { flushTraces } = await import("./http-CzKW7TgN.js").then((n) => n.a);
+	const { flushTraces } = await import("./http-Dh6NfOpj.js").then((n) => n.a);
 	await flushTraces(3e4);
 	return {
 		pipeline,
@@ -7235,4 +7261,4 @@ function resolveTraceFunctionKey(registration) {
 //#endregion
 export { VerdictsClient as A, OrganizationMembersClient as C, BitfabLangGraphCallbackHandler as D, BitfabLangGraphIntegration as E, GraderRerunTimeoutError as F, BitfabClaudeAgentHandler as I, DEFAULT_SERVICE_URL as L, SUPPORTED_PROVIDERS as M, DatasetsClient as N, GradersClient as O, GraderRerunError as P, AssertionCategoriesClient as R, BitfabPiIntegration as S, NO_MOCK_OVERRIDE 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, ExperimentsClient as j, LabelsClient 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, BitfabOpenAIAgentHandler as w, serializeReplayResult as x, ReplayError as y, CategoriesClient as z };
 
-//# sourceMappingURL=src-Cn--d1sW.js.map
+//# sourceMappingURL=src-gqUT-PNr.js.map