braintrust 0.0.55 → 0.0.57

package/dist/index.js

@@ -8880,11 +8880,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path) {
-      if (!path || typeof path !== "string") {
+    function lookup(path2) {
+      if (!path2 || typeof path2 !== "string") {
         return false;
       }
-      var extension2 = extname("x." + path).toLowerCase().substr(1);
+      var extension2 = extname("x." + path2).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -9141,7 +9141,7 @@ var require_form_data = __commonJS({
   "node_modules/form-data/lib/form_data.js"(exports, module2) {
     var CombinedStream = require_combined_stream();
     var util2 = require("util");
-    var path = require("path");
+    var path2 = require("path");
     var http3 = require("http");
     var https3 = require("https");
     var parseUrl = require("url").parse;
@@ -9268,11 +9268,11 @@ var require_form_data = __commonJS({
     FormData3.prototype._getContentDisposition = function(value, options) {
       var filename, contentDisposition;
       if (typeof options.filepath === "string") {
-        filename = path.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path2.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value.name || value.path) {
-        filename = path.basename(options.filename || value.name || value.path);
+        filename = path2.basename(options.filename || value.name || value.path);
       } else if (value.readable && value.hasOwnProperty("httpVersion")) {
-        filename = path.basename(value.client._httpMessage.path || "");
+        filename = path2.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
         contentDisposition = 'filename="' + filename + '"';
@@ -10749,10 +10749,10 @@ var require_src2 = __commonJS({
     var fs_1 = require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check(path, isFile2, isDirectory) {
-      log2(`checking %s`, path);
+    function check(path2, isFile2, isDirectory) {
+      log2(`checking %s`, path2);
       try {
-        const stat = fs_1.statSync(path);
+        const stat = fs_1.statSync(path2);
         if (stat.isFile() && isFile2) {
           log2(`[OK] path represents a file`);
           return true;
@@ -10772,8 +10772,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path, type = exports.READABLE) {
-      return check(path, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path2, type = exports.READABLE) {
+      return check(path2, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -10844,12 +10844,23 @@ __export(src_exports, {
   Dataset: () => Dataset,
   Eval: () => Eval,
   Experiment: () => Experiment,
+  NoopSpan: () => NoopSpan,
   Project: () => Project,
+  SpanImpl: () => SpanImpl,
+  _internalGetGlobalState: () => _internalGetGlobalState,
+  currentExperiment: () => currentExperiment,
+  currentSpan: () => currentSpan,
   init: () => init,
   initDataset: () => initDataset,
   log: () => log,
   login: () => login,
-  summarize: () => summarize
+  noopSpan: () => noopSpan,
+  startSpan: () => startSpan,
+  summarize: () => summarize,
+  traced: () => traced,
+  withCurrent: () => withCurrent,
+  withDataset: () => withDataset,
+  withExperiment: () => withExperiment
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -11305,10 +11316,10 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path, key, dots) {
-  if (!path)
+function renderKey(path2, key, dots) {
+  if (!path2)
     return key;
-  return path.concat(key).map(function each(token, i) {
+  return path2.concat(key).map(function each(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -11354,9 +11365,9 @@ function toFormData(obj, formData, options) {
     }
     return value;
   }
-  function defaultVisitor(value, key, path) {
+  function defaultVisitor(value, key, path2) {
     let arr = value;
-    if (value && !path && typeof value === "object") {
+    if (value && !path2 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = JSON.stringify(value);
@@ -11375,7 +11386,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path, key, dots), convertValue(value));
+    formData.append(renderKey(path2, key, dots), convertValue(value));
     return false;
   }
   const stack = [];
@@ -11384,11 +11395,11 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path) {
+  function build(value, path2) {
     if (utils_default.isUndefined(value))
       return;
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path.join("."));
+      throw Error("Circular reference detected in " + path2.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
@@ -11396,11 +11407,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path,
+        path2,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path ? path.concat(key) : [key]);
+        build(el, path2 ? path2.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -11561,7 +11572,7 @@ var node_default = {
 // node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new node_default.classes.URLSearchParams(), Object.assign({
-    visitor: function(value, key, path, helpers) {
+    visitor: function(value, key, path2, helpers) {
       if (node_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -11590,10 +11601,10 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path, value, target, index) {
-    let name = path[index++];
+  function buildPath(path2, value, target, index) {
+    let name = path2[index++];
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path.length;
+    const isLast = index >= path2.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -11606,7 +11617,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path, value, target[name], index);
+    const result = buildPath(path2, value, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -12705,9 +12716,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path;
+    let path2;
     try {
-      path = buildURL(
+      path2 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -12725,7 +12736,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path,
+      path: path2,
       method,
       headers: headers.toJSON(),
       agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -12948,14 +12959,14 @@ var cookies_default = node_default.isStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   function standardBrowserEnv() {
     return {
-      write: function write(name, value, expires, path, domain, secure) {
+      write: function write(name, value, expires, path2, domain, secure) {
         const cookie = [];
         cookie.push(name + "=" + encodeURIComponent(value));
         if (utils_default.isNumber(expires)) {
           cookie.push("expires=" + new Date(expires).toGMTString());
         }
-        if (utils_default.isString(path)) {
-          cookie.push("path=" + path);
+        if (utils_default.isString(path2)) {
+          cookie.push("path=" + path2);
         }
         if (utils_default.isString(domain)) {
           cookie.push("domain=" + domain);
@@ -13790,14 +13801,31 @@ var {
   mergeConfig: mergeConfig2
 } = axios_default;
 
+// src/node.ts
+var import_node_async_hooks = require("node:async_hooks");
+
 // src/isomorph.ts
+var DefaultAsyncLocalStorage = class {
+  constructor() {
+  }
+  enterWith(_) {
+  }
+  run(_, callback) {
+    return callback();
+  }
+  getStore() {
+    return void 0;
+  }
+};
 var iso = {
   makeAxios: (conf) => axios_default.create({
     ...conf
   }),
   getRepoStatus: async () => void 0,
   getPastNAncestors: async () => [],
-  getEnv: (_name) => void 0
+  getEnv: (_name) => void 0,
+  getCallerLocation: () => void 0,
+  newAsyncLocalStorage: () => new DefaultAsyncLocalStorage()
 };
 var isomorph_default = iso;
 
@@ -13872,8 +13900,8 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-function isPathSpec(path) {
-  return path instanceof String && cache.has(path);
+function isPathSpec(path2) {
+  return path2 instanceof String && cache.has(path2);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -13955,8 +13983,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path) {
-  return (0, import_file_exists.exists)(path, import_file_exists.FOLDER);
+function folderExists(path2) {
+  return (0, import_file_exists.exists)(path2, import_file_exists.FOLDER);
 }
 function append2(target, item) {
   if (Array.isArray(target)) {
@@ -14319,8 +14347,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path) {
-      return /^\.(git)?$/.test(path.trim());
+    parser(path2) {
+      return /^\.(git)?$/.test(path2.trim());
     }
   };
 }
@@ -14711,11 +14739,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path, line, preview] = input.split(NULL);
-    paths.add(path);
-    (results[path] = results[path] || []).push({
+    const [path2, line, preview] = input.split(NULL);
+    paths.add(path2);
+    (results[path2] = results[path2] || []).push({
       line: asNumber(line),
-      path,
+      path: path2,
       preview
     });
   });
@@ -15332,14 +15360,14 @@ var init_hash_object = __esm({
     init_task();
   }
 });
-function parseInit(bare, path, text) {
+function parseInit(bare, path2, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path, false, result[1]);
+    return new InitSummary(bare, path2, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path, true, result[1]);
+    return new InitSummary(bare, path2, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -15350,7 +15378,7 @@ function parseInit(bare, path, text) {
       break;
     }
   }
-  return new InitSummary(bare, path, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path2, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -15358,9 +15386,9 @@ var reInitResponseRegex;
 var init_InitSummary = __esm({
   "src/lib/responses/InitSummary.ts"() {
     InitSummary = class {
-      constructor(bare, path, existing, gitDir) {
+      constructor(bare, path2, existing, gitDir) {
         this.bare = bare;
-        this.path = path;
+        this.path = path2;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -15372,7 +15400,7 @@ var init_InitSummary = __esm({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path, customArgs) {
+function initTask(bare = false, path2, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -15381,7 +15409,7 @@ function initTask(bare = false, path, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path, text);
+      return parseInit(commands.includes("--bare"), path2, text);
     }
   };
 }
@@ -16101,12 +16129,12 @@ var init_FileStatusSummary = __esm({
   "src/lib/responses/FileStatusSummary.ts"() {
     fromPathRegex = /^(.+) -> (.+)$/;
     FileStatusSummary = class {
-      constructor(path, index, working_dir) {
-        this.path = path;
+      constructor(path2, index, working_dir) {
+        this.path = path2;
         this.index = index;
         this.working_dir = working_dir;
         if (index + working_dir === "R") {
-          const detail = fromPathRegex.exec(path) || [null, path, path];
+          const detail = fromPathRegex.exec(path2) || [null, path2, path2];
           this.from = detail[1] || "";
           this.path = detail[2] || "";
         }
@@ -16137,14 +16165,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path) {
+  function data(index, workingDir, path2) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path);
+      handler(result, path2);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path.replace(/\0.+$/, ""), index, workingDir));
+      result.files.push(new FileStatusSummary(path2.replace(/\0.+$/, ""), index, workingDir));
     }
   }
 }
@@ -16389,8 +16417,8 @@ var init_simple_git_api = __esm({
         }
         return this._runTask(configurationErrorTask("Git.cwd: workingDirectory must be supplied as a string"), next);
       }
-      hashObject(path, write) {
-        return this._runTask(hashObjectTask(path, write === true), trailingFunctionArgument(arguments));
+      hashObject(path2, write) {
+        return this._runTask(hashObjectTask(path2, write === true), trailingFunctionArgument(arguments));
       }
       init(bare) {
         return this._runTask(initTask(bare === true, this._executor.cwd, getTrailingOptions(arguments)), trailingFunctionArgument(arguments));
@@ -16967,8 +16995,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path) {
-  return subModuleTask(["add", repo, path]);
+function addSubModuleTask(repo, path2) {
+  return subModuleTask(["add", repo, path2]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -17234,8 +17262,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path, then) {
-      return this._runTask(addSubModuleTask2(repo, path), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path2, then) {
+      return this._runTask(addSubModuleTask2(repo, path2), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(updateSubModuleTask2(getTrailingOptions2(arguments, true)), trailingFunctionArgument2(arguments));
@@ -17824,6 +17852,50 @@ async function getRepoStatus() {
   };
 }
 
+// src/stackutil.ts
+var path = __toESM(require("path"));
+function getStackTrace() {
+  const trace = new Error().stack;
+  if (trace === void 0) {
+    return [];
+  }
+  const traceLines = trace.split("\n");
+  const out = [];
+  const stackFrameRegex = /at(.*)\((.*):(\d+):(\d+)\)/;
+  for (const traceLine of traceLines.slice(1)) {
+    const matches = traceLine.match(stackFrameRegex);
+    if (matches === null || matches.length !== 5) {
+      continue;
+    }
+    const entry = {
+      functionName: matches[1].trim(),
+      fileName: matches[2],
+      lineNo: parseInt(matches[3])
+    };
+    if (!isNaN(entry.lineNo)) {
+      out.push(entry);
+    }
+  }
+  return out;
+}
+function getCallerLocation() {
+  let thisDir = void 0;
+  const entries = getStackTrace();
+  for (const frame of entries) {
+    if (thisDir === void 0) {
+      thisDir = path.dirname(frame.fileName);
+    }
+    if (path.dirname(frame.fileName) !== thisDir) {
+      return {
+        caller_functionname: frame.functionName,
+        caller_filename: frame.fileName,
+        caller_lineno: frame.lineNo
+      };
+    }
+  }
+  return void 0;
+}
+
 // src/node.ts
 function configureNode() {
   isomorph_default.makeAxios = (options) => {
@@ -17838,6 +17910,8 @@ function configureNode() {
   isomorph_default.getRepoStatus = getRepoStatus;
   isomorph_default.getPastNAncestors = getPastNAncestors;
   isomorph_default.getEnv = (name) => process.env[name];
+  isomorph_default.getCallerLocation = getCallerLocation;
+  isomorph_default.newAsyncLocalStorage = () => new import_node_async_hooks.AsyncLocalStorage();
 }
 
 // node_modules/uuid/dist/esm-node/rng.js
@@ -17887,17 +17961,126 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
+// src/util.ts
+function runFinally(f, finallyF) {
+  let runSyncCleanup = true;
+  try {
+    const ret = f();
+    if (ret instanceof Promise) {
+      runSyncCleanup = false;
+      return ret.finally(finallyF);
+    } else {
+      return ret;
+    }
+  } finally {
+    if (runSyncCleanup) {
+      finallyF();
+    }
+  }
+}
+
 // src/logger.ts
-var _state = {
-  current_project: null,
-  current_experiment: null
+var NoopSpan = class {
+  constructor() {
+    this.kind = "span";
+    this.id = "";
+    this.span_id = "";
+    this.root_span_id = "";
+  }
+  log(_) {
+  }
+  startSpan(_0, _1) {
+    return this;
+  }
+  traced(_0, callback, _1) {
+    return callback(this);
+  }
+  end(args) {
+    return args?.endTime ?? getCurrentUnixTimestamp();
+  }
+  close(args) {
+    return this.end(args);
+  }
+};
+var noopSpan = new NoopSpan();
+var BraintrustState = class {
+  constructor() {
+    this.id = v4_default();
+    this.currentExperiment = isomorph_default.newAsyncLocalStorage();
+    this.currentSpan = isomorph_default.newAsyncLocalStorage();
+    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._userInfo = null;
+    globalThis.__inherited_braintrust_state = this;
+  }
+  apiConn() {
+    if (!this._apiConn) {
+      if (!this.apiUrl) {
+        throw new Error("Must initialize apiUrl before requesting apiConn");
+      }
+      this._apiConn = new HTTPConnection(this.apiUrl);
+    }
+    return this._apiConn;
+  }
+  logConn() {
+    if (!this._logConn) {
+      if (!this.logUrl) {
+        throw new Error("Must initialize logUrl before requesting logConn");
+      }
+      this._logConn = new HTTPConnection(this.logUrl);
+    }
+    return this._logConn;
+  }
+  async userInfo() {
+    if (!this._userInfo) {
+      this._userInfo = await this.logConn().get_json("ping");
+    }
+    return this._userInfo;
+  }
+  setUserInfoIfNull(info) {
+    if (!this._userInfo) {
+      this._userInfo = info;
+    }
+  }
 };
-var API_URL = null;
-var LOGIN_TOKEN = null;
-var ORG_ID = null;
-var ORG_NAME = null;
-var LOG_URL = null;
-var LOGGED_IN = false;
+var _state = globalThis.__inherited_braintrust_state || new BraintrustState();
+var _internalGetGlobalState = () => _state;
+var UnterminatedObjectsHandler = class {
+  constructor() {
+    this.unterminatedObjects = /* @__PURE__ */ new Map();
+    process.on("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 TRANSACTION_ID_FIELD = "_xact_id";
 var HTTPConnection = class _HTTPConnection {
   constructor(base_url) {
@@ -17909,9 +18092,7 @@ var HTTPConnection = class _HTTPConnection {
   async ping() {
     try {
       const resp = await this.get("ping");
-      if (_var_user_info === null) {
-        _var_user_info = resp.data;
-      }
+      _state.setUserInfoIfNull(resp.data);
       return resp.status === 200;
     } catch (e) {
       return false;
@@ -17936,12 +18117,12 @@ var HTTPConnection = class _HTTPConnection {
     }
     this.session = isomorph_default.makeAxios({ headers });
   }
-  async get(path, params = void 0) {
-    return await this.session.get(_urljoin(this.base_url, path), { params });
+  async get(path2, params = void 0) {
+    return await this.session.get(_urljoin(this.base_url, path2), { params });
   }
-  async post(path, params = void 0, config = void 0) {
+  async post(path2, params = void 0, config = void 0) {
     return await this.session.post(
-      _urljoin(this.base_url, path),
+      _urljoin(this.base_url, path2),
       params,
       config
     );
@@ -17971,32 +18152,6 @@ var HTTPConnection = class _HTTPConnection {
     return resp.data;
   }
 };
-var _api_conn = null;
-function api_conn() {
-  if (!_api_conn) {
-    _api_conn = new HTTPConnection(API_URL);
-  }
-  return _api_conn;
-}
-var _log_conn = null;
-function log_conn() {
-  if (!_log_conn) {
-    _log_conn = new HTTPConnection(LOG_URL);
-  }
-  return _log_conn;
-}
-var _var_user_info = null;
-async function _user_info() {
-  if (_var_user_info === null) {
-    _var_user_info = await log_conn().get_json("ping");
-  }
-  return _var_user_info;
-}
-function clear_cached_globals() {
-  _api_conn = null;
-  _log_conn = null;
-  _var_user_info = null;
-}
 var Project = class {
   constructor(name, id, org_id) {
     this.name = name;
@@ -18041,10 +18196,7 @@ var LogThread = class {
         itemsLen += itemS.length;
       }
       if (items.length > 0) {
-        const resp = await log_conn().post_json(
-          "logs",
-          constructJsonArray(items)
-        );
+        const resp = await _state.logConn().post_json("logs", constructJsonArray(items));
         ret = resp.data;
       } else {
         break;
@@ -18085,7 +18237,7 @@ async function init(project, options = {}) {
     apiKey,
     apiUrl
   });
-  const ret = await _initExperiment(project, {
+  return await _initExperiment(project, {
     experimentName: experiment,
     description,
     dataset,
@@ -18093,8 +18245,19 @@ async function init(project, options = {}) {
     baseExperiment,
     isPublic
   });
-  _state.current_experiment = ret;
-  return ret;
+}
+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);
+      }
+    },
+    () => experiment.close()
+  );
 }
 async function initDataset(project, options = {}) {
   const {
@@ -18118,6 +18281,13 @@ async function initDataset(project, options = {}) {
     version
   });
 }
+async function withDataset(project, callback, options = {}) {
+  const dataset = await initDataset(project, options);
+  return runFinally(
+    () => callback(dataset),
+    () => dataset.close()
+  );
+}
 async function login(options = {}) {
   const {
     apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") || "https://www.braintrustdata.com",
@@ -18126,24 +18296,27 @@ async function login(options = {}) {
     disableCache = false
   } = options || {};
   let { forceLogin = false } = options || {};
-  if (apiUrl != API_URL || apiKey !== void 0 && HTTPConnection.sanitize_token(apiKey) != LOGIN_TOKEN || orgName !== void 0 && orgName != ORG_NAME) {
+  if (apiUrl != _state.apiUrl || apiKey !== void 0 && HTTPConnection.sanitize_token(apiKey) != _state.loginToken || orgName !== void 0 && orgName != _state.orgName) {
     forceLogin = true;
   }
-  if (LOGGED_IN && !forceLogin) {
+  if (_state.loggedIn && !forceLogin) {
     return;
   }
-  clear_cached_globals();
-  API_URL = apiUrl;
+  _state = new BraintrustState();
+  _state.apiUrl = apiUrl;
   let login_key_info = null;
   let ping_ok = false;
   let conn = null;
   if (apiKey !== void 0) {
-    const resp = await axios_default.post(_urljoin(API_URL, `/api/apikey/login`), {
-      token: apiKey
-    });
+    const resp = await axios_default.post(
+      _urljoin(_state.apiUrl, `/api/apikey/login`),
+      {
+        token: apiKey
+      }
+    );
     const info = resp.data;
     _check_org_info(info.org_info, orgName);
-    conn = log_conn();
+    conn = _state.logConn();
     conn.set_token(apiKey);
     ping_ok = await conn.ping();
   } else {
@@ -18158,21 +18331,66 @@ async function login(options = {}) {
     await conn.get("ping");
   }
   conn.make_long_lived();
-  api_conn().set_token(apiKey);
-  LOGIN_TOKEN = conn.token;
-  LOGGED_IN = true;
+  _state.apiConn().set_token(apiKey);
+  _state.loginToken = conn.token;
+  _state.loggedIn = true;
 }
-function log(options) {
-  if (!_state.current_experiment) {
+function log(event) {
+  const currentExperiment2 = _state.currentExperiment.getStore();
+  if (!currentExperiment2) {
     throw new Error("Not initialized. Please call init() first");
   }
-  return _state.current_experiment.log(options);
+  return currentExperiment2.log(event);
 }
 async function summarize(options = {}) {
-  if (!_state.current_experiment) {
+  const currentExperiment2 = _state.currentExperiment.getStore();
+  if (!currentExperiment2) {
     throw new Error("Not initialized. Please call init() first");
   }
-  return await _state.current_experiment.summarize(options);
+  return await currentExperiment2.summarize(options);
+}
+function currentExperiment() {
+  return _state.currentExperiment.getStore();
+}
+function currentSpan() {
+  return _state.currentSpan.getStore();
+}
+function startSpan(args) {
+  const { name: nameOpt, ...argsRest } = args ?? {};
+  const name = (nameOpt ?? isomorph_default.getCallerLocation()?.caller_functionname) || "root";
+  const parentSpan = currentSpan();
+  if (!Object.is(parentSpan, noopSpan)) {
+    return parentSpan.startSpan(name, argsRest);
+  }
+  const experiment = currentExperiment();
+  if (experiment) {
+    return experiment.startSpan({ name, ...argsRest });
+  }
+  return noopSpan;
+}
+function traced(callback, args) {
+  const span = startSpan(args);
+  return runFinally(
+    () => {
+      if (args?.setCurrent ?? true) {
+        return withCurrent(span, () => callback(span));
+      } else {
+        return callback(span);
+      }
+    },
+    () => span.end()
+  );
+}
+function withCurrent(object, callback) {
+  if (object.kind === "experiment") {
+    return _state.currentExperiment.run(object, callback);
+  } else if (object.kind === "span") {
+    return _state.currentSpan.run(object, callback);
+  } else {
+    throw new Error(
+      `Invalid object of type ${object.constructor.name}`
+    );
+  }
 }
 function _check_org_info(org_info, org_name) {
   if (org_info.length === 0) {
@@ -18180,13 +18398,13 @@ function _check_org_info(org_info, org_name) {
   }
   for (const org of org_info) {
     if (org_name === void 0 || org.name === org_name) {
-      ORG_ID = org.id;
-      ORG_NAME = org.name;
-      LOG_URL = org.api_url;
+      _state.orgId = org.id;
+      _state.orgName = org.name;
+      _state.logUrl = org.api_url;
       break;
     }
   }
-  if (ORG_ID === void 0) {
+  if (_state.orgId === void 0) {
     throw new Error(
       `Organization ${org_name} not found. Must be one of ${org_info.map((x) => x.name).join(", ")}`
     );
@@ -18195,6 +18413,82 @@ function _check_org_info(org_info, org_name) {
 function _urljoin(...parts) {
   return parts.map((x) => x.replace(/^\//, "")).join("/");
 }
+function getCurrentUnixTimestamp() {
+  return (/* @__PURE__ */ new Date()).getTime() / 1e3;
+}
+function validateAndSanitizeExperimentLogPartialArgs(event) {
+  if (event.scores) {
+    for (let [name, score] of Object.entries(event.scores)) {
+      if (typeof name !== "string") {
+        throw new Error("score names must be strings");
+      }
+      if (typeof score === "boolean") {
+        score = score ? 1 : 0;
+        event.scores[name] = score;
+      }
+      if (typeof score !== "number") {
+        throw new Error("score values must be numbers");
+      }
+      if (score < 0 || score > 1) {
+        throw new Error("score values must be between 0 and 1");
+      }
+    }
+  }
+  if (event.metadata) {
+    for (const key of Object.keys(event.metadata)) {
+      if (typeof key !== "string") {
+        throw new Error("metadata keys must be strings");
+      }
+    }
+  }
+  if (event.metrics) {
+    for (const key of Object.keys(event.metrics)) {
+      if (typeof key !== "string") {
+        throw new Error("metric keys must be strings");
+      }
+    }
+    for (const forbiddenKey of [
+      "start",
+      "end",
+      "caller_functionname",
+      "caller_filename",
+      "caller_lineno"
+    ]) {
+      if (forbiddenKey in event.metrics) {
+        throw new Error(`Key ${forbiddenKey} may not be specified in metrics`);
+      }
+    }
+  }
+  if ("input" in event && event.input && "inputs" in event && event.inputs) {
+    throw new Error(
+      "Only one of input or inputs (deprecated) can be specified. Prefer input."
+    );
+  }
+  if ("inputs" in event) {
+    const { inputs, ...rest } = event;
+    return { input: inputs, ...rest };
+  } else {
+    return { ...event };
+  }
+}
+function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
+  if ("input" in event && event.input && "inputs" in event && 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.scores) {
+    throw new Error("scores must be specified");
+  }
+  if (hasDataset && event.datasetRecordId === void 0) {
+    throw new Error("datasetRecordId must be specified when using a dataset");
+  } else if (!hasDataset && event.datasetRecordId !== void 0) {
+    throw new Error(
+      "datasetRecordId cannot be specified when not using a dataset"
+    );
+  }
+  return event;
+}
 async function _initExperiment(projectName, {
   experimentName,
   description,
@@ -18210,7 +18504,7 @@ async function _initExperiment(projectName, {
 }) {
   const args = {
     project_name: projectName,
-    org_id: ORG_ID
+    org_id: _state.orgId
   };
   if (experimentName) {
     args["experiment_name"] = experimentName;
@@ -18237,10 +18531,10 @@ async function _initExperiment(projectName, {
   if (isPublic !== void 0) {
     args["public"] = isPublic;
   }
-  const response = await api_conn().post_json("api/experiment/register", args);
+  const response = await _state.apiConn().post_json("api/experiment/register", args);
   const project = response.project;
   const experiment = response.experiment;
-  const user_id = (await _user_info())["id"];
+  const user_id = (await _state.userInfo())["id"];
   return new Experiment(
     project,
     experiment.id,
@@ -18251,106 +18545,71 @@ async function _initExperiment(projectName, {
 }
 var Experiment = class {
   constructor(project, id, name, user_id, dataset) {
+    // For type identification.
+    this.kind = "experiment";
+    this.finished = false;
     this.project = project;
     this.id = id;
     this.name = name;
     this.user_id = user_id;
     this.dataset = dataset;
     this.logger = new LogThread();
+    this.lastStartTime = getCurrentUnixTimestamp();
+    unterminatedObjects.addUnterminated(this, isomorph_default.getCallerLocation());
   }
   /**
    * Log a single event to the experiment. The event will be batched and uploaded behind the scenes.
    *
    * @param event The event to log.
-   * @param event.input The arguments that uniquely define a test case (an arbitrary, JSON serializable object). Later on,
-   * Braintrust will use the `input` to know whether two test cases are the same between experiments, so they should
-   * not contain experiment-specific state. A simple rule of thumb is that if you run the same experiment twice, the
-   * `input` should be identical.
-   * @param event.output The output of your application, including post-processing (an arbitrary, JSON serializable object),
-   * that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries,
-   * the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may
-   * be multiple valid queries that answer a single question.
-   * @param event.expected The ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to
-   * determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for
-   * you, since there are so many different ways to do that correctly. Instead, these values are just used to help you
-   * navigate your experiments while digging into analyses. However, we may later use these values to re-score outputs or
-   * fine-tune your models.
-   * @param event.scores A dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals
-   * that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a
-   * summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity
-   * between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was
-   * covering similar concepts or not. You can use these scores to help you sort, filter, and compare experiments.
-   * @param event.metadata (Optional) a dictionary with additional data about the test example, model outputs, or just
-   * about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the
-   * `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any
-   * JSON-serializable type, but its keys must be strings.
-   * @param event.id (Optional) a unique identifier for the event. If you don't provide one, Braintrust will generate one for you.
-   * @param event.inputs (Deprecated) the same as `input` (will be removed in a future version)
-   * @returns The `id` of the logged event.
+   * @param event.input: The arguments that uniquely define a test case (an arbitrary, JSON serializable object). Later on, Braintrust will use the `input` to know whether two test cases are the same between experiments, so they should not contain experiment-specific state. A simple rule of thumb is that if you run the same experiment twice, the `input` should be identical.
+   * @param event.output: The output of your application, including post-processing (an arbitrary, JSON serializable object), that allows you to determine whether the result is correct or not. For example, in an app that generates SQL queries, the `output` should be the _result_ of the SQL query generated by the model, not the query itself, because there may be multiple valid queries that answer a single question.
+   * @param event.expected: The ground truth value (an arbitrary, JSON serializable object) that you'd compare to `output` to determine if your `output` value is correct or not. Braintrust currently does not compare `output` to `expected` for you, since there are so many different ways to do that correctly. Instead, these values are just used to help you navigate your experiments while digging into analyses. However, we may later use these values to re-score outputs or fine-tune your models.
+   * @param event.scores: A dictionary of numeric values (between 0 and 1) to log. The scores should give you a variety of signals that help you determine how accurate the outputs are compared to what you expect and diagnose failures. For example, a summarization app might have one score that tells you how accurate the summary is, and another that measures the word similarity between the generated and grouth truth summary. The word similarity score could help you determine whether the summarization was covering similar concepts or not. You can use these scores to help you sort, filter, and compare experiments.
+   * @param event.metadata: (Optional) a dictionary with additional data about the test example, model outputs, or just about anything else that's relevant, that you can use to help find and analyze examples later. For example, you could log the `prompt`, example's `id`, or anything else that would be useful to slice/dice later. The values in `metadata` can be any JSON-serializable type, but its keys must be strings.
+   * @param event.metrics: (Optional) a dictionary of metrics to log. The following keys are populated automatically and should not be specified: "start", "end", "caller_functionname", "caller_filename", "caller_lineno".
+   * @param event.id: (Optional) a unique identifier for the event. If you don't provide one, BrainTrust will generate one for you.
+   * @param event.dataset_record_id: (Optional) the id of the dataset record that this event is associated with. This field is required if and only if the experiment is associated with a dataset.
+   * @param event.inputs: (Deprecated) the same as `input` (will be removed in a future version).
+   * :returns: The `id` of the logged event.
    */
-  log({
-    input,
-    output,
-    expected,
-    scores,
-    metadata,
-    id,
-    datasetRecordId,
-    inputs
-  }) {
-    if (input === void 0 && inputs === void 0) {
-      throw new Error(
-        "Either input or inputs (deprecated) must be specified. Prefer input."
-      );
-    } else if (input !== void 0 && inputs !== void 0) {
-      throw new Error(
-        "Only one of input or inputs (deprecated) can be specified. Prefer input."
-      );
-    }
-    for (let [name, score] of Object.entries(scores)) {
-      if (typeof name !== "string") {
-        throw new Error("score names must be strings");
-      }
-      if (typeof score === "boolean") {
-        score = score ? 1 : 0;
-        scores[name] = score;
-      }
-      if (typeof score !== "number") {
-        throw new Error("score values must be numbers");
-      }
-      if (score < 0 || score > 1) {
-        throw new Error("score values must be between 0 and 1");
-      }
-    }
-    if (metadata !== void 0) {
-      for (const key of Object.keys(metadata)) {
-        if (typeof key !== "string") {
-          throw new Error("metadata keys must be strings");
+  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".
+   *
+   * See `Span.startSpan` for full details.
+   */
+  startSpan(args) {
+    this.checkNotFinished();
+    const { name, ...argsRest } = args ?? {};
+    return new SpanImpl({
+      experimentLogger: this.logger,
+      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.
+   */
+  traced(callback, args) {
+    const { setCurrent, ...argsRest } = args ?? {};
+    const span = this.startSpan(argsRest);
+    return runFinally(
+      () => {
+        if (setCurrent ?? true) {
+          return withCurrent(span, () => callback(span));
+        } else {
+          return callback(span);
         }
-      }
-    }
-    if (this.dataset && datasetRecordId === void 0) {
-      throw new Error("datasetRecordId must be specified when using a dataset");
-    } else if (!this.dataset && datasetRecordId !== void 0) {
-      throw new Error(
-        "datasetRecordId cannot be specified when not using a dataset"
-      );
-    }
-    const args = {
-      id: id || v4_default(),
-      inputs: input ?? inputs,
-      output,
-      expected,
-      scores,
-      project_id: this.project.id,
-      experiment_id: this.id,
-      user_id: this.user_id,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      dataset_record_id: datasetRecordId,
-      metadata
-    };
-    this.logger.log([args]);
-    return args.id;
+      },
+      () => span.end()
+    );
   }
   /**
    * Summarize the experiment, including the scores (compared to the closest reference experiment) and metadata.
@@ -18363,15 +18622,15 @@ var Experiment = class {
   async summarize(options = {}) {
     let { summarizeScores = true, comparisonExperimentId = void 0 } = options || {};
     await this.logger.flush();
-    const projectUrl = `${API_URL}/app/${encodeURIComponent(
-      ORG_NAME
+    const projectUrl = `${_state.apiUrl}/app/${encodeURIComponent(
+      _state.orgName
     )}/p/${encodeURIComponent(this.project.name)}`;
     const experimentUrl = `${projectUrl}/${encodeURIComponent(this.name)}`;
     let scores = void 0;
     let comparisonExperimentName = void 0;
     if (summarizeScores) {
       if (comparisonExperimentId === void 0) {
-        const conn = log_conn();
+        const conn = _state.logConn();
         const resp = await conn.get("/crud/base_experiments", {
           id: this.id
         });
@@ -18382,7 +18641,7 @@ var Experiment = class {
         }
       }
       if (comparisonExperimentId !== void 0) {
-        scores = await log_conn().get_json(
+        scores = await _state.logConn().get_json(
           "/experiment-comparison",
           {
             experiment_id: this.id,
@@ -18401,6 +18660,122 @@ var Experiment = class {
       scores
     };
   }
+  /**
+   * 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.
+   */
+  async close() {
+    this.checkNotFinished();
+    await this.logger.flush();
+    this.finished = true;
+    unterminatedObjects.removeUnterminated(this);
+    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.experimentLogger = args.experimentLogger;
+    const callerLocation = isomorph_default.getCallerLocation();
+    this.internalData = {
+      metrics: {
+        start: args.startTime ?? getCurrentUnixTimestamp(),
+        ...callerLocation
+      },
+      span_attributes: { ...args.spanAttributes, name: args.name }
+    };
+    this.id = args.event?.id ?? v4_default();
+    this.span_id = v4_default();
+    if ("rootExperiment" in args) {
+      this.root_span_id = this.span_id;
+      this._project_id = args.rootExperiment.project.id;
+      this._experiment_id = args.rootExperiment.id;
+      this.internalData = Object.assign(this.internalData, {
+        // TODO: Hopefully we can remove this.
+        user_id: args.rootExperiment.user_id,
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else if ("parentSpan" in args) {
+      this.root_span_id = args.parentSpan.root_span_id;
+      this._project_id = args.parentSpan._project_id;
+      this._experiment_id = args.parentSpan._experiment_id;
+      this.internalData.span_parents = [args.parentSpan.span_id];
+    } else {
+      throw new Error("Must provide either 'rootExperiment' or 'parentSpan'");
+    }
+    this.isMerge = false;
+    const { id, ...eventRest } = args.event ?? {};
+    this.log(eventRest);
+    this.isMerge = true;
+    unterminatedObjects.addUnterminated(this, callerLocation);
+  }
+  log(event) {
+    this.checkNotFinished();
+    const sanitized = validateAndSanitizeExperimentLogPartialArgs(event);
+    const record = {
+      ...sanitized,
+      ...this.internalData,
+      id: this.id,
+      span_id: this.span_id,
+      root_span_id: this.root_span_id,
+      project_id: this._project_id,
+      experiment_id: this._experiment_id,
+      _is_merge: this.isMerge
+    };
+    this.internalData = {};
+    this.experimentLogger.log([record]);
+  }
+  startSpan(name, args) {
+    this.checkNotFinished();
+    return new _SpanImpl({
+      experimentLogger: this.experimentLogger,
+      name,
+      ...args,
+      parentSpan: this
+    });
+  }
+  traced(name, callback, args) {
+    const { setCurrent, ...argsRest } = args ?? {};
+    const span = this.startSpan(name, argsRest);
+    return runFinally(
+      () => {
+        if (setCurrent ?? true) {
+          return withCurrent(span, () => callback(span));
+        } else {
+          return callback(span);
+        }
+      },
+      () => span.end()
+    );
+  }
+  end(args) {
+    this.checkNotFinished();
+    const endTime = args?.endTime ?? getCurrentUnixTimestamp();
+    this.internalData = { metrics: { end: endTime } };
+    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,
@@ -18408,26 +18783,28 @@ async function _initDataset(project_name, {
   version
 } = {}) {
   const args = {
-    org_id: ORG_ID,
+    org_id: _state.orgId,
     project_name,
     dataset_name: name,
     description
   };
-  const response = await api_conn().post_json("api/dataset/register", args);
+  const response = await _state.apiConn().post_json("api/dataset/register", args);
   const project = response.project;
   const dataset = response.dataset;
-  const user_id = (await _user_info())["id"];
+  const user_id = (await _state.userInfo())["id"];
   return new Dataset(project, dataset.id, dataset.name, user_id, version);
 }
 var Dataset = class {
   constructor(project, id, name, user_id, pinnedVersion) {
     this._fetchedData = void 0;
+    this.finished = false;
     this.project = project;
     this.id = id;
     this.name = name;
     this.user_id = user_id;
     this.pinnedVersion = pinnedVersion;
     this.logger = new LogThread();
+    unterminatedObjects.addUnterminated(this, isomorph_default.getCallerLocation());
   }
   /**
    * Insert a single record to the dataset. The record will be batched and uploaded behind the scenes. If you pass in an `id`,
@@ -18449,6 +18826,7 @@ var Dataset = class {
     metadata,
     id
   }) {
+    this.checkNotFinished();
     if (metadata !== void 0) {
       for (const key of Object.keys(metadata)) {
         if (typeof key !== "string") {
@@ -18470,6 +18848,7 @@ var Dataset = class {
     return args.id;
   }
   delete(id) {
+    this.checkNotFinished();
     const user_id = this.user_id;
     const args = {
       id,
@@ -18489,15 +18868,16 @@ var Dataset = class {
    * @returns A summary of the dataset.
    */
   async summarize(options = {}) {
+    this.checkNotFinished();
     let { summarizeData = true } = options || {};
     await this.logger.flush();
-    const projectUrl = `${API_URL}/app/${encodeURIComponent(
-      ORG_NAME
+    const projectUrl = `${_state.apiUrl}/app/${encodeURIComponent(
+      _state.orgName
     )}/p/${encodeURIComponent(this.project.name)}`;
     const datasetUrl = `${projectUrl}/d/${encodeURIComponent(this.name)}`;
     let dataSummary = void 0;
     if (summarizeData) {
-      dataSummary = await log_conn().get_json(
+      dataSummary = await _state.logConn().get_json(
         "dataset-summary",
         {
           dataset_id: this.id
@@ -18532,6 +18912,7 @@ 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 {
@@ -18555,11 +18936,13 @@ var Dataset = class {
    * ```
    */
   [Symbol.asyncIterator]() {
+    this.checkNotFinished();
     return this.fetch();
   }
   async fetchedData() {
+    this.checkNotFinished();
     if (this._fetchedData === void 0) {
-      const resp = await log_conn().get("object/dataset", {
+      const resp = await _state.logConn().get("object/dataset", {
         id: this.id,
         fmt: "json",
         version: this.pinnedVersion
@@ -18570,9 +18953,11 @@ 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 {
@@ -18587,6 +18972,25 @@ var Dataset = class {
       return maxVersion;
     }
   }
+  /**
+   * 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.
+   */
+  async close() {
+    this.checkNotFinished();
+    await this.logger.flush();
+    this.finished = true;
+    unterminatedObjects.removeUnterminated(this);
+    return this.id;
+  }
+  checkNotFinished() {
+    if (this.finished) {
+      throw new Error("Cannot invoke method on finished dataset");
+    }
+  }
 };
 
 // src/framework.ts
@@ -18605,12 +19009,23 @@ configureNode();
   Dataset,
   Eval,
   Experiment,
+  NoopSpan,
   Project,
+  SpanImpl,
+  _internalGetGlobalState,
+  currentExperiment,
+  currentSpan,
   init,
   initDataset,
   log,
   login,
-  summarize
+  noopSpan,
+  startSpan,
+  summarize,
+  traced,
+  withCurrent,
+  withDataset,
+  withExperiment
 });
 /*! Bundled license information: