braintrust 0.0.85 → 0.0.87

package/dist/index.js

@@ -3651,6 +3651,7 @@ __export(src_exports, {
   Eval: () => Eval,
   Experiment: () => Experiment,
   Logger: () => Logger,
+  NOOP_SPAN: () => NOOP_SPAN,
   NoopSpan: () => NoopSpan,
   SpanImpl: () => SpanImpl,
   _internalGetGlobalState: () => _internalGetGlobalState,
@@ -3658,16 +3659,15 @@ __export(src_exports, {
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
   currentSpan: () => currentSpan,
+  getSpanParentObject: () => getSpanParentObject,
   init: () => init,
   initDataset: () => initDataset,
   initLogger: () => initLogger,
   log: () => log,
   login: () => login,
-  noopSpan: () => noopSpan,
   startSpan: () => startSpan,
   summarize: () => summarize,
   traced: () => traced,
-  withCurrent: () => withCurrent,
   withDataset: () => withDataset,
   withExperiment: () => withExperiment,
   withLogger: () => withLogger,
@@ -7628,10 +7628,14 @@ var simpleGit = gitInstanceFactory;
 // src/gitutil.ts
 var COMMON_BASE_BRANCHES = ["main", "master", "develop"];
 async function currentRepo() {
-  const git = simpleGit();
-  if (await git.checkIsRepo()) {
-    return git;
-  } else {
+  try {
+    const git = simpleGit();
+    if (await git.checkIsRepo()) {
+      return git;
+    } else {
+      return null;
+    }
+  } catch (e) {
     return null;
   }
 }
@@ -7860,7 +7864,7 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// ../../node_modules/.pnpm/@braintrust+core@0.0.7/node_modules/@braintrust/core/dist/index.mjs
+// ../core/js/dist/index.mjs
 var TRANSACTION_ID_FIELD = "_xact_id";
 var IS_MERGE_FIELD = "_is_merge";
 function mergeDicts(mergeInto, mergeFrom) {
@@ -7949,12 +7953,12 @@ var NoopSpan = class {
   }
   log(_) {
   }
-  startSpan(_0, _1) {
-    return this;
-  }
-  traced(_0, callback, _1) {
+  traced(callback, _1) {
     return callback(this);
   }
+  startSpan(_1) {
+    return this;
+  }
   end(args) {
     return args?.endTime ?? getCurrentUnixTimestamp();
   }
@@ -7962,16 +7966,25 @@ var NoopSpan = class {
     return this.end(args);
   }
 };
-var noopSpan = new NoopSpan();
+var NOOP_SPAN = new NoopSpan();
 var BraintrustState = class {
   constructor() {
+    this.apiUrl = null;
+    this.loginToken = null;
+    this.orgId = null;
+    this.orgName = null;
+    this.logUrl = null;
+    this.loggedIn = false;
+    this._apiConn = null;
+    this._logConn = null;
     this.id = v4_default();
-    this.currentExperiment = isomorph_default.newAsyncLocalStorage();
-    this.currentLogger = isomorph_default.newAsyncLocalStorage();
+    this.currentExperiment = void 0;
+    this.currentLogger = void 0;
     this.currentSpan = isomorph_default.newAsyncLocalStorage();
-    if (this.currentSpan.enterWith) {
-      this.currentSpan.enterWith(noopSpan);
-    }
+    this.resetLoginInfo();
+    globalThis.__inherited_braintrust_state = this;
+  }
+  resetLoginInfo() {
     this.apiUrl = null;
     this.loginToken = null;
     this.orgId = null;
@@ -7980,7 +7993,6 @@ var BraintrustState = class {
     this.loggedIn = false;
     this._apiConn = null;
     this._logConn = null;
-    globalThis.__inherited_braintrust_state = this;
   }
   apiConn() {
     if (!this._apiConn) {
@@ -8009,36 +8021,6 @@ function _internalSetInitialState() {
   _state = globalThis.__inherited_braintrust_state || new BraintrustState();
 }
 var _internalGetGlobalState = () => _state;
-var UnterminatedObjectsHandler = class {
-  constructor() {
-    this.unterminatedObjects = /* @__PURE__ */ new Map();
-    isomorph_default.processOn("exit", () => {
-      this.warnUnterminated();
-    });
-  }
-  addUnterminated(obj, createdLocation) {
-    this.unterminatedObjects.set(obj, createdLocation);
-  }
-  removeUnterminated(obj) {
-    this.unterminatedObjects.delete(obj);
-  }
-  warnUnterminated() {
-    if (this.unterminatedObjects.size === 0) {
-      return;
-    }
-    let warningMessage = "WARNING: Did not close the following braintrust objects. We recommend running `.close` on the listed objects, or by running them inside a callback so they are closed automatically:";
-    this.unterminatedObjects.forEach((createdLocation, obj) => {
-      let msg = `
-	Object of type ${obj?.constructor?.name}`;
-      if (createdLocation) {
-        msg += ` created at ${JSON.stringify(createdLocation)}`;
-      }
-      warningMessage += msg;
-    });
-    console.warn(warningMessage);
-  }
-};
-var unterminatedObjects = new UnterminatedObjectsHandler();
 var FailedHTTPResponse = class extends Error {
   constructor(status, text, data = null) {
     super(`${status}: ${text}`);
@@ -8145,45 +8127,29 @@ var HTTPConnection = class _HTTPConnection {
     return await resp.json();
   }
 };
-var Project = class {
-  constructor({ name, id }) {
-    this.name = name;
-    this.id = id;
-  }
-  async lazyInit() {
-    if (this.id === void 0) {
-      const response = await _state.apiConn().post_json("api/project/register", {
-        project_name: this.name || GLOBAL_PROJECT,
-        org_id: _state.orgId
-      });
-      this.id = response.project.id;
-      this.name = response.project.name;
-    } else if (this.name === void 0) {
-      const response = await _state.apiConn().get_json("api/project", {
-        id: this.id
-      });
-      this.name = response.name;
-    }
-    return { id: this.id, name: this.name };
-  }
-};
 var Logger = class {
-  constructor(lazyLogin, lazyProject, logOptions = {}) {
-    this.loggedIn = false;
+  constructor(lazyMetadata, logOptions = {}) {
     // For type identification.
     this.kind = "logger";
-    this._lazyLogin = lazyLogin;
-    this.lazyProject = lazyProject;
+    this.lazyMetadata = lazyMetadata;
     this.logOptions = logOptions;
-    this.bgLogger = new BackgroundLogger();
+    const logConn = this.getState().then((state) => state.logConn());
+    this.bgLogger = new BackgroundLogger(logConn);
     this.lastStartTime = getCurrentUnixTimestamp();
   }
-  async lazyLogin() {
-    if (!this.loggedIn) {
-      await this._lazyLogin();
-      this.lastStartTime = getCurrentUnixTimestamp();
-      this.loggedIn = true;
-    }
+  get org_id() {
+    return (async () => {
+      return (await this.lazyMetadata).org_id;
+    })();
+  }
+  get project() {
+    return (async () => {
+      return (await this.lazyMetadata).project;
+    })();
+  }
+  async getState() {
+    await this.lazyMetadata;
+    return _state;
   }
   /**
    * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
@@ -8198,54 +8164,87 @@ var Logger = class {
    * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
    * :returns: The `id` of the logged event.
    */
-  async log(event) {
-    await this.lazyLogin();
-    const span = await this.startSpan({ startTime: this.lastStartTime, event });
+  log(event) {
+    const span = this.startSpan({ startTime: this.lastStartTime, event });
     this.lastStartTime = span.end();
-    if (!this.logOptions.asyncFlush) {
-      await this.flush();
+    const ret = span.id;
+    if (this.logOptions.asyncFlush === true) {
+      return ret;
+    } else {
+      return (async () => {
+        await this.flush();
+        return ret;
+      })();
+    }
+  }
+  /**
+   * Create a new toplevel span underneath the logger. The name defaults to "root".
+   *
+   * See `Span.traced` for full details.
+   */
+  traced(callback, args) {
+    const { setCurrent, ...argsRest } = args ?? {};
+    const span = this.startSpan(argsRest);
+    const ret = runFinally(
+      () => {
+        if (setCurrent ?? true) {
+          return withCurrent(span, callback);
+        } else {
+          return callback(span);
+        }
+      },
+      () => span.end()
+    );
+    if (this.logOptions.asyncFlush) {
+      return ret;
+    } else {
+      return (async () => {
+        const awaitedRet = await ret;
+        await this.flush();
+        return awaitedRet;
+      })();
     }
-    return span.id;
   }
   /**
-   * Create a new toplevel span. The name parameter is optional and defaults to "root".
+   * Lower-level alternative to `traced`, which does not automatically end the span or mark it as current.
    *
-   * See `Span.startSpan` for full details.
+   * See `traced` for full details.
    */
-  async startSpan(args) {
-    await this.lazyLogin();
-    const project = await this.lazyProject.lazyInit();
+  startSpan(args) {
     const { name, ...argsRest } = args ?? {};
+    const parentIds = (async () => ({
+      kind: "project_log",
+      org_id: await this.org_id,
+      project_id: (await this.project).id,
+      log_id: "g"
+    }))();
     return new SpanImpl({
+      parentIds,
       bgLogger: this.bgLogger,
       name: name ?? "root",
-      ...argsRest,
-      rootProject: project
+      ...argsRest
     });
   }
-  /**
-   * Wrapper over `Logger.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
-   */
-  async traced(callback, args) {
-    const { setCurrent, ...argsRest } = args ?? {};
-    const span = await this.startSpan(argsRest);
-    try {
-      let ret = null;
-      return await (setCurrent ?? true ? withCurrent(span, () => callback(span)) : callback(span));
-    } finally {
-      span.end();
-      if (!this.logOptions.asyncFlush) {
-        await this.flush();
-      }
-    }
-  }
   /*
    * Flush any pending logs to the server.
    */
   async flush() {
     return await this.bgLogger.flush();
   }
+  get asyncFlush() {
+    return this.logOptions.asyncFlush;
+  }
 };
+function castLogger(logger, asyncFlush) {
+  if (logger === void 0)
+    return void 0;
+  if (asyncFlush && !!asyncFlush !== !!logger.asyncFlush) {
+    throw new Error(
+      `Asserted asyncFlush setting ${asyncFlush} does not match stored logger's setting ${logger.asyncFlush}`
+    );
+  }
+  return logger;
+}
 var MaxRequestSize = 6 * 1024 * 1024;
 function constructJsonArray(items) {
   return `[${items.join(",")}]`;
@@ -8256,10 +8255,11 @@ function now() {
   return (/* @__PURE__ */ new Date()).getTime();
 }
 var BackgroundLogger = class {
-  constructor() {
+  constructor(logConn) {
     this.items = [];
     this.active_flush = Promise.resolve([]);
     this.active_flush_resolved = true;
+    this.logConn = logConn;
     isomorph_default.processOn("beforeExit", async () => {
       await this.flush();
     });
@@ -8273,8 +8273,9 @@ var BackgroundLogger = class {
   }
   async flush_once(batchSize = DefaultBatchSize) {
     this.active_flush_resolved = false;
-    const allItems = mergeRowBatch(this.items || []).reverse();
+    const itemPromises = this.items;
     this.items = [];
+    const allItems = mergeRowBatch(await Promise.all(itemPromises)).reverse();
     let postPromises = [];
     while (true) {
       const items = [];
@@ -8299,7 +8300,7 @@ var BackgroundLogger = class {
           for (let i = 0; i < NumRetries; i++) {
             const startTime = now();
             try {
-              return (await _state.logConn().post_json("logs", itemsS)).map(
+              return (await (await this.logConn).post_json("logs", itemsS)).map(
                 (res) => res.id
               );
             } catch (e) {
@@ -8340,7 +8341,7 @@ var BackgroundLogger = class {
     }
   }
 };
-async function init(project, options = {}) {
+function init(project, options = {}) {
   const {
     experiment,
     description,
@@ -8351,79 +8352,129 @@ async function init(project, options = {}) {
     apiUrl,
     apiKey,
     orgName,
-    disableCache,
     metadata
   } = options || {};
-  await login({
-    orgName,
-    disableCache,
-    apiKey,
-    apiUrl
-  });
-  return await _initExperiment(project, {
-    experimentName: experiment,
-    description,
-    dataset,
-    update,
-    baseExperiment,
-    isPublic,
-    metadata
-  });
-}
-async function withExperiment(project, callback, options = {}) {
-  const experiment = await init(project, options);
-  return runFinally(
-    () => {
-      if (options.setCurrent ?? true) {
-        return withCurrent(experiment, () => callback(experiment));
-      } else {
-        return callback(experiment);
+  const lazyMetadata = (async () => {
+    await login({
+      orgName,
+      apiKey,
+      apiUrl
+    });
+    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;
+    }
+    const repoStatus = await isomorph_default.getRepoStatus();
+    if (repoStatus) {
+      args["repo_info"] = repoStatus;
+    }
+    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;
+        }
       }
-    },
-    () => experiment.close()
+    }
+    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;
+  }
+  return ret;
+}
+function withExperiment(project, callback, options = {}) {
+  console.warn(
+    "withExperiment is deprecated and will be removed in a future version of braintrust. Simply create the experiment with `init`."
   );
+  const experiment = init(project, options);
+  return callback(experiment);
 }
-async function withLogger(callback, options = {}) {
-  const logger = initLogger(options);
-  return runFinally(
-    () => {
-      if (options.setCurrent ?? true) {
-        return withCurrent(logger, () => callback(logger));
-      } else {
-        return callback(logger);
-      }
-    },
-    () => logger.flush()
+function withLogger(callback, options = {}) {
+  console.warn(
+    "withLogger is deprecated and will be removed in a future version of braintrust. Simply create the logger with `initLogger`."
   );
+  const logger = initLogger(options);
+  return callback(logger);
 }
-async function initDataset(project, options = {}) {
-  const {
-    dataset,
-    description,
-    version,
-    apiUrl,
-    apiKey,
-    orgName,
-    disableCache
-  } = options || {};
-  await login({
-    orgName,
-    disableCache,
-    apiKey,
-    apiUrl
-  });
-  return await _initDataset(project, {
-    name: dataset,
-    description,
-    version
-  });
+function initDataset(project, options = {}) {
+  const { dataset, description, version, apiUrl, apiKey, orgName } = options || {};
+  const lazyMetadata = (async () => {
+    await login({
+      orgName,
+      apiKey,
+      apiUrl
+    });
+    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);
 }
-async function withDataset(project, callback, options = {}) {
-  const dataset = await initDataset(project, options);
-  return runFinally(
-    () => callback(dataset),
-    () => dataset.close()
+function withDataset(project, callback, options = {}) {
+  console.warn(
+    "withDataset is deprecated and will be removed in a future version of braintrust. Simply create the dataset with `initDataset`."
   );
+  const dataset = initDataset(project, options);
+  return callback(dataset);
 }
 function initLogger(options = {}) {
   const {
@@ -8433,42 +8484,67 @@ function initLogger(options = {}) {
     apiUrl,
     apiKey,
     orgName,
-    disableCache
+    forceLogin
   } = options || {};
-  const lazyLogin = async () => {
+  const lazyMetadata = (async () => {
     await login({
       orgName,
-      disableCache,
       apiKey,
-      apiUrl
+      apiUrl,
+      forceLogin
     });
-  };
-  return new Logger(
-    lazyLogin,
-    new Project({
-      name: projectName,
-      id: projectId
-    }),
-    {
-      asyncFlush
+    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
+  });
+  if (options.setCurrent ?? true) {
+    _state.currentLogger = ret;
+  }
+  return ret;
 }
 async function login(options = {}) {
   const {
     apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") || "https://www.braintrustdata.com",
     apiKey = isomorph_default.getEnv("BRAINTRUST_API_KEY"),
-    orgName = isomorph_default.getEnv("BRAINTRUST_ORG_NAME"),
-    disableCache = false
+    orgName = isomorph_default.getEnv("BRAINTRUST_ORG_NAME")
   } = options || {};
   let { forceLogin = false } = options || {};
-  if (apiUrl != _state.apiUrl || apiKey !== void 0 && HTTPConnection.sanitize_token(apiKey) != _state.loginToken || orgName !== void 0 && orgName != _state.orgName) {
-    forceLogin = true;
-  }
   if (_state.loggedIn && !forceLogin) {
     return;
   }
-  _state = new BraintrustState();
+  _state.resetLoginInfo();
   _state.apiUrl = apiUrl;
   let conn = null;
   if (apiKey !== void 0) {
@@ -8501,78 +8577,87 @@ async function login(options = {}) {
   _state.loggedIn = true;
 }
 function log(event) {
-  const currentExperiment2 = _state.currentExperiment.getStore();
-  if (!currentExperiment2) {
+  console.warn(
+    "braintrust.log is deprecated and will be removed in a future version of braintrust. Use `experiment.log` instead."
+  );
+  const e = currentExperiment();
+  if (!e) {
     throw new Error("Not initialized. Please call init() first");
   }
-  return currentExperiment2.log(event);
+  return e.log(event);
 }
 async function summarize(options = {}) {
-  const currentExperiment2 = _state.currentExperiment.getStore();
-  if (!currentExperiment2) {
+  console.warn(
+    "braintrust.summarize is deprecated and will be removed in a future version of braintrust. Use `experiment.summarize` instead."
+  );
+  const e = currentExperiment();
+  if (!e) {
     throw new Error("Not initialized. Please call init() first");
   }
-  return await currentExperiment2.summarize(options);
+  return await e.summarize(options);
 }
 function currentExperiment() {
-  return _state.currentExperiment.getStore();
+  return _state.currentExperiment;
 }
-function currentLogger() {
-  return _state.currentLogger.getStore();
+function currentLogger(options) {
+  return castLogger(_state.currentLogger, options?.asyncFlush);
 }
 function currentSpan() {
-  return _state.currentSpan.getStore() ?? noopSpan;
+  return _state.currentSpan.getStore() ?? NOOP_SPAN;
 }
-function startSpan(args) {
-  const { name: nameOpt, ...argsRest } = args ?? {};
-  const name = (nameOpt ?? isomorph_default.getCallerLocation()?.caller_functionname) || "root";
+function getSpanParentObject(options) {
   const parentSpan = currentSpan();
-  if (!parentSpan) {
-    throw new Error(
-      "Cannot call startSpan() from outside a trace. Please wrap this code in a traced() callback."
-    );
-  }
-  if (!Object.is(parentSpan, noopSpan)) {
-    return parentSpan.startSpan(name, argsRest);
+  if (!Object.is(parentSpan, NOOP_SPAN)) {
+    return parentSpan;
   }
   const experiment = currentExperiment();
   if (experiment) {
-    return experiment.startSpan({ name, ...argsRest });
+    return experiment;
   }
-  const logger = currentLogger();
+  const logger = currentLogger(options);
   if (logger) {
-    throw new Error(
-      "Cannot start a span within a logger from startSpan(). Use logger.startSpan() instead."
-    );
+    return logger;
   }
-  return noopSpan;
+  return NOOP_SPAN;
 }
 function traced(callback, args) {
-  const span = startSpan(args);
-  return runFinally(
+  const { span, parentObject } = startSpanReturnParent(args);
+  const ret = runFinally(
     () => {
       if (args?.setCurrent ?? true) {
-        return withCurrent(span, () => callback(span));
+        return withCurrent(span, callback);
       } else {
         return callback(span);
       }
     },
     () => span.end()
   );
-}
-function withCurrent(object, callback) {
-  if (object.kind === "experiment") {
-    return _state.currentExperiment.run(object, callback);
-  } else if (object.kind === "logger") {
-    return _state.currentLogger.run(object, callback);
-  } else if (object.kind === "span") {
-    return _state.currentSpan.run(object, callback);
+  if (args?.asyncFlush) {
+    return ret;
   } else {
-    throw new Error(
-      `Invalid object of type ${object.constructor.name}`
-    );
+    return (async () => {
+      const awaitedRet = await ret;
+      if (parentObject.kind === "logger") {
+        await parentObject.flush();
+      }
+      return awaitedRet;
+    })();
   }
 }
+function startSpan(args) {
+  return startSpanReturnParent(args).span;
+}
+function startSpanReturnParent(args) {
+  const parentObject = getSpanParentObject({
+    asyncFlush: args?.asyncFlush
+  });
+  const { name: nameOpt, ...argsRest } = args ?? {};
+  const name = parentObject.kind === "span" ? nameOpt : nameOpt ?? "root";
+  return { span: parentObject.startSpan({ name, ...argsRest }), parentObject };
+}
+function withCurrent(span, callback) {
+  return _state.currentSpan.run(span, () => callback(span));
+}
 function _check_org_info(org_info, org_name) {
   if (org_info.length === 0) {
     throw new Error("This user is not part of any organizations.");
@@ -8659,83 +8744,34 @@ function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
   }
   return event;
 }
-async function _initExperiment(projectName, {
-  experimentName,
-  description,
-  dataset,
-  update,
-  baseExperiment,
-  isPublic,
-  metadata
-} = {
-  experimentName: void 0,
-  description: void 0,
-  baseExperiment: void 0,
-  isPublic: false,
-  metadata: void 0
-}) {
-  const args = {
-    project_name: projectName,
-    org_id: _state.orgId
-  };
-  if (experimentName) {
-    args["experiment_name"] = experimentName;
-  }
-  if (description) {
-    args["description"] = description;
-  }
-  if (update) {
-    args["update"] = update;
-  }
-  const repoStatus = await isomorph_default.getRepoStatus();
-  if (repoStatus) {
-    args["repo_info"] = repoStatus;
-  }
-  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 project = response.project;
-  const experiment = response.experiment;
-  return new Experiment(project, experiment.id, experiment.name, dataset);
-}
 var Experiment = class {
-  constructor(project, id, name, dataset) {
+  constructor(lazyMetadata, dataset) {
     // For type identification.
     this.kind = "experiment";
-    this.finished = false;
-    this.project = project;
-    this.id = id;
-    this.name = name;
+    this.lazyMetadata = lazyMetadata;
     this.dataset = dataset;
-    this.bgLogger = new BackgroundLogger();
+    const logConn = this.getState().then((state) => state.logConn());
+    this.bgLogger = new BackgroundLogger(logConn);
     this.lastStartTime = getCurrentUnixTimestamp();
-    unterminatedObjects.addUnterminated(this, isomorph_default.getCallerLocation());
+  }
+  get id() {
+    return (async () => {
+      return (await this.lazyMetadata).experiment.id;
+    })();
+  }
+  get name() {
+    return (async () => {
+      return (await this.lazyMetadata).experiment.name;
+    })();
+  }
+  get project() {
+    return (async () => {
+      return (await this.lazyMetadata).project;
+    })();
+  }
+  async getState() {
+    await this.lazyMetadata;
+    return _state;
   }
   /**
    * Log a single event to the experiment. The event will be batched and uploaded behind the scenes.
@@ -8753,29 +8789,15 @@ var Experiment = class {
    * :returns: The `id` of the logged event.
    */
   log(event) {
-    this.checkNotFinished();
     event = validateAndSanitizeExperimentLogFullArgs(event, !!this.dataset);
     const span = this.startSpan({ startTime: this.lastStartTime, event });
     this.lastStartTime = span.end();
     return span.id;
   }
   /**
-   * Create a new toplevel span. The name parameter is optional and defaults to "root".
+   * Create a new toplevel span underneath the experiment. The name defaults to "root".
    *
-   * See `Span.startSpan` for full details.
-   */
-  startSpan(args) {
-    this.checkNotFinished();
-    const { name, ...argsRest } = args ?? {};
-    return new SpanImpl({
-      bgLogger: this.bgLogger,
-      name: name ?? "root",
-      ...argsRest,
-      rootExperiment: this
-    });
-  }
-  /**
-   * Wrapper over `Experiment.startSpan`, which passes the initialized `Span` it to the given callback and ends it afterwards. See `Span.traced` for full details.
+   * See `Span.traced` for full details.
    */
   traced(callback, args) {
     const { setCurrent, ...argsRest } = args ?? {};
@@ -8783,7 +8805,7 @@ var Experiment = class {
     return runFinally(
       () => {
         if (setCurrent ?? true) {
-          return withCurrent(span, () => callback(span));
+          return withCurrent(span, callback);
         } else {
           return callback(span);
         }
@@ -8791,6 +8813,25 @@ var Experiment = class {
       () => span.end()
     );
   }
+  /**
+   * Lower-level alternative to `traced`, which does not automatically end the span or mark it as current.
+   *
+   * See `traced` for full details.
+   */
+  startSpan(args) {
+    const { name, ...argsRest } = args ?? {};
+    const parentIds = (async () => ({
+      kind: "experiment",
+      project_id: (await this.project).id,
+      experiment_id: await this.id
+    }))();
+    return new SpanImpl({
+      parentIds,
+      bgLogger: this.bgLogger,
+      name: name ?? "root",
+      ...argsRest
+    });
+  }
   /**
    * Summarize the experiment, including the scores (compared to the closest reference experiment) and metadata.
    *
@@ -8802,18 +8843,21 @@ var Experiment = class {
   async summarize(options = {}) {
     let { summarizeScores = true, comparisonExperimentId = void 0 } = options || {};
     await this.bgLogger.flush();
-    const projectUrl = `${_state.apiUrl}/app/${encodeURIComponent(
-      _state.orgName
-    )}/p/${encodeURIComponent(this.project.name)}`;
-    const experimentUrl = `${projectUrl}/${encodeURIComponent(this.name)}`;
+    const state = await this.getState();
+    const projectUrl = `${state.apiUrl}/app/${encodeURIComponent(
+      state.orgName
+    )}/p/${encodeURIComponent((await this.project).name)}`;
+    const experimentUrl = `${projectUrl}/${encodeURIComponent(
+      await this.name
+    )}`;
     let scores = void 0;
     let metrics = void 0;
     let comparisonExperimentName = void 0;
     if (summarizeScores) {
       if (comparisonExperimentId === void 0) {
-        const conn = _state.logConn();
+        const conn = state.logConn();
         const resp = await conn.get("/crud/base_experiments", {
-          id: this.id
+          id: await this.id
         });
         const base_experiments = await resp.json();
         if (base_experiments.length > 0) {
@@ -8822,10 +8866,10 @@ var Experiment = class {
         }
       }
       if (comparisonExperimentId !== void 0) {
-        const results = await _state.logConn().get_json(
+        const results = await state.logConn().get_json(
           "/experiment-comparison2",
           {
-            experiment_id: this.id,
+            experiment_id: await this.id,
             base_experiment_id: comparisonExperimentId
           },
           3
@@ -8835,8 +8879,8 @@ var Experiment = class {
       }
     }
     return {
-      projectName: this.project.name,
-      experimentName: this.name,
+      projectName: (await this.project).name,
+      experimentName: await this.name,
       projectUrl,
       experimentUrl,
       comparisonExperimentName,
@@ -8845,118 +8889,99 @@ var Experiment = class {
     };
   }
   /**
-   * Finish the experiment and return its id. After calling close, you may not invoke any further methods on the experiment object.
-   *
-   * Will be invoked automatically if the experiment is wrapped in a callback passed to `braintrust.withExperiment`.
-   *
-   * @returns The experiment id.
+   * Flush any pending rows to the server.
+   */
+  async flush() {
+    return await this.bgLogger.flush();
+  }
+  /**
+   * This function is deprecated. You can simply remove it from your code.
    */
   async close() {
-    this.checkNotFinished();
-    await this.bgLogger.flush();
-    this.finished = true;
-    unterminatedObjects.removeUnterminated(this);
+    console.warn(
+      "close is deprecated and will be removed in a future version of braintrust. It is now a no-op and can be removed"
+    );
     return this.id;
   }
-  checkNotFinished() {
-    if (this.finished) {
-      throw new Error("Cannot invoke method on finished experiment");
-    }
-  }
 };
 var SpanImpl = class _SpanImpl {
   // root_experiment should only be specified for a root span. parent_span
   // should only be specified for non-root spans.
   constructor(args) {
     this.kind = "span";
-    this.finished = false;
     this.loggedEndTime = void 0;
     this.bgLogger = args.bgLogger;
     const callerLocation = isomorph_default.getCallerLocation();
+    const name = (() => {
+      if (args.name)
+        return args.name;
+      if (callerLocation) {
+        const pathComponents = callerLocation.caller_filename.split("/");
+        const filename = pathComponents[pathComponents.length - 1];
+        return [callerLocation.caller_functionname].concat(
+          filename ? [`${filename}:${callerLocation.caller_lineno}`] : []
+        ).join(":");
+      }
+      return "subspan";
+    })();
     this.internalData = {
       metrics: {
         start: args.startTime ?? getCurrentUnixTimestamp(),
         ...callerLocation
       },
-      span_attributes: { ...args.spanAttributes, name: args.name },
+      span_attributes: { ...args.spanAttributes, name },
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
+    this.parentIds = args.parentIds;
     const id = args.event?.id ?? v4_default();
     const span_id = v4_default();
-    if ("rootExperiment" in args) {
-      this._object_info = {
-        id,
-        span_id,
-        root_span_id: span_id,
-        project_id: args.rootExperiment.project.id,
-        experiment_id: args.rootExperiment.id
-      };
-    } else if ("rootProject" in args) {
-      this._object_info = {
-        id,
-        span_id,
-        root_span_id: span_id,
-        org_id: _state.orgId,
-        project_id: args.rootProject.id,
-        log_id: "g"
-      };
-    } else if ("parentSpan" in args) {
-      this._object_info = {
-        ...args.parentSpan._object_info,
-        id,
-        span_id
-      };
-      this.internalData.span_parents = [args.parentSpan.span_id];
-    } else {
-      throw new Error("Must provide either 'rootExperiment' or 'parentSpan'");
+    this.rowIds = {
+      id,
+      span_id,
+      root_span_id: args.parentSpanInfo?.root_span_id ?? span_id
+    };
+    if (args.parentSpanInfo) {
+      this.internalData.span_parents = [args.parentSpanInfo.span_id];
     }
     this.isMerge = false;
     const { id: _id, ...eventRest } = args.event ?? {};
     this.log(eventRest);
     this.isMerge = true;
-    unterminatedObjects.addUnterminated(this, callerLocation);
   }
   get id() {
-    return this._object_info.id;
+    return this.rowIds.id;
   }
   get span_id() {
-    return this._object_info.span_id;
+    return this.rowIds.span_id;
   }
   get root_span_id() {
-    return this._object_info.root_span_id;
+    return this.rowIds.root_span_id;
   }
   log(event) {
-    this.checkNotFinished();
     const sanitized = validateAndSanitizeExperimentLogPartialArgs(event);
     const sanitizedAndInternalData = { ...this.internalData };
     mergeDicts(sanitizedAndInternalData, sanitized);
-    const record = {
-      ...sanitizedAndInternalData,
-      ...this._object_info,
-      [IS_MERGE_FIELD]: this.isMerge
-    };
-    if (record.metrics?.end) {
-      this.loggedEndTime = record.metrics?.end;
-    }
     this.internalData = {};
+    if (sanitizedAndInternalData.metrics?.end) {
+      this.loggedEndTime = sanitizedAndInternalData.metrics?.end;
+    }
+    const record = (async () => {
+      return {
+        ...sanitizedAndInternalData,
+        ...this.rowIds,
+        ...await this.parentIds,
+        [IS_MERGE_FIELD]: this.isMerge
+      };
+    })();
     this.bgLogger.log([record]);
   }
-  startSpan(name, args) {
-    this.checkNotFinished();
-    return new _SpanImpl({
-      bgLogger: this.bgLogger,
-      name,
-      ...args,
-      parentSpan: this
-    });
-  }
-  traced(name, callback, args) {
+  traced(callback, args) {
     const { setCurrent, ...argsRest } = args ?? {};
-    const span = this.startSpan(name, argsRest);
+    const span = this.startSpan(argsRest);
     return runFinally(
       () => {
         if (setCurrent ?? true) {
-          return withCurrent(span, () => callback(span));
+          return withCurrent(span, callback);
         } else {
           return callback(span);
         }
@@ -8964,8 +8989,18 @@ var SpanImpl = class _SpanImpl {
       () => span.end()
     );
   }
+  startSpan(args) {
+    return new _SpanImpl({
+      parentIds: this.parentIds,
+      bgLogger: this.bgLogger,
+      parentSpanInfo: {
+        span_id: this.rowIds.span_id,
+        root_span_id: this.rowIds.root_span_id
+      },
+      ...args
+    });
+  }
   end(args) {
-    this.checkNotFinished();
     let endTime;
     if (!this.loggedEndTime) {
       endTime = args?.endTime ?? getCurrentUnixTimestamp();
@@ -8974,45 +9009,38 @@ var SpanImpl = class _SpanImpl {
       endTime = this.loggedEndTime;
     }
     this.log({});
-    this.finished = true;
-    unterminatedObjects.removeUnterminated(this);
     return endTime;
   }
   close(args) {
     return this.end(args);
   }
-  checkNotFinished() {
-    if (this.finished) {
-      throw new Error("Cannot invoke method on finished span");
-    }
-  }
 };
-async function _initDataset(project_name, {
-  name,
-  description,
-  version
-} = {}) {
-  const args = {
-    org_id: _state.orgId,
-    project_name,
-    dataset_name: name,
-    description
-  };
-  const response = await _state.apiConn().post_json("api/dataset/register", args);
-  const project = response.project;
-  const dataset = response.dataset;
-  return new Dataset(project, dataset.id, dataset.name, version);
-}
 var Dataset = class {
-  constructor(project, id, name, pinnedVersion) {
+  constructor(lazyMetadata, pinnedVersion) {
     this._fetchedData = void 0;
-    this.finished = false;
-    this.project = project;
-    this.id = id;
-    this.name = name;
+    this.lazyMetadata = lazyMetadata;
     this.pinnedVersion = pinnedVersion;
-    this.logger = new BackgroundLogger();
-    unterminatedObjects.addUnterminated(this, isomorph_default.getCallerLocation());
+    const logConn = this.getState().then((state) => state.logConn());
+    this.bgLogger = new BackgroundLogger(logConn);
+  }
+  get id() {
+    return (async () => {
+      return (await this.lazyMetadata).dataset.id;
+    })();
+  }
+  get name() {
+    return (async () => {
+      return (await this.lazyMetadata).dataset.name;
+    })();
+  }
+  get project() {
+    return (async () => {
+      return (await this.lazyMetadata).project;
+    })();
+  }
+  async getState() {
+    await this.lazyMetadata;
+    return _state;
   }
   /**
    * Insert a single record to the dataset. The record will be batched and uploaded behind the scenes. If you pass in an `id`,
@@ -9034,7 +9062,6 @@ var Dataset = class {
     metadata,
     id
   }) {
-    this.checkNotFinished();
     if (metadata !== void 0) {
       for (const key of Object.keys(metadata)) {
         if (typeof key !== "string") {
@@ -9042,29 +9069,29 @@ var Dataset = class {
         }
       }
     }
-    const args = {
-      id: id || v4_default(),
+    const rowId = id || v4_default();
+    const args = (async () => ({
+      id: rowId,
       inputs: input,
       output,
-      project_id: this.project.id,
-      dataset_id: this.id,
+      project_id: (await this.project).id,
+      dataset_id: await this.id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       metadata
-    };
-    this.logger.log([args]);
-    return args.id;
+    }))();
+    this.bgLogger.log([args]);
+    return rowId;
   }
   delete(id) {
-    this.checkNotFinished();
-    const args = {
+    const args = (async () => ({
       id,
-      project_id: this.project.id,
-      dataset_id: this.id,
+      project_id: (await this.project).id,
+      dataset_id: await this.id,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       _object_delete: true
-    };
-    this.logger.log([args]);
-    return args.id;
+    }))();
+    this.bgLogger.log([args]);
+    return id;
   }
   /**
    * Summarize the dataset, including high level metrics about its size and other metadata.
@@ -9073,26 +9100,26 @@ var Dataset = class {
    * @returns A summary of the dataset.
    */
   async summarize(options = {}) {
-    this.checkNotFinished();
     let { summarizeData = true } = options || {};
-    await this.logger.flush();
-    const projectUrl = `${_state.apiUrl}/app/${encodeURIComponent(
-      _state.orgName
-    )}/p/${encodeURIComponent(this.project.name)}`;
-    const datasetUrl = `${projectUrl}/d/${encodeURIComponent(this.name)}`;
+    await this.bgLogger.flush();
+    const state = await this.getState();
+    const projectUrl = `${state.apiUrl}/app/${encodeURIComponent(
+      state.orgName
+    )}/p/${encodeURIComponent((await this.project).name)}`;
+    const datasetUrl = `${projectUrl}/d/${encodeURIComponent(await this.name)}`;
     let dataSummary = void 0;
     if (summarizeData) {
-      dataSummary = await _state.logConn().get_json(
+      dataSummary = await state.logConn().get_json(
         "dataset-summary",
         {
-          dataset_id: this.id
+          dataset_id: await this.id
         },
         3
       );
     }
     return {
-      projectName: this.project.name,
-      datasetName: this.name,
+      projectName: (await this.project).name,
+      datasetName: await this.name,
       projectUrl,
       datasetUrl,
       dataSummary
@@ -9117,7 +9144,6 @@ var Dataset = class {
    * @returns An iterator over the dataset's records.
    */
   async *fetch() {
-    this.checkNotFinished();
     const records = await this.fetchedData();
     for (const record of records) {
       yield {
@@ -9141,14 +9167,13 @@ var Dataset = class {
    * ```
    */
   [Symbol.asyncIterator]() {
-    this.checkNotFinished();
     return this.fetch();
   }
   async fetchedData() {
-    this.checkNotFinished();
     if (this._fetchedData === void 0) {
-      const resp = await _state.logConn().get("object/dataset", {
-        id: this.id,
+      const state = await this.getState();
+      const resp = await state.logConn().get("object/dataset", {
+        id: await this.id,
         fmt: "json",
         version: this.pinnedVersion
       });
@@ -9158,11 +9183,9 @@ var Dataset = class {
     return this._fetchedData || [];
   }
   clearCache() {
-    this.checkNotFinished();
     this._fetchedData = void 0;
   }
   async version() {
-    this.checkNotFinished();
     if (this.pinnedVersion !== void 0) {
       return this.pinnedVersion;
     } else {
@@ -9178,24 +9201,20 @@ var Dataset = class {
     }
   }
   /**
-   * Terminate connection to the dataset and return its id. After calling close, you may not invoke any further methods on the dataset object.
-   *
-   * Will be invoked automatically if the dataset is bound as a context manager.
-   *
-   * @returns The dataset id.
+   * Flush any pending rows to the server.
+   */
+  async flush() {
+    return await this.bgLogger.flush();
+  }
+  /**
+   * This function is deprecated. You can simply remove it from your code.
    */
   async close() {
-    this.checkNotFinished();
-    await this.logger.flush();
-    this.finished = true;
-    unterminatedObjects.removeUnterminated(this);
+    console.warn(
+      "close is deprecated and will be removed in a future version of braintrust. It is now a no-op and can be removed"
+    );
     return this.id;
   }
-  checkNotFinished() {
-    if (this.finished) {
-      throw new Error("Cannot invoke method on finished dataset");
-    }
-  }
 };
 
 // src/node.ts
@@ -9271,28 +9290,28 @@ async function Eval(name, evaluator) {
   }
   const progressReporter = new BarProgressReporter();
   try {
-    return await withExperiment(
-      name,
-      async (experiment) => {
-        const ret = await runEvaluator(
-          experiment,
-          {
-            evalName,
-            projectName: name,
-            ...evaluator
-          },
-          progressReporter,
-          []
-        );
-        reportEvaluatorResult(name, ret, { verbose: true, jsonl: false });
-        return ret.summary;
-      },
-      {
-        experiment: evaluator.experimentName,
-        metadata: evaluator.metadata,
-        isPublic: evaluator.isPublic
-      }
-    );
+    const experiment = init(name, {
+      experiment: evaluator.experimentName,
+      metadata: evaluator.metadata,
+      isPublic: evaluator.isPublic,
+      setCurrent: false
+    });
+    try {
+      const ret = await runEvaluator(
+        experiment,
+        {
+          evalName,
+          projectName: name,
+          ...evaluator
+        },
+        progressReporter,
+        []
+      );
+      reportEvaluatorResult(name, ret, { verbose: true, jsonl: false });
+      return ret.summary;
+    } finally {
+      experiment.flush();
+    }
   } finally {
     progressReporter.stop();
   }
@@ -9332,30 +9351,27 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
     let output = void 0;
     let error2 = void 0;
     let scores = {};
-    const callback = async () => {
+    const callback = async (rootSpan) => {
       try {
         const meta = (o) => metadata = { ...metadata, ...o };
-        await traced(
-          async () => {
-            const outputResult = evaluator.task(datum.input, {
-              meta,
-              span: currentSpan()
-            });
+        await rootSpan.traced(
+          async (span) => {
+            const outputResult = evaluator.task(datum.input, { meta, span });
             if (outputResult instanceof Promise) {
               output = await outputResult;
             } else {
               output = outputResult;
             }
-            currentSpan().log({ input: datum.input, output });
+            span.log({ input: datum.input, output });
           },
           { name: "task" }
         );
-        currentSpan().log({ output });
+        rootSpan.log({ output });
         const scoringArgs = { ...datum, metadata, output };
         const scoreResults = await Promise.all(
           evaluator.scores.map(async (score, score_idx) => {
-            return traced(
-              async () => {
+            return rootSpan.traced(
+              async (span) => {
                 const scoreResult = score(scoringArgs);
                 const result = scoreResult instanceof Promise ? await scoreResult : scoreResult;
                 const {
@@ -9363,7 +9379,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
                   name: _,
                   ...resultRest
                 } = result;
-                currentSpan().log({
+                span.log({
                   output: resultRest,
                   metadata: resultMetadata
                 });
@@ -9392,7 +9408,7 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
         if (Object.keys(scoreMetadata).length > 0) {
           meta({ scores: scoreMetadata });
         }
-        currentSpan().log({ scores, metadata });
+        rootSpan.log({ scores, metadata });
       } catch (e) {
         error2 = e;
       } finally {
@@ -9405,17 +9421,16 @@ async function runEvaluator(experiment, evaluator, progressReporter, filters) {
         error: error2
       };
     };
-    const rootSpan = experiment ? experiment.startSpan({
-      name: "eval",
-      event: {
-        input: datum.input,
-        expected: datum.expected
-      }
-    }) : noopSpan;
-    try {
-      return await withCurrent(rootSpan, callback);
-    } finally {
-      rootSpan.end();
+    if (!experiment) {
+      return await callback(NOOP_SPAN);
+    } else {
+      return await experiment.traced(callback, {
+        name: "eval",
+        event: {
+          input: datum.input,
+          expected: datum.expected
+        }
+      });
     }
   });
   const results = await Promise.all(evals);
@@ -9678,6 +9693,7 @@ configureNode();
   Eval,
   Experiment,
   Logger,
+  NOOP_SPAN,
   NoopSpan,
   SpanImpl,
   _internalGetGlobalState,
@@ -9685,16 +9701,15 @@ configureNode();
   currentExperiment,
   currentLogger,
   currentSpan,
+  getSpanParentObject,
   init,
   initDataset,
   initLogger,
   log,
   login,
-  noopSpan,
   startSpan,
   summarize,
   traced,
-  withCurrent,
   withDataset,
   withExperiment,
   withLogger,