braintrust 0.0.93 → 0.0.95

package/dist/index.js

@@ -3647,12 +3647,14 @@ var require_pluralize = __commonJS({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BaseExperiment: () => BaseExperiment,
   Dataset: () => Dataset,
   Eval: () => Eval,
   Experiment: () => Experiment,
   Logger: () => Logger,
   NOOP_SPAN: () => NOOP_SPAN,
   NoopSpan: () => NoopSpan,
+  ReadonlyExperiment: () => ReadonlyExperiment,
   SpanImpl: () => SpanImpl,
   _internalGetGlobalState: () => _internalGetGlobalState,
   _internalSetInitialState: () => _internalSetInitialState,
@@ -7681,7 +7683,9 @@ async function getBaseBranchAncestor(remote = void 0) {
   if (git === null) {
     throw new Error("Not in a git repo");
   }
-  const { remote: remoteName, branch: baseBranch } = await getBaseBranch(remote);
+  const { remote: remoteName, branch: baseBranch } = await getBaseBranch(
+    remote
+  );
   const isDirty = (await git.diffSummary()).files.length > 0;
   const head = isDirty ? "HEAD" : "HEAD^";
   try {
@@ -7999,6 +8003,21 @@ function getCurrentUnixTimestamp() {
 function isEmpty(a) {
   return a === void 0 || a === null;
 }
+var LazyValue = class {
+  constructor(callable) {
+    this.value = {
+      hasComputed: false
+    };
+    this.callable = callable;
+  }
+  async get() {
+    if (this.value.hasComputed) {
+      return this.value.val;
+    }
+    this.value = { hasComputed: true, val: await this.callable() };
+    return this.value.val;
+  }
+};
 
 // src/logger.ts
 var NoopSpan = class {
@@ -8213,25 +8232,25 @@ function logFeedbackImpl(bgLogger, parentIds, {
   updateEvent = Object.fromEntries(
     Object.entries(updateEvent).filter(([_, v]) => !isEmpty(v))
   );
-  const trueParentIds = (async () => {
-    const { kind, ...ids } = await parentIds;
+  const trueParentIds = new LazyValue(async () => {
+    const { kind, ...ids } = await parentIds.get();
     return ids;
-  })();
+  });
   if (Object.keys(updateEvent).length > 0) {
-    const record = (async () => {
+    const record = new LazyValue(async () => {
       return {
         id,
         ...updateEvent,
-        ...await trueParentIds,
+        ...await trueParentIds.get(),
         [AUDIT_SOURCE_FIELD]: source,
         [AUDIT_METADATA_FIELD]: metadata,
         [IS_MERGE_FIELD]: true
       };
-    })();
+    });
     bgLogger.log([record]);
   }
   if (!isEmpty(comment)) {
-    const record = (async () => {
+    const record = new LazyValue(async () => {
       return {
         id: v4_default(),
         created: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8243,11 +8262,11 @@ function logFeedbackImpl(bgLogger, parentIds, {
         comment: {
           text: comment
         },
-        ...await trueParentIds,
+        ...await trueParentIds.get(),
         [AUDIT_SOURCE_FIELD]: source,
         [AUDIT_METADATA_FIELD]: metadata
       };
-    })();
+    });
     bgLogger.log([record]);
   }
 }
@@ -8257,22 +8276,24 @@ var Logger = class {
     this.kind = "logger";
     this.lazyMetadata = lazyMetadata;
     this.logOptions = logOptions;
-    const logConn = this.getState().then((state) => state.logConn());
+    const logConn = new LazyValue(
+      () => this.getState().then((state) => state.logConn())
+    );
     this.bgLogger = new BackgroundLogger(logConn);
     this.lastStartTime = getCurrentUnixTimestamp();
   }
   get org_id() {
     return (async () => {
-      return (await this.lazyMetadata).org_id;
+      return (await this.lazyMetadata.get()).org_id;
     })();
   }
   get project() {
     return (async () => {
-      return (await this.lazyMetadata).project;
+      return (await this.lazyMetadata.get()).project;
     })();
   }
   async getState() {
-    await this.lazyMetadata;
+    await this.lazyMetadata.get();
     return _state;
   }
   /**
@@ -8347,7 +8368,7 @@ var Logger = class {
   startSpan(args) {
     const { name, ...argsRest } = args ?? {};
     return new SpanImpl({
-      parentIds: this.lazyParentIds(),
+      parentIds: new LazyValue(() => this.lazyParentIds()),
       bgLogger: this.bgLogger,
       name: name ?? "root",
       ...argsRest
@@ -8365,7 +8386,11 @@ var Logger = class {
    * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
    */
   logFeedback(event) {
-    logFeedbackImpl(this.bgLogger, this.lazyParentIds(), event);
+    logFeedbackImpl(
+      this.bgLogger,
+      new LazyValue(() => this.lazyParentIds()),
+      event
+    );
   }
   /*
    * Flush any pending logs to the server.
@@ -8415,9 +8440,20 @@ var BackgroundLogger = class {
   }
   async flush_once(batchSize = DefaultBatchSize) {
     this.active_flush_resolved = false;
-    const itemPromises = this.items;
+    const itemLazyValues = this.items;
     this.items = [];
-    const allItems = mergeRowBatch(await Promise.all(itemPromises)).reverse();
+    const allItems = await (async () => {
+      try {
+        const itemPromises = itemLazyValues.map((x) => x.get());
+        return mergeRowBatch(await Promise.all(itemPromises)).reverse();
+      } catch (e) {
+        console.warn(
+          "Encountered error when constructing records to flush:\n",
+          e
+        );
+        return [];
+      }
+    })();
     let postPromises = [];
     while (true) {
       const items = [];
@@ -8442,9 +8478,7 @@ var BackgroundLogger = class {
           for (let i = 0; i < NumRetries; i++) {
             const startTime = now();
             try {
-              return (await (await this.logConn).post_json("logs", itemsS)).map(
-                (res) => res.id
-              );
+              return (await (await this.logConn.get()).post_json("logs", itemsS)).map((res) => res.id);
             } catch (e) {
               const retryingText = i + 1 === NumRetries ? "" : " Retrying";
               const errMsg = (() => {
@@ -8490,6 +8524,7 @@ function init(project, options = {}) {
     dataset,
     baseExperiment,
     isPublic,
+    open,
     update,
     appUrl,
     apiKey,
@@ -8497,82 +8532,121 @@ function init(project, options = {}) {
     metadata,
     gitMetadataSettings
   } = options || {};
-  const lazyMetadata = (async () => {
-    await login({
-      orgName,
-      apiKey,
-      appUrl
-    });
-    const args = {
-      project_name: project,
-      org_id: _state.orgId
-    };
-    if (experiment) {
-      args["experiment_name"] = experiment;
-    }
-    if (description) {
-      args["description"] = description;
+  if (open) {
+    if (isEmpty(experiment)) {
+      throw new Error("Cannot open an experiment without specifying its name");
     }
     if (update) {
-      args["update"] = update;
+      throw new Error("Cannot open and update an experiment at the same time");
     }
-    let mergedGitMetadataSettings = {
-      ..._state.gitMetadataSettings || {
-        collect: "all"
+    const lazyMetadata2 = new LazyValue(async () => {
+      await login({
+        orgName,
+        apiKey,
+        appUrl
+      });
+      const args = {
+        project_name: project,
+        org_name: _state.orgName,
+        experiment_name: experiment
+      };
+      const response = await _state.apiConn().post_json("api/experiment/get", args);
+      if (response.length === 0) {
+        throw new Error(
+          `Experiment ${experiment} not found in project ${project}.`
+        );
       }
-    };
-    if (gitMetadataSettings) {
-      mergedGitMetadataSettings = mergeGitMetadataSettings(
-        mergedGitMetadataSettings,
-        gitMetadataSettings
-      );
-    }
-    const repoStatus2 = await isomorph_default.getRepoStatus(gitMetadataSettings);
-    if (repoStatus2) {
-      args["repo_info"] = repoStatus2;
-    }
-    if (baseExperiment) {
-      args["base_experiment"] = baseExperiment;
-    } else {
-      args["ancestor_commits"] = await isomorph_default.getPastNAncestors();
-    }
-    if (dataset !== void 0) {
-      args["dataset_id"] = dataset.id;
-      args["dataset_version"] = await dataset.version();
-    }
-    if (isPublic !== void 0) {
-      args["public"] = isPublic;
-    }
-    if (metadata) {
-      args["metadata"] = metadata;
-    }
-    let response = null;
-    while (true) {
-      try {
-        response = await _state.apiConn().post_json("api/experiment/register", args);
-        break;
-      } catch (e) {
-        if (args["base_experiment"] && `${"data" in e && e.data}`.includes("base experiment")) {
-          console.warn(`Base experiment ${args["base_experiment"]} not found.`);
-          delete args["base_experiment"];
-        } else {
-          throw e;
+      const info = response[0];
+      return {
+        id: info.id,
+        name: info.name,
+        fullInfo: info
+      };
+    });
+    return new ReadonlyExperiment(
+      lazyMetadata2
+    );
+  }
+  const lazyMetadata = new LazyValue(
+    async () => {
+      await login({
+        orgName,
+        apiKey,
+        appUrl
+      });
+      const args = {
+        project_name: project,
+        org_id: _state.orgId
+      };
+      if (experiment) {
+        args["experiment_name"] = experiment;
+      }
+      if (description) {
+        args["description"] = description;
+      }
+      if (update) {
+        args["update"] = update;
+      }
+      let mergedGitMetadataSettings = {
+        ..._state.gitMetadataSettings || {
+          collect: "all"
         }
+      };
+      if (gitMetadataSettings) {
+        mergedGitMetadataSettings = mergeGitMetadataSettings(
+          mergedGitMetadataSettings,
+          gitMetadataSettings
+        );
       }
-    }
-    return {
-      project: {
-        id: response.project.id,
-        name: response.project.name,
-        fullInfo: response.project
-      },
-      experiment: {
-        id: response.experiment.id,
-        name: response.experiment.name,
-        fullInfo: response.experiment
+      const repoStatus2 = await isomorph_default.getRepoStatus(gitMetadataSettings);
+      if (repoStatus2) {
+        args["repo_info"] = repoStatus2;
       }
-    };
-  })();
+      if (baseExperiment) {
+        args["base_experiment"] = baseExperiment;
+      } else {
+        args["ancestor_commits"] = await isomorph_default.getPastNAncestors();
+      }
+      if (dataset !== void 0) {
+        args["dataset_id"] = await dataset.id;
+        args["dataset_version"] = await dataset.version();
+      }
+      if (isPublic !== void 0) {
+        args["public"] = isPublic;
+      }
+      if (metadata) {
+        args["metadata"] = metadata;
+      }
+      let response = null;
+      while (true) {
+        try {
+          response = await _state.apiConn().post_json("api/experiment/register", args);
+          break;
+        } catch (e) {
+          if (args["base_experiment"] && `${"data" in e && e.data}`.includes("base experiment")) {
+            console.warn(
+              `Base experiment ${args["base_experiment"]} not found.`
+            );
+            delete args["base_experiment"];
+          } else {
+            throw e;
+          }
+        }
+      }
+      return {
+        project: {
+          id: response.project.id,
+          name: response.project.name,
+          fullInfo: response.project
+        },
+        experiment: {
+          id: response.experiment.id,
+          name: response.experiment.name,
+          fullInfo: response.experiment
+        }
+      };
+    }
+  );
   const ret = new Experiment(lazyMetadata, dataset);
   if (options.setCurrent ?? true) {
     _state.currentExperiment = ret;
@@ -8595,32 +8669,34 @@ function withLogger(callback, options = {}) {
 }
 function initDataset(project, options = {}) {
   const { dataset, description, version, appUrl, apiKey, orgName } = options || {};
-  const lazyMetadata = (async () => {
-    await login({
-      orgName,
-      apiKey,
-      appUrl
-    });
-    const args = {
-      org_id: _state.orgId,
-      project_name: project,
-      dataset_name: dataset,
-      description
-    };
-    const response = await _state.apiConn().post_json("api/dataset/register", args);
-    return {
-      project: {
-        id: response.project.id,
-        name: response.project.name,
-        fullInfo: response.project
-      },
-      dataset: {
-        id: response.dataset.id,
-        name: response.dataset.name,
-        fullInfo: response.dataset
-      }
-    };
-  })();
+  const lazyMetadata = new LazyValue(
+    async () => {
+      await login({
+        orgName,
+        apiKey,
+        appUrl
+      });
+      const args = {
+        org_id: _state.orgId,
+        project_name: project,
+        dataset_name: dataset,
+        description
+      };
+      const response = await _state.apiConn().post_json("api/dataset/register", args);
+      return {
+        project: {
+          id: response.project.id,
+          name: response.project.name,
+          fullInfo: response.project
+        },
+        dataset: {
+          id: response.dataset.id,
+          name: response.dataset.name,
+          fullInfo: response.dataset
+        }
+      };
+    }
+  );
   return new Dataset(lazyMetadata, version);
 }
 function withDataset(project, callback, options = {}) {
@@ -8640,46 +8716,48 @@ function initLogger(options = {}) {
     orgName,
     forceLogin
   } = options || {};
-  const lazyMetadata = (async () => {
-    await login({
-      orgName,
-      apiKey,
-      appUrl,
-      forceLogin
-    });
-    const org_id = _state.orgId;
-    if (projectId === void 0) {
-      const response = await _state.apiConn().post_json("api/project/register", {
-        project_name: projectName || GLOBAL_PROJECT,
-        org_id
+  const lazyMetadata = new LazyValue(
+    async () => {
+      await login({
+        orgName,
+        apiKey,
+        appUrl,
+        forceLogin
       });
-      return {
-        org_id,
-        project: {
-          id: response.project.id,
-          name: response.project.name,
-          fullInfo: response.project
-        }
-      };
-    } else if (projectName === void 0) {
-      const response = await _state.apiConn().get_json("api/project", {
-        id: projectId
-      });
-      return {
-        org_id,
-        project: {
-          id: projectId,
-          name: response.name,
-          fullInfo: response.project
-        }
-      };
-    } else {
-      return {
-        org_id,
-        project: { id: projectId, name: projectName, fullInfo: {} }
-      };
+      const org_id = _state.orgId;
+      if (projectId === void 0) {
+        const response = await _state.apiConn().post_json("api/project/register", {
+          project_name: projectName || GLOBAL_PROJECT,
+          org_id
+        });
+        return {
+          org_id,
+          project: {
+            id: response.project.id,
+            name: response.project.name,
+            fullInfo: response.project
+          }
+        };
+      } else if (projectName === void 0) {
+        const response = await _state.apiConn().get_json("api/project", {
+          id: projectId
+        });
+        return {
+          org_id,
+          project: {
+            id: projectId,
+            name: response.name,
+            fullInfo: response.project
+          }
+        };
+      } else {
+        return {
+          org_id,
+          project: { id: projectId, name: projectName, fullInfo: {} }
+        };
+      }
     }
-  })();
+  );
   const ret = new Logger(lazyMetadata, {
     asyncFlush
   });
@@ -8885,15 +8963,15 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
   }
 }
 function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
-  if ("input" in event && event.input && "inputs" in event && event.inputs || !("input" in event) && !("inputs" in event)) {
+  if ("input" in event && !isEmpty(event.input) && "inputs" in event && !isEmpty(event.inputs) || !("input" in event) && !("inputs" in event)) {
     throw new Error(
       "Exactly one of input or inputs (deprecated) must be specified. Prefer input."
     );
   }
-  if (!event.output) {
+  if (isEmpty(event.output)) {
     throw new Error("output must be specified");
   }
-  if (!event.scores) {
+  if (isEmpty(event.scores)) {
     throw new Error("scores must be specified");
   }
   if (hasDataset && event.datasetRecordId === void 0) {
@@ -8905,33 +8983,88 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
   }
   return event;
 }
-var Experiment = class {
+var ObjectFetcher = class {
+  constructor(objectType, pinnedVersion) {
+    this.objectType = objectType;
+    this.pinnedVersion = pinnedVersion;
+    this._fetchedData = void 0;
+  }
+  get id() {
+    throw new Error("ObjectFetcher subclasses must have an 'id' attribute");
+  }
+  async getState() {
+    throw new Error("ObjectFetcher subclasses must have a 'getState' method");
+  }
+  async *fetch() {
+    const records = await this.fetchedData();
+    for (const record of records) {
+      yield record;
+    }
+  }
+  [Symbol.iterator]() {
+    return this.fetch();
+  }
+  async fetchedData() {
+    if (this._fetchedData === void 0) {
+      const state = await this.getState();
+      const resp = await state.logConn().get(`object/${this.objectType}`, {
+        id: await this.id,
+        fmt: "json2",
+        version: this.pinnedVersion
+      });
+      this._fetchedData = await resp.json();
+    }
+    return this._fetchedData || [];
+  }
+  clearCache() {
+    this._fetchedData = void 0;
+  }
+  async version() {
+    if (this.pinnedVersion !== void 0) {
+      return this.pinnedVersion;
+    } else {
+      const fetchedData = await this.fetchedData();
+      let maxVersion = void 0;
+      for (const record of fetchedData) {
+        const xactId = record[TRANSACTION_ID_FIELD];
+        if (maxVersion === void 0 || (xactId ?? xactId > maxVersion)) {
+          maxVersion = xactId;
+        }
+      }
+      return maxVersion;
+    }
+  }
+};
+var Experiment = class extends ObjectFetcher {
   constructor(lazyMetadata, dataset) {
+    super("experiment", void 0);
     // For type identification.
     this.kind = "experiment";
     this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
-    const logConn = this.getState().then((state) => state.logConn());
+    const logConn = new LazyValue(
+      () => this.getState().then((state) => state.logConn())
+    );
     this.bgLogger = new BackgroundLogger(logConn);
     this.lastStartTime = getCurrentUnixTimestamp();
   }
   get id() {
     return (async () => {
-      return (await this.lazyMetadata).experiment.id;
+      return (await this.lazyMetadata.get()).experiment.id;
     })();
   }
   get name() {
     return (async () => {
-      return (await this.lazyMetadata).experiment.name;
+      return (await this.lazyMetadata.get()).experiment.name;
     })();
   }
   get project() {
     return (async () => {
-      return (await this.lazyMetadata).project;
+      return (await this.lazyMetadata.get()).project;
     })();
   }
   async getState() {
-    await this.lazyMetadata;
+    await this.lazyMetadata.get();
     return _state;
   }
   /**
@@ -8991,12 +9124,32 @@ var Experiment = class {
   startSpan(args) {
     const { name, ...argsRest } = args ?? {};
     return new SpanImpl({
-      parentIds: this.lazyParentIds(),
+      parentIds: new LazyValue(() => this.lazyParentIds()),
       bgLogger: this.bgLogger,
       name: name ?? "root",
       ...argsRest
     });
   }
+  async fetchBaseExperiment() {
+    const state = await this.getState();
+    const conn = state.apiConn();
+    try {
+      const resp = await conn.post("/api/base_experiment/get_id", {
+        id: await this.id
+      });
+      const base = await resp.json();
+      return {
+        id: base["base_exp_id"],
+        name: base["base_exp_name"]
+      };
+    } catch (e) {
+      if (e instanceof FailedHTTPResponse && e.status === 400) {
+        return null;
+      } else {
+        throw e;
+      }
+    }
+  }
   /**
    * Summarize the experiment, including the scores (compared to the closest reference experiment) and metadata.
    *
@@ -9020,14 +9173,10 @@ var Experiment = class {
     let comparisonExperimentName = void 0;
     if (summarizeScores) {
       if (comparisonExperimentId === void 0) {
-        const conn = state.logConn();
-        const resp = await conn.get("/crud/base_experiments", {
-          id: await this.id
-        });
-        const base_experiments = await resp.json();
-        if (base_experiments.length > 0) {
-          comparisonExperimentId = base_experiments[0]["base_exp_id"];
-          comparisonExperimentName = base_experiments[0]["base_exp_name"];
+        const baseExperiment = await this.fetchBaseExperiment();
+        if (baseExperiment !== null) {
+          comparisonExperimentId = baseExperiment.id;
+          comparisonExperimentName = baseExperiment.name;
         }
       }
       if (comparisonExperimentId !== void 0) {
@@ -9065,7 +9214,11 @@ var Experiment = class {
    * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
    */
   logFeedback(event) {
-    logFeedbackImpl(this.bgLogger, this.lazyParentIds(), event);
+    logFeedbackImpl(
+      this.bgLogger,
+      new LazyValue(() => this.lazyParentIds()),
+      event
+    );
   }
   /**
    * Flush any pending rows to the server.
@@ -9083,6 +9236,40 @@ var Experiment = class {
     return this.id;
   }
 };
+var ReadonlyExperiment = class extends ObjectFetcher {
+  constructor(lazyMetadata) {
+    super("experiment", void 0);
+    this.lazyMetadata = lazyMetadata;
+  }
+  get id() {
+    return (async () => {
+      return (await this.lazyMetadata.get()).id;
+    })();
+  }
+  get name() {
+    return (async () => {
+      return (await this.lazyMetadata.get()).name;
+    })();
+  }
+  async getState() {
+    await this.lazyMetadata.get();
+    return _state;
+  }
+  async *asDataset() {
+    const records = this.fetch();
+    for await (const record of records) {
+      if (record.root_span_id !== record.span_id) {
+        continue;
+      }
+      const { output, expected } = record;
+      yield {
+        input: record.input,
+        expected: expected ?? output
+      };
+    }
+  }
+};
+var executionCounter = 0;
 var SpanImpl = class _SpanImpl {
   // root_experiment should only be specified for a root span. parent_span
   // should only be specified for non-root spans.
@@ -9108,7 +9295,11 @@ var SpanImpl = class _SpanImpl {
         start: args.startTime ?? getCurrentUnixTimestamp()
       },
       context: { ...callerLocation },
-      span_attributes: { ...args.spanAttributes, name },
+      span_attributes: {
+        ...args.spanAttributes,
+        name,
+        exec_counter: executionCounter++
+      },
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.parentIds = args.parentIds;
@@ -9146,18 +9337,18 @@ var SpanImpl = class _SpanImpl {
     if (sanitizedAndInternalData.metrics?.end) {
       this.loggedEndTime = sanitizedAndInternalData.metrics?.end;
     }
-    const parentIds = (async () => {
-      const { kind, ...ids } = await this.parentIds;
+    const parentIds = new LazyValue(async () => {
+      const { kind, ...ids } = await this.parentIds.get();
       return ids;
-    })();
-    const record = (async () => {
+    });
+    const record = new LazyValue(async () => {
       return {
         ...sanitizedAndInternalData,
         ...this.rowIds,
-        ...await parentIds,
+        ...await parentIds.get(),
         [IS_MERGE_FIELD]: this.isMerge
       };
-    })();
+    });
     this.bgLogger.log([record]);
   }
   logFeedback(event) {
@@ -9206,31 +9397,32 @@ var SpanImpl = class _SpanImpl {
     return this.end(args);
   }
 };
-var Dataset = class {
+var Dataset = class extends ObjectFetcher {
   constructor(lazyMetadata, pinnedVersion) {
-    this._fetchedData = void 0;
+    super("dataset", pinnedVersion);
     this.lazyMetadata = lazyMetadata;
-    this.pinnedVersion = pinnedVersion;
-    const logConn = this.getState().then((state) => state.logConn());
+    const logConn = new LazyValue(
+      () => this.getState().then((state) => state.logConn())
+    );
     this.bgLogger = new BackgroundLogger(logConn);
   }
   get id() {
     return (async () => {
-      return (await this.lazyMetadata).dataset.id;
+      return (await this.lazyMetadata.get()).dataset.id;
     })();
   }
   get name() {
     return (async () => {
-      return (await this.lazyMetadata).dataset.name;
+      return (await this.lazyMetadata.get()).dataset.name;
     })();
   }
   get project() {
     return (async () => {
-      return (await this.lazyMetadata).project;
+      return (await this.lazyMetadata.get()).project;
     })();
   }
   async getState() {
-    await this.lazyMetadata;
+    await this.lazyMetadata.get();
     return _state;
   }
   /**
@@ -9261,7 +9453,7 @@ var Dataset = class {
       }
     }
     const rowId = id || v4_default();
-    const args = (async () => ({
+    const args = new LazyValue(async () => ({
       id: rowId,
       inputs: input,
       output,
@@ -9269,18 +9461,18 @@ var Dataset = class {
       dataset_id: await this.id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       metadata
-    }))();
+    }));
     this.bgLogger.log([args]);
     return rowId;
   }
   delete(id) {
-    const args = (async () => ({
+    const args = new LazyValue(async () => ({
       id,
       project_id: (await this.project).id,
       dataset_id: await this.id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       _object_delete: true
-    }))();
+    }));
     this.bgLogger.log([args]);
     return id;
   }
@@ -9316,81 +9508,6 @@ var Dataset = class {
       dataSummary
     };
   }
-  /**
-   * Fetch all records in the dataset.
-   *
-   * @example
-   * ```
-   * // Use an async iterator to fetch all records in the dataset.
-   * for await (const record of dataset.fetch()) {
-   *  console.log(record);
-   * }
-   *
-   * // You can also iterate over the dataset directly.
-   * for await (const record of dataset) {
-   *  console.log(record);
-   * }
-   * ```
-   *
-   * @returns An iterator over the dataset's records.
-   */
-  async *fetch() {
-    const records = await this.fetchedData();
-    for (const record of records) {
-      yield {
-        id: record.id,
-        input: record.input && JSON.parse(record.input),
-        output: record.input && JSON.parse(record.output),
-        metadata: record.metadata && JSON.parse(record.metadata)
-      };
-    }
-    this.clearCache();
-  }
-  /**
-   * Fetch all records in the dataset.
-   *
-   * @example
-   * ```
-   * // Use an async iterator to fetch all records in the dataset.
-   * for await (const record of dataset) {
-   *  console.log(record);
-   * }
-   * ```
-   */
-  [Symbol.asyncIterator]() {
-    return this.fetch();
-  }
-  async fetchedData() {
-    if (this._fetchedData === void 0) {
-      const state = await this.getState();
-      const resp = await state.logConn().get("object/dataset", {
-        id: await this.id,
-        fmt: "json",
-        version: this.pinnedVersion
-      });
-      const text = await resp.text();
-      this._fetchedData = text.split("\n").filter((x) => x.trim() !== "").map((x) => JSON.parse(x));
-    }
-    return this._fetchedData || [];
-  }
-  clearCache() {
-    this._fetchedData = void 0;
-  }
-  async version() {
-    if (this.pinnedVersion !== void 0) {
-      return this.pinnedVersion;
-    } else {
-      const fetchedData = await this.fetchedData();
-      let maxVersion = void 0;
-      for (const record of fetchedData) {
-        const xactId = record[TRANSACTION_ID_FIELD];
-        if (maxVersion === void 0 || (xactId ?? xactId > maxVersion)) {
-          maxVersion = xactId;
-        }
-      }
-      return maxVersion;
-    }
-  }
   /**
    * Flush any pending rows to the server.
    */
@@ -9462,6 +9579,9 @@ var BarProgressReporter = class {
 
 // src/framework.ts
 var import_pluralize = __toESM(require_pluralize());
+function BaseExperiment(options = {}) {
+  return { _type: "BaseExperiment", ...options };
+}
 function makeEvalName(projectName, experimentName) {
   let out = projectName;
   if (experimentName) {
@@ -9469,6 +9589,12 @@ function makeEvalName(projectName, experimentName) {
   }
   return out;
 }
+function initExperiment(projectName, options = {}) {
+  return init(projectName, {
+    ...options,
+    setCurrent: false
+  });
+}
 globalThis._evals = {};
 async function Eval(name, evaluator) {
   const evalName = makeEvalName(name, evaluator.experimentName);
@@ -9477,15 +9603,22 @@ async function Eval(name, evaluator) {
   }
   if (globalThis._lazy_load) {
     _evals[evalName] = { evalName, projectName: name, ...evaluator };
-    return;
+    return {
+      projectName: "_lazy_load",
+      experimentName: "_lazy_load",
+      projectUrl: "",
+      experimentUrl: "",
+      comparisonExperimentName: "",
+      scores: {},
+      metrics: {}
+    };
   }
   const progressReporter = new BarProgressReporter();
   try {
-    const experiment = init(name, {
+    const experiment = initExperiment(name, {
       experiment: evaluator.experimentName,
       metadata: evaluator.metadata,
-      isPublic: evaluator.isPublic,
-      setCurrent: false
+      isPublic: evaluator.isPublic
     });
     try {
       const ret = await runEvaluator(
@@ -9526,10 +9659,37 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
   if (typeof evaluator.data === "string") {
     throw new Error("Unimplemented: string data paths");
   }
-  const dataResult = evaluator.data();
-  let data = null;
+  let dataResult = typeof evaluator.data === "function" ? evaluator.data() : evaluator.data;
+  if ("_type" in dataResult) {
+    if (dataResult._type !== "BaseExperiment") {
+      throw new Error("Invalid _type");
+    }
+    if (!experiment) {
+      throw new Error(
+        "Cannot use BaseExperiment() without connecting to Braintrust (you most likely set --no-send-logs)"
+      );
+    }
+    let name = dataResult.name;
+    if (isEmpty(name)) {
+      const baseExperiment = await experiment.fetchBaseExperiment();
+      if (!baseExperiment) {
+        throw new Error("BaseExperiment() failed to fetch base experiment");
+      }
+      name = baseExperiment.name;
+    }
+    dataResult = initExperiment(evaluator.projectName, {
+      experiment: name,
+      open: true
+    }).asDataset();
+  }
+  let data = [];
   if (dataResult instanceof Promise) {
     data = await dataResult;
+  } else if (Symbol.asyncIterator in dataResult) {
+    data = [];
+    for await (const d of dataResult) {
+      data.push(d);
+    }
   } else {
     data = dataResult;
   }
@@ -9942,12 +10102,14 @@ var WrapperStream = class {
 configureNode();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseExperiment,
   Dataset,
   Eval,
   Experiment,
   Logger,
   NOOP_SPAN,
   NoopSpan,
+  ReadonlyExperiment,
   SpanImpl,
   _internalGetGlobalState,
   _internalSetInitialState,