braintrust 0.0.122 → 0.0.123

package/dist/browser.js

@@ -1362,6 +1362,15 @@ function rng() {
   return getRandomValues(rnds8);
 }
 
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-browser/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-browser/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
 // ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-browser/stringify.js
 var byteToHex = [];
 for (let i = 0; i < 256; ++i) {
@@ -1370,6 +1379,41 @@ for (let i = 0; i < 256; ++i) {
 function unsafeStringify(arr, offset = 0) {
   return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
 }
+function stringify(arr, offset = 0) {
+  const uuid = unsafeStringify(arr, offset);
+  if (!validate_default(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+var stringify_default = stringify;
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-browser/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  const arr = new Uint8Array(16);
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 255;
+  arr[2] = v >>> 8 & 255;
+  arr[3] = v & 255;
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 255;
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 255;
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 255;
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255;
+  arr[11] = v / 4294967296 & 255;
+  arr[12] = v >>> 24 & 255;
+  arr[13] = v >>> 16 & 255;
+  arr[14] = v >>> 8 & 255;
+  arr[15] = v & 255;
+  return arr;
+}
+var parse_default = parse;
 
 // ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-browser/native.js
 var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
@@ -1397,451 +1441,61 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 
-// ../core/js/dist/index.mjs
-var TRANSACTION_ID_FIELD = "_xact_id";
-var IS_MERGE_FIELD = "_is_merge";
-var MERGE_PATHS_FIELD = "_merge_paths";
-var AUDIT_SOURCE_FIELD = "_audit_source";
-var AUDIT_METADATA_FIELD = "_audit_metadata";
-var VALID_SOURCES = ["app", "api", "external"];
-var PARENT_ID_FIELD = "_parent_id";
-function mergeDicts(mergeInto, mergeFrom) {
-  for (const [k, mergeFromV] of Object.entries(mergeFrom)) {
-    const mergeIntoV = mergeInto[k];
-    if (mergeIntoV instanceof Object && !Array.isArray(mergeIntoV) && mergeFrom instanceof Object && !Array.isArray(mergeFromV)) {
-      mergeDicts(
-        mergeIntoV,
-        mergeFromV
-      );
-    } else {
-      mergeInto[k] = mergeFromV;
-    }
-  }
-  return mergeInto;
-}
-function constructJsonArray(items) {
-  return `[${items.join(",")}]`;
-}
-function mapAt(m, k) {
-  const ret = m.get(k);
-  if (ret === void 0) {
-    throw new Error(`Map does not contain key ${k}`);
+// ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
+var util;
+(function(util2) {
+  util2.assertEqual = (val) => val;
+  function assertIs(_arg) {
   }
-  return ret;
-}
-function depthFirstSearch(args) {
-  var _a2;
-  const { graph, firstVisitF, lastVisitF } = args;
-  for (const vs of graph.values()) {
-    for (const v of vs.values()) {
-      if (!graph.has(v)) {
-        throw new Error(`Outgoing vertex ${v} must be a key in the graph`);
-      }
-    }
+  util2.assertIs = assertIs;
+  function assertNever(_x) {
+    throw new Error();
   }
-  const firstVisitedVertices = /* @__PURE__ */ new Set();
-  const visitationOrder = (_a2 = args.visitationOrder) != null ? _a2 : [...graph.keys()];
-  const events = visitationOrder.map((vertex) => ({ eventType: "first", vertex, extras: {} })).reverse();
-  while (events.length) {
-    const { eventType, vertex, extras } = events.pop();
-    if (eventType === "last") {
-      lastVisitF == null ? void 0 : lastVisitF(vertex);
-      continue;
+  util2.assertNever = assertNever;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
     }
-    if (firstVisitedVertices.has(vertex)) {
-      continue;
+    return obj;
+  };
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
     }
-    firstVisitedVertices.add(vertex);
-    firstVisitF == null ? void 0 : firstVisitF(vertex, { parentVertex: extras.parentVertex });
-    events.push({ eventType: "last", vertex, extras: {} });
-    mapAt(graph, vertex).forEach((child) => {
-      events.push({
-        eventType: "first",
-        vertex: child,
-        extras: { parentVertex: vertex }
-      });
-    });
-  }
-}
-function undirectedConnectedComponents(graph) {
-  const directedGraph = new Map(
-    [...graph.vertices].map((v) => [v, /* @__PURE__ */ new Set()])
-  );
-  for (const [i, j] of graph.edges) {
-    mapAt(directedGraph, i).add(j);
-    mapAt(directedGraph, j).add(i);
-  }
-  let labelCounter = 0;
-  const vertexLabels = /* @__PURE__ */ new Map();
-  const firstVisitF = (vertex, args) => {
-    const label = (args == null ? void 0 : args.parentVertex) !== void 0 ? mapAt(vertexLabels, args == null ? void 0 : args.parentVertex) : labelCounter++;
-    vertexLabels.set(vertex, label);
+    return util2.objectValues(filtered);
   };
-  depthFirstSearch({ graph: directedGraph, firstVisitF });
-  const output = Array.from({ length: labelCounter }).map(() => []);
-  for (const [vertex, label] of vertexLabels.entries()) {
-    output[label].push(vertex);
-  }
-  return output;
-}
-function topologicalSort(graph, visitationOrder) {
-  const reverseOrdering = [];
-  const lastVisitF = (vertex) => {
-    reverseOrdering.push(vertex);
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
   };
-  depthFirstSearch({ graph, lastVisitF, visitationOrder });
-  return reverseOrdering.reverse();
-}
-function generateMergedRowKey(row, useParentIdForId) {
-  return JSON.stringify(
-    [
-      "org_id",
-      "project_id",
-      "experiment_id",
-      "dataset_id",
-      "prompt_session_id",
-      "log_id",
-      (useParentIdForId != null ? useParentIdForId : false) ? PARENT_ID_FIELD : "id"
-    ].map((k) => row[k])
-  );
-}
-function mergeRowBatch(rows) {
-  for (const row of rows) {
-    if (row.id === void 0) {
-      throw new Error(
-        "Logged row is missing an id. This is an internal braintrust error. Please contact us at info@braintrustdata.com for help"
-      );
-    }
-  }
-  const rowGroups = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = generateMergedRowKey(row);
-    const existingRow = rowGroups.get(key);
-    if (existingRow !== void 0 && row[IS_MERGE_FIELD]) {
-      const preserveNoMerge = !existingRow[IS_MERGE_FIELD];
-      mergeDicts(existingRow, row);
-      if (preserveNoMerge) {
-        delete existingRow[IS_MERGE_FIELD];
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        keys.push(key);
       }
-    } else {
-      rowGroups.set(key, row);
-    }
-  }
-  const merged = [...rowGroups.values()];
-  const rowToLabel = new Map(
-    merged.map((r, i) => [generateMergedRowKey(r), i])
-  );
-  const graph = new Map(
-    Array.from({ length: merged.length }).map((_, i) => [i, /* @__PURE__ */ new Set()])
-  );
-  merged.forEach((r, i) => {
-    const parentId = r[PARENT_ID_FIELD];
-    if (!parentId) {
-      return;
     }
-    const parentRowKey = generateMergedRowKey(
-      r,
-      true
-      /* useParentIdForId */
-    );
-    const parentLabel = rowToLabel.get(parentRowKey);
-    if (parentLabel !== void 0) {
-      mapAt(graph, parentLabel).add(i);
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
     }
-  });
-  const connectedComponents = undirectedConnectedComponents({
-    vertices: new Set(graph.keys()),
-    edges: new Set(
-      [...graph.entries()].flatMap(
-        ([k, vs]) => [...vs].map((v) => {
-          const ret = [k, v];
-          return ret;
-        })
-      )
-    )
-  });
-  const buckets = connectedComponents.map(
-    (cc) => topologicalSort(
-      graph,
-      cc
-      /* visitationOrder */
-    )
-  );
-  return buckets.map((bucket) => bucket.map((i) => merged[i]));
-}
-function batchItems(args) {
-  var _a2, _b;
-  let { items } = args;
-  const batchMaxNumItems = (_a2 = args.batchMaxNumItems) != null ? _a2 : Number.POSITIVE_INFINITY;
-  const batchMaxNumBytes = (_b = args.batchMaxNumBytes) != null ? _b : Number.POSITIVE_INFINITY;
-  const output = [];
-  let nextItems = [];
-  let batchSet = [];
-  let batch = [];
-  let batchLen = 0;
-  function addToBatch(item) {
-    batch.push(item);
-    batchLen += item.length;
-  }
-  function flushBatch() {
-    batchSet.push(batch);
-    batch = [];
-    batchLen = 0;
+    return void 0;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
   }
-  while (items.length) {
-    for (const bucket of items) {
-      let i = 0;
-      for (const item of bucket) {
-        if (batch.length === 0 || item.length + batchLen < batchMaxNumBytes && batch.length < batchMaxNumItems) {
-          addToBatch(item);
-        } else if (i === 0) {
-          flushBatch();
-          addToBatch(item);
-        } else {
-          break;
-        }
-        ++i;
-      }
-      if (i < bucket.length) {
-        nextItems.push(bucket.slice(i));
-      }
-      if (batchLen >= batchMaxNumBytes || batch.length > batchMaxNumItems) {
-        flushBatch();
-      }
-    }
-    if (batch.length) {
-      flushBatch();
-    }
-    if (batchSet.length) {
-      output.push(batchSet);
-      batchSet = [];
-    }
-    items = nextItems;
-    nextItems = [];
-  }
-  return output;
-}
-var DEFAULT_IS_LEGACY_DATASET = true;
-function ensureDatasetRecord(r, legacy) {
-  if (legacy) {
-    return ensureLegacyDatasetRecord(r);
-  } else {
-    return ensureNewDatasetRecord(r);
-  }
-}
-function ensureLegacyDatasetRecord(r) {
-  if ("output" in r) {
-    return r;
-  }
-  const row = {
-    ...r,
-    output: r.expected
-  };
-  delete row.expected;
-  return row;
-}
-function ensureNewDatasetRecord(r) {
-  if ("expected" in r) {
-    return r;
-  }
-  const row = {
-    ...r,
-    tags: null,
-    expected: r.output
-  };
-  delete row.output;
-  return row;
-}
-function makeLegacyEvent(e) {
-  if (!("dataset_id" in e) || !("expected" in e)) {
-    return e;
-  }
-  const event = {
-    ...e,
-    output: e.expected
-  };
-  delete event.expected;
-  if (MERGE_PATHS_FIELD in event) {
-    for (const path of event[MERGE_PATHS_FIELD] || []) {
-      if (path.length > 0 && path[0] === "expected") {
-        path[0] = "output";
-      }
-    }
-  }
-  return event;
-}
-var SpanParentObjectType = /* @__PURE__ */ ((SpanParentObjectType2) => {
-  SpanParentObjectType2["EXPERIMENT"] = "experiment";
-  SpanParentObjectType2["PROJECT_LOGS"] = "project_logs";
-  return SpanParentObjectType2;
-})(SpanParentObjectType || {});
-var _OBJECT_TYPE_TO_PREFIX = {
-  [
-    "experiment"
-    /* EXPERIMENT */
-  ]: "ex",
-  [
-    "project_logs"
-    /* PROJECT_LOGS */
-  ]: "pl"
-};
-var _PREFIX_TO_OBJECT_TYPE = Object.fromEntries(
-  Object.entries(_OBJECT_TYPE_TO_PREFIX).map(([k, v]) => [v, k])
-);
-var _SEP = ":";
-var SpanParentComponents = class _SpanParentComponents {
-  constructor(args) {
-    this.objectType = args.objectType;
-    this.objectId = args.objectId;
-    this.rowId = args.rowId;
-    if (!(typeof this.objectType === "string")) {
-      throw new Error("objectType must be a string");
-    }
-    if (!(typeof this.objectId === "string")) {
-      throw new Error("objectId must be a string");
-    }
-    if (!(typeof this.rowId === "string")) {
-      throw new Error("rowId must be a string");
-    }
-    const objectTypePrefix = _OBJECT_TYPE_TO_PREFIX[this.objectType];
-    if (objectTypePrefix.includes(_SEP)) {
-      throw new Error(
-        `objectType prefix ${objectTypePrefix} may not contain separator character ${_SEP}`
-      );
-    }
-    if (this.objectId.includes(_SEP)) {
-      throw new Error(
-        `objectId ${this.objectId} may not contain separator character ${_SEP}`
-      );
-    }
-  }
-  toStr() {
-    return [
-      _OBJECT_TYPE_TO_PREFIX[this.objectType],
-      this.objectId,
-      this.rowId
-    ].join(_SEP);
-  }
-  static fromStr(s) {
-    const items = s.split(_SEP);
-    if (items.length < 3) {
-      throw new Error(
-        `Serialized parent components string must have at least three components. Provided string ${s} has only ${items.length}`
-      );
-    }
-    return new _SpanParentComponents({
-      objectType: _PREFIX_TO_OBJECT_TYPE[items[0]],
-      objectId: items[1],
-      rowId: items.slice(2).join(_SEP)
-    });
-  }
-  asDict() {
-    const out = (() => {
-      switch (this.objectType) {
-        case "experiment":
-          return { experiment_id: this.objectId };
-        case "project_logs":
-          return { project_id: this.objectId, log_id: "g" };
-        default:
-          throw new Error("Impossible");
-      }
-    })();
-    if (this.rowId) {
-      out[PARENT_ID_FIELD] = this.rowId;
-    }
-    return out;
-  }
-};
-var SpanTypeAttribute = /* @__PURE__ */ ((SpanTypeAttribute2) => {
-  SpanTypeAttribute2["LLM"] = "llm";
-  SpanTypeAttribute2["SCORE"] = "score";
-  SpanTypeAttribute2["FUNCTION"] = "function";
-  SpanTypeAttribute2["EVAL"] = "eval";
-  SpanTypeAttribute2["TASK"] = "task";
-  SpanTypeAttribute2["TOOL"] = "tool";
-  return SpanTypeAttribute2;
-})(SpanTypeAttribute || {});
-function mergeGitMetadataSettings(s1, s2) {
-  var _a2;
-  if (s1.collect === "all") {
-    return s2;
-  } else if (s2.collect === "all") {
-    return s1;
-  } else if (s1.collect === "none") {
-    return s1;
-  } else if (s2.collect === "none") {
-    return s2;
-  }
-  const fields = ((_a2 = s1.fields) != null ? _a2 : []).filter((f) => {
-    var _a22;
-    return ((_a22 = s2.fields) != null ? _a22 : []).includes(f);
-  });
-  const collect = fields.length > 0 ? "some" : "none";
-  return { collect, fields };
-}
-var TOP_BITS = BigInt("0x0DE1") << BigInt(48);
-var MOD = BigInt(1) << BigInt(64);
-var COPRIME = BigInt("205891132094649");
-var COPRIME_INVERSE = BigInt("1522336535492693385");
-
-// ../core/js/typespecs/dist/index.mjs
-var import_zod_to_openapi = __toESM(require_dist(), 1);
-
-// ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
-var util;
-(function(util2) {
-  util2.assertEqual = (val) => val;
-  function assertIs(_arg) {
-  }
-  util2.assertIs = assertIs;
-  function assertNever(_x) {
-    throw new Error();
-  }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
-    const obj = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
-  };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
-    }
-    return util2.objectValues(filtered);
-  };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
-    });
-  };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-    const keys = [];
-    for (const key in object) {
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
-        keys.push(key);
-      }
-    }
-    return keys;
-  };
-  util2.find = (arr, checker) => {
-    for (const item of arr) {
-      if (checker(item))
-        return item;
-    }
-    return void 0;
-  };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
-  function joinValues(array, separator = " | ") {
-    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
-  }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
+  util2.joinValues = joinValues;
+  util2.jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
     }
     return value;
   };
@@ -5403,124 +5057,562 @@ var coerce = {
   bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
-var NEVER = INVALID;
-var z = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  defaultErrorMap: errorMap,
-  setErrorMap,
-  getErrorMap,
-  makeIssue,
-  EMPTY_PATH,
-  addIssueToContext,
-  ParseStatus,
-  INVALID,
-  DIRTY,
-  OK,
-  isAborted,
-  isDirty,
-  isValid,
-  isAsync,
-  get util() {
-    return util;
-  },
-  get objectUtil() {
-    return objectUtil;
-  },
-  ZodParsedType,
-  getParsedType,
-  ZodType,
-  ZodString,
-  ZodNumber,
-  ZodBigInt,
-  ZodBoolean,
-  ZodDate,
-  ZodSymbol,
-  ZodUndefined,
-  ZodNull,
-  ZodAny,
-  ZodUnknown,
-  ZodNever,
-  ZodVoid,
-  ZodArray,
-  ZodObject,
-  ZodUnion,
-  ZodDiscriminatedUnion,
-  ZodIntersection,
-  ZodTuple,
-  ZodRecord,
-  ZodMap,
-  ZodSet,
-  ZodFunction,
-  ZodLazy,
-  ZodLiteral,
-  ZodEnum,
-  ZodNativeEnum,
-  ZodPromise,
-  ZodEffects,
-  ZodTransformer: ZodEffects,
-  ZodOptional,
-  ZodNullable,
-  ZodDefault,
-  ZodCatch,
-  ZodNaN,
-  BRAND,
-  ZodBranded,
-  ZodPipeline,
-  ZodReadonly,
-  custom,
-  Schema: ZodType,
-  ZodSchema: ZodType,
-  late,
-  get ZodFirstPartyTypeKind() {
-    return ZodFirstPartyTypeKind;
-  },
-  coerce,
-  any: anyType,
-  array: arrayType,
-  bigint: bigIntType,
-  boolean: booleanType,
-  date: dateType,
-  discriminatedUnion: discriminatedUnionType,
-  effect: effectsType,
-  "enum": enumType,
-  "function": functionType,
-  "instanceof": instanceOfType,
-  intersection: intersectionType,
-  lazy: lazyType,
-  literal: literalType,
-  map: mapType,
-  nan: nanType,
-  nativeEnum: nativeEnumType,
-  never: neverType,
-  "null": nullType,
-  nullable: nullableType,
-  number: numberType,
-  object: objectType,
-  oboolean,
-  onumber,
-  optional: optionalType,
-  ostring,
-  pipeline: pipelineType,
-  preprocess: preprocessType,
-  promise: promiseType,
-  record: recordType,
-  set: setType,
-  strictObject: strictObjectType,
-  string: stringType,
-  symbol: symbolType,
-  transformer: effectsType,
-  tuple: tupleType,
-  "undefined": undefinedType,
-  union: unionType,
-  unknown: unknownType,
-  "void": voidType,
-  NEVER,
-  ZodIssueCode,
-  quotelessJson,
-  ZodError
-});
+var NEVER = INVALID;
+var z = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  defaultErrorMap: errorMap,
+  setErrorMap,
+  getErrorMap,
+  makeIssue,
+  EMPTY_PATH,
+  addIssueToContext,
+  ParseStatus,
+  INVALID,
+  DIRTY,
+  OK,
+  isAborted,
+  isDirty,
+  isValid,
+  isAsync,
+  get util() {
+    return util;
+  },
+  get objectUtil() {
+    return objectUtil;
+  },
+  ZodParsedType,
+  getParsedType,
+  ZodType,
+  ZodString,
+  ZodNumber,
+  ZodBigInt,
+  ZodBoolean,
+  ZodDate,
+  ZodSymbol,
+  ZodUndefined,
+  ZodNull,
+  ZodAny,
+  ZodUnknown,
+  ZodNever,
+  ZodVoid,
+  ZodArray,
+  ZodObject,
+  ZodUnion,
+  ZodDiscriminatedUnion,
+  ZodIntersection,
+  ZodTuple,
+  ZodRecord,
+  ZodMap,
+  ZodSet,
+  ZodFunction,
+  ZodLazy,
+  ZodLiteral,
+  ZodEnum,
+  ZodNativeEnum,
+  ZodPromise,
+  ZodEffects,
+  ZodTransformer: ZodEffects,
+  ZodOptional,
+  ZodNullable,
+  ZodDefault,
+  ZodCatch,
+  ZodNaN,
+  BRAND,
+  ZodBranded,
+  ZodPipeline,
+  ZodReadonly,
+  custom,
+  Schema: ZodType,
+  ZodSchema: ZodType,
+  late,
+  get ZodFirstPartyTypeKind() {
+    return ZodFirstPartyTypeKind;
+  },
+  coerce,
+  any: anyType,
+  array: arrayType,
+  bigint: bigIntType,
+  boolean: booleanType,
+  date: dateType,
+  discriminatedUnion: discriminatedUnionType,
+  effect: effectsType,
+  "enum": enumType,
+  "function": functionType,
+  "instanceof": instanceOfType,
+  intersection: intersectionType,
+  lazy: lazyType,
+  literal: literalType,
+  map: mapType,
+  nan: nanType,
+  nativeEnum: nativeEnumType,
+  never: neverType,
+  "null": nullType,
+  nullable: nullableType,
+  number: numberType,
+  object: objectType,
+  oboolean,
+  onumber,
+  optional: optionalType,
+  ostring,
+  pipeline: pipelineType,
+  preprocess: preprocessType,
+  promise: promiseType,
+  record: recordType,
+  set: setType,
+  strictObject: strictObjectType,
+  string: stringType,
+  symbol: symbolType,
+  transformer: effectsType,
+  tuple: tupleType,
+  "undefined": undefinedType,
+  union: unionType,
+  unknown: unknownType,
+  "void": voidType,
+  NEVER,
+  ZodIssueCode,
+  quotelessJson,
+  ZodError
+});
+
+// ../core/js/dist/index.mjs
+var TRANSACTION_ID_FIELD = "_xact_id";
+var IS_MERGE_FIELD = "_is_merge";
+var MERGE_PATHS_FIELD = "_merge_paths";
+var AUDIT_SOURCE_FIELD = "_audit_source";
+var AUDIT_METADATA_FIELD = "_audit_metadata";
+var VALID_SOURCES = ["app", "api", "external"];
+var PARENT_ID_FIELD = "_parent_id";
+function mergeDicts(mergeInto, mergeFrom) {
+  for (const [k, mergeFromV] of Object.entries(mergeFrom)) {
+    const mergeIntoV = mergeInto[k];
+    if (mergeIntoV instanceof Object && !Array.isArray(mergeIntoV) && mergeFrom instanceof Object && !Array.isArray(mergeFromV)) {
+      mergeDicts(
+        mergeIntoV,
+        mergeFromV
+      );
+    } else {
+      mergeInto[k] = mergeFromV;
+    }
+  }
+  return mergeInto;
+}
+function constructJsonArray(items) {
+  return `[${items.join(",")}]`;
+}
+function mapAt(m, k) {
+  const ret = m.get(k);
+  if (ret === void 0) {
+    throw new Error(`Map does not contain key ${k}`);
+  }
+  return ret;
+}
+function depthFirstSearch(args) {
+  var _a2;
+  const { graph, firstVisitF, lastVisitF } = args;
+  for (const vs of graph.values()) {
+    for (const v of vs.values()) {
+      if (!graph.has(v)) {
+        throw new Error(`Outgoing vertex ${v} must be a key in the graph`);
+      }
+    }
+  }
+  const firstVisitedVertices = /* @__PURE__ */ new Set();
+  const visitationOrder = (_a2 = args.visitationOrder) != null ? _a2 : [...graph.keys()];
+  const events = visitationOrder.map((vertex) => ({ eventType: "first", vertex, extras: {} })).reverse();
+  while (events.length) {
+    const { eventType, vertex, extras } = events.pop();
+    if (eventType === "last") {
+      lastVisitF == null ? void 0 : lastVisitF(vertex);
+      continue;
+    }
+    if (firstVisitedVertices.has(vertex)) {
+      continue;
+    }
+    firstVisitedVertices.add(vertex);
+    firstVisitF == null ? void 0 : firstVisitF(vertex, { parentVertex: extras.parentVertex });
+    events.push({ eventType: "last", vertex, extras: {} });
+    mapAt(graph, vertex).forEach((child) => {
+      events.push({
+        eventType: "first",
+        vertex: child,
+        extras: { parentVertex: vertex }
+      });
+    });
+  }
+}
+function undirectedConnectedComponents(graph) {
+  const directedGraph = new Map(
+    [...graph.vertices].map((v) => [v, /* @__PURE__ */ new Set()])
+  );
+  for (const [i, j] of graph.edges) {
+    mapAt(directedGraph, i).add(j);
+    mapAt(directedGraph, j).add(i);
+  }
+  let labelCounter = 0;
+  const vertexLabels = /* @__PURE__ */ new Map();
+  const firstVisitF = (vertex, args) => {
+    const label = (args == null ? void 0 : args.parentVertex) !== void 0 ? mapAt(vertexLabels, args == null ? void 0 : args.parentVertex) : labelCounter++;
+    vertexLabels.set(vertex, label);
+  };
+  depthFirstSearch({ graph: directedGraph, firstVisitF });
+  const output = Array.from({ length: labelCounter }).map(() => []);
+  for (const [vertex, label] of vertexLabels.entries()) {
+    output[label].push(vertex);
+  }
+  return output;
+}
+function topologicalSort(graph, visitationOrder) {
+  const reverseOrdering = [];
+  const lastVisitF = (vertex) => {
+    reverseOrdering.push(vertex);
+  };
+  depthFirstSearch({ graph, lastVisitF, visitationOrder });
+  return reverseOrdering.reverse();
+}
+function generateMergedRowKey(row, useParentIdForId) {
+  return JSON.stringify(
+    [
+      "org_id",
+      "project_id",
+      "experiment_id",
+      "dataset_id",
+      "prompt_session_id",
+      "log_id",
+      (useParentIdForId != null ? useParentIdForId : false) ? PARENT_ID_FIELD : "id"
+    ].map((k) => row[k])
+  );
+}
+function mergeRowBatch(rows) {
+  for (const row of rows) {
+    if (row.id === void 0) {
+      throw new Error(
+        "Logged row is missing an id. This is an internal braintrust error. Please contact us at info@braintrustdata.com for help"
+      );
+    }
+  }
+  const rowGroups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = generateMergedRowKey(row);
+    const existingRow = rowGroups.get(key);
+    if (existingRow !== void 0 && row[IS_MERGE_FIELD]) {
+      const preserveNoMerge = !existingRow[IS_MERGE_FIELD];
+      mergeDicts(existingRow, row);
+      if (preserveNoMerge) {
+        delete existingRow[IS_MERGE_FIELD];
+      }
+    } else {
+      rowGroups.set(key, row);
+    }
+  }
+  const merged = [...rowGroups.values()];
+  const rowToLabel = new Map(
+    merged.map((r, i) => [generateMergedRowKey(r), i])
+  );
+  const graph = new Map(
+    Array.from({ length: merged.length }).map((_, i) => [i, /* @__PURE__ */ new Set()])
+  );
+  merged.forEach((r, i) => {
+    const parentId = r[PARENT_ID_FIELD];
+    if (!parentId) {
+      return;
+    }
+    const parentRowKey = generateMergedRowKey(
+      r,
+      true
+      /* useParentIdForId */
+    );
+    const parentLabel = rowToLabel.get(parentRowKey);
+    if (parentLabel !== void 0) {
+      mapAt(graph, parentLabel).add(i);
+    }
+  });
+  const connectedComponents = undirectedConnectedComponents({
+    vertices: new Set(graph.keys()),
+    edges: new Set(
+      [...graph.entries()].flatMap(
+        ([k, vs]) => [...vs].map((v) => {
+          const ret = [k, v];
+          return ret;
+        })
+      )
+    )
+  });
+  const buckets = connectedComponents.map(
+    (cc) => topologicalSort(
+      graph,
+      cc
+      /* visitationOrder */
+    )
+  );
+  return buckets.map((bucket) => bucket.map((i) => merged[i]));
+}
+function batchItems(args) {
+  var _a2, _b;
+  let { items } = args;
+  const batchMaxNumItems = (_a2 = args.batchMaxNumItems) != null ? _a2 : Number.POSITIVE_INFINITY;
+  const batchMaxNumBytes = (_b = args.batchMaxNumBytes) != null ? _b : Number.POSITIVE_INFINITY;
+  const output = [];
+  let nextItems = [];
+  let batchSet = [];
+  let batch = [];
+  let batchLen = 0;
+  function addToBatch(item) {
+    batch.push(item);
+    batchLen += item.length;
+  }
+  function flushBatch() {
+    batchSet.push(batch);
+    batch = [];
+    batchLen = 0;
+  }
+  while (items.length) {
+    for (const bucket of items) {
+      let i = 0;
+      for (const item of bucket) {
+        if (batch.length === 0 || item.length + batchLen < batchMaxNumBytes && batch.length < batchMaxNumItems) {
+          addToBatch(item);
+        } else if (i === 0) {
+          flushBatch();
+          addToBatch(item);
+        } else {
+          break;
+        }
+        ++i;
+      }
+      if (i < bucket.length) {
+        nextItems.push(bucket.slice(i));
+      }
+      if (batchLen >= batchMaxNumBytes || batch.length > batchMaxNumItems) {
+        flushBatch();
+      }
+    }
+    if (batch.length) {
+      flushBatch();
+    }
+    if (batchSet.length) {
+      output.push(batchSet);
+      batchSet = [];
+    }
+    items = nextItems;
+    nextItems = [];
+  }
+  return output;
+}
+var DEFAULT_IS_LEGACY_DATASET = true;
+function ensureDatasetRecord(r, legacy) {
+  if (legacy) {
+    return ensureLegacyDatasetRecord(r);
+  } else {
+    return ensureNewDatasetRecord(r);
+  }
+}
+function ensureLegacyDatasetRecord(r) {
+  if ("output" in r) {
+    return r;
+  }
+  const row = {
+    ...r,
+    output: r.expected
+  };
+  delete row.expected;
+  return row;
+}
+function ensureNewDatasetRecord(r) {
+  if ("expected" in r) {
+    return r;
+  }
+  const row = {
+    ...r,
+    tags: null,
+    expected: r.output
+  };
+  delete row.output;
+  return row;
+}
+function makeLegacyEvent(e) {
+  if (!("dataset_id" in e) || !("expected" in e)) {
+    return e;
+  }
+  const event = {
+    ...e,
+    output: e.expected
+  };
+  delete event.expected;
+  if (MERGE_PATHS_FIELD in event) {
+    for (const path of event[MERGE_PATHS_FIELD] || []) {
+      if (path.length > 0 && path[0] === "expected") {
+        path[0] = "output";
+      }
+    }
+  }
+  return event;
+}
+function tryMakeUuid(s) {
+  try {
+    const ret = parse_default(s);
+    if (ret.length !== 16) {
+      throw new Error();
+    }
+    return { bytes: Buffer.from(ret), isUUID: true };
+  } catch (e) {
+    return { bytes: Buffer.from(s, "utf-8"), isUUID: false };
+  }
+}
+var ENCODING_VERSION_NUMBER = 1;
+var INVALID_ENCODING_ERRMSG = "SpanComponents string is not properly encoded. This may be due to a version mismatch between the SDK library used to export the span and the library used to decode it. Please make sure you are using the same SDK version across the board";
+var SpanObjectType = /* @__PURE__ */ ((SpanObjectType2) => {
+  SpanObjectType2[SpanObjectType2["EXPERIMENT"] = 0] = "EXPERIMENT";
+  SpanObjectType2[SpanObjectType2["PROJECT_LOGS"] = 1] = "PROJECT_LOGS";
+  return SpanObjectType2;
+})(SpanObjectType || {});
+var SpanObjectTypeEnumSchema = z.nativeEnum(SpanObjectType);
+var SpanRowIds = class {
+  constructor(args) {
+    this.rowId = args.rowId;
+    this.spanId = args.spanId;
+    this.rootSpanId = args.rootSpanId;
+    if (!this.rowId) {
+      throw new Error("rowId must be nonempty string");
+    }
+    if (!this.spanId) {
+      throw new Error("spanId must be nonempty string");
+    }
+    if (!this.rootSpanId) {
+      throw new Error("rootSpanId must be nonempty string");
+    }
+  }
+  toObject() {
+    return {
+      rowId: this.rowId,
+      spanId: this.spanId,
+      rootSpanId: this.rootSpanId
+    };
+  }
+};
+var SpanComponents = class _SpanComponents {
+  constructor(args) {
+    this.objectType = args.objectType;
+    this.objectId = args.objectId;
+    this.rowIds = args.rowIds;
+  }
+  toStr() {
+    const allBuffers = [];
+    const { bytes: rowIdBytes, isUUID: rowIdIsUUID } = this.rowIds ? tryMakeUuid(this.rowIds.rowId) : { bytes: Buffer.from(""), isUUID: false };
+    allBuffers.push(
+      Buffer.from([
+        ENCODING_VERSION_NUMBER,
+        this.objectType,
+        this.rowIds ? 1 : 0,
+        rowIdIsUUID ? 1 : 0
+      ])
+    );
+    const { bytes: objectIdBytes, isUUID: objectIdIsUUID } = tryMakeUuid(
+      this.objectId
+    );
+    if (!objectIdIsUUID) {
+      throw new Error("object_id component must be a valid UUID");
+    }
+    allBuffers.push(objectIdBytes);
+    if (this.rowIds) {
+      const { bytes: spanIdBytes, isUUID: spanIdIsUUID } = tryMakeUuid(
+        this.rowIds.spanId
+      );
+      if (!spanIdIsUUID) {
+        throw new Error("span_id component must be a valid UUID");
+      }
+      const { bytes: rootSpanIdBytes, isUUID: rootSpanIdIsUUID } = tryMakeUuid(
+        this.rowIds.rootSpanId
+      );
+      if (!rootSpanIdIsUUID) {
+        throw new Error("root_span_id component must be a valid UUID");
+      }
+      allBuffers.push(spanIdBytes, rootSpanIdBytes, rowIdBytes);
+    }
+    return Buffer.concat(allBuffers).toString("base64");
+  }
+  static fromStr(s) {
+    try {
+      const rawBytes = Buffer.from(s, "base64");
+      if (rawBytes[0] !== ENCODING_VERSION_NUMBER) {
+        throw new Error();
+      }
+      const objectType2 = SpanObjectTypeEnumSchema.parse(rawBytes[1]);
+      if (![0, 1].includes(rawBytes[2])) {
+        throw new Error();
+      }
+      if (![0, 1].includes(rawBytes[3])) {
+        throw new Error();
+      }
+      const hasRowId = rawBytes[2] == 1;
+      const rowIdIsUUID = rawBytes[3] == 1;
+      const objectId = stringify_default(rawBytes.subarray(4, 20));
+      const rowIds = (() => {
+        if (!hasRowId) {
+          return void 0;
+        }
+        const spanId = stringify_default(rawBytes.subarray(20, 36));
+        const rootSpanId = stringify_default(rawBytes.subarray(36, 52));
+        const rowId = rowIdIsUUID ? stringify_default(rawBytes.subarray(52)) : rawBytes.subarray(52).toString("utf-8");
+        return new SpanRowIds({ rowId, spanId, rootSpanId });
+      })();
+      return new _SpanComponents({ objectType: objectType2, objectId, rowIds });
+    } catch (e) {
+      throw new Error(INVALID_ENCODING_ERRMSG);
+    }
+  }
+  objectIdFields() {
+    switch (this.objectType) {
+      case 0:
+        return { experiment_id: this.objectId };
+      case 1:
+        return { project_id: this.objectId, log_id: "g" };
+      default:
+        throw new Error("Impossible");
+    }
+  }
+  toObject() {
+    var _a2;
+    return {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      rowIds: (_a2 = this.rowIds) == null ? void 0 : _a2.toObject()
+    };
+  }
+};
+var SpanTypeAttribute = /* @__PURE__ */ ((SpanTypeAttribute2) => {
+  SpanTypeAttribute2["LLM"] = "llm";
+  SpanTypeAttribute2["SCORE"] = "score";
+  SpanTypeAttribute2["FUNCTION"] = "function";
+  SpanTypeAttribute2["EVAL"] = "eval";
+  SpanTypeAttribute2["TASK"] = "task";
+  SpanTypeAttribute2["TOOL"] = "tool";
+  return SpanTypeAttribute2;
+})(SpanTypeAttribute || {});
+function mergeGitMetadataSettings(s1, s2) {
+  var _a2;
+  if (s1.collect === "all") {
+    return s2;
+  } else if (s2.collect === "all") {
+    return s1;
+  } else if (s1.collect === "none") {
+    return s1;
+  } else if (s2.collect === "none") {
+    return s2;
+  }
+  const fields = ((_a2 = s1.fields) != null ? _a2 : []).filter((f) => {
+    var _a22;
+    return ((_a22 = s2.fields) != null ? _a22 : []).includes(f);
+  });
+  const collect = fields.length > 0 ? "some" : "none";
+  return { collect, fields };
+}
+var TOP_BITS = BigInt("0x0DE1") << BigInt(48);
+var MOD = BigInt(1) << BigInt(64);
+var COPRIME = BigInt("205891132094649");
+var COPRIME_INVERSE = BigInt("1522336535492693385");
 
 // ../core/js/typespecs/dist/index.mjs
+var import_zod_to_openapi = __toESM(require_dist(), 1);
 var import_zod_to_openapi2 = __toESM(require_dist(), 1);
 var import_zod_to_openapi3 = __toESM(require_dist(), 1);
 var literalSchema = z.union([
@@ -6999,7 +7091,7 @@ Writer.prototype.clearCache = function clearCache() {
     this.templateCache.clear();
   }
 };
-Writer.prototype.parse = function parse(template, tags) {
+Writer.prototype.parse = function parse2(template, tags) {
   var cache = this.templateCache;
   var cacheKey = template + ":" + (tags || mustache.tags).join(":");
   var isCacheEnabled = typeof cache !== "undefined";
@@ -7158,7 +7250,7 @@ var defaultWriter = new Writer();
 mustache.clearCache = function clearCache2() {
   return defaultWriter.clearCache();
 };
-mustache.parse = function parse2(template, tags) {
+mustache.parse = function parse3(template, tags) {
   return defaultWriter.parse(template, tags);
 };
 mustache.render = function render2(template, view, partials, config) {
@@ -7431,11 +7523,10 @@ function logFeedbackImpl(parentObjectType, parentObjectId, {
   updateEvent = Object.fromEntries(
     Object.entries(updateEvent).filter(([_, v]) => !isEmpty(v))
   );
-  const parentIds = async () => new SpanParentComponents({
+  const parentIds = async () => new SpanComponents({
     objectType: parentObjectType,
-    objectId: await parentObjectId.get(),
-    rowId: ""
-  }).asDict();
+    objectId: await parentObjectId.get()
+  }).objectIdFields();
   if (Object.keys(updateEvent).length > 0) {
     const record = new LazyValue(async () => {
       return {
@@ -7471,38 +7562,41 @@ function logFeedbackImpl(parentObjectType, parentObjectId, {
   }
 }
 function startSpanParentArgs(args) {
-  if (args.parent && args.parentId) {
-    throw new Error(
-      "Cannot specify both `parent` and `parentId`. Prefer `parent"
-    );
-  }
-  let parentObjectId = void 0;
-  let parentRowId = void 0;
+  let argParentObjectId = void 0;
+  let argParentSpanIds = void 0;
   if (args.parent) {
-    const parentComponents = SpanParentComponents.fromStr(args.parent);
-    if (args.spanParentObjectType !== parentComponents.objectType) {
+    if (args.parentSpanIds) {
+      throw new Error("Cannot specify both parent and parentSpanIds");
+    }
+    const parentComponents = SpanComponents.fromStr(args.parent);
+    if (args.parentObjectType !== parentComponents.objectType) {
       throw new Error(
-        `Mismatch between expected span parent object type ${args.spanParentObjectType} and provided type ${parentComponents.objectType}`
+        `Mismatch between expected span parent object type ${args.parentObjectType} and provided type ${parentComponents.objectType}`
       );
     }
     const computeParentObjectId = async () => {
-      if (await args.spanParentObjectId.get() !== parentComponents.objectId) {
+      if (await args.parentObjectId.get() !== parentComponents.objectId) {
         throw new Error(
-          `Mismatch between expected span parent object id ${await args.spanParentObjectId.get()} and provided id ${parentComponents.objectId}`
+          `Mismatch between expected span parent object id ${await args.parentObjectId.get()} and provided id ${parentComponents.objectId}`
         );
       }
-      return await args.spanParentObjectId.get();
+      return await args.parentObjectId.get();
     };
-    parentObjectId = new LazyValue(computeParentObjectId);
-    parentRowId = parentComponents.rowId;
+    argParentObjectId = new LazyValue(computeParentObjectId);
+    if (parentComponents.rowIds) {
+      argParentSpanIds = {
+        spanId: parentComponents.rowIds.spanId,
+        rootSpanId: parentComponents.rowIds.rootSpanId
+      };
+    }
   } else {
-    parentObjectId = args.spanParentObjectId;
-    parentRowId = args.parentId ?? "";
+    argParentObjectId = args.parentObjectId;
+    argParentSpanIds = args.parentSpanIds;
   }
   return {
-    parentObjectType: args.spanParentObjectType,
-    parentObjectId,
-    parentRowId
+    parentObjectType: args.parentObjectType,
+    parentObjectId: argParentObjectId,
+    parentSpanIds: argParentSpanIds
   };
 }
 var Logger = class {
@@ -7533,12 +7627,8 @@ var Logger = class {
   get id() {
     return (async () => (await this.project).id)();
   }
-  spanParentObjectType() {
-    return SpanParentObjectType.PROJECT_LOGS;
-  }
-  async getState() {
-    await this.lazyMetadata.get();
-    return _state;
+  parentObjectType() {
+    return SpanObjectType.PROJECT_LOGS;
   }
   /**
    * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
@@ -7616,9 +7706,9 @@ var Logger = class {
     return new SpanImpl({
       ...startSpanParentArgs({
         parent: args?.parent,
-        parentId: args?.parentId,
-        spanParentObjectType: this.spanParentObjectType(),
-        spanParentObjectId: this.lazyId
+        parentObjectType: this.parentObjectType(),
+        parentObjectId: this.lazyId,
+        parentSpanIds: void 0
       }),
       ...args,
       defaultRootType: SpanTypeAttribute.TASK
@@ -7636,16 +7726,15 @@ var Logger = class {
    * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
    */
   logFeedback(event) {
-    logFeedbackImpl(this.spanParentObjectType(), this.lazyId, event);
+    logFeedbackImpl(this.parentObjectType(), this.lazyId, event);
   }
   /**
    * Return a serialized representation of the logger that can be used to start subspans in other places. See `Span.start_span` for more details.
    */
   async export() {
-    return new SpanParentComponents({
-      objectType: this.spanParentObjectType(),
-      objectId: await this.id,
-      rowId: ""
+    return new SpanComponents({
+      objectType: this.parentObjectType(),
+      objectId: await this.id
     }).toStr();
   }
   /*
@@ -8355,21 +8444,20 @@ async function flush() {
 }
 function startSpanAndIsLogger(args) {
   if (args?.parent) {
-    if (args?.parentId) {
-      throw new Error(
-        "Cannot specify both `parent` and `parent_id`. Prefer `parent`"
-      );
-    }
-    const components = SpanParentComponents.fromStr(args?.parent);
+    const components = SpanComponents.fromStr(args?.parent);
+    const parentSpanIds = components.rowIds ? {
+      spanId: components.rowIds.spanId,
+      rootSpanId: components.rowIds.rootSpanId
+    } : void 0;
     const span = new SpanImpl({
       ...args,
       parentObjectType: components.objectType,
       parentObjectId: new LazyValue(async () => components.objectId),
-      parentRowId: components.rowId
+      parentSpanIds
     });
     return {
       span,
-      isLogger: components.objectType === SpanParentObjectType.PROJECT_LOGS
+      isLogger: components.objectType === SpanObjectType.PROJECT_LOGS
     };
   } else {
     const parentObject = getSpanParentObject({
@@ -8576,8 +8664,8 @@ var Experiment = class extends ObjectFetcher {
       return (await this.lazyMetadata.get()).project;
     })();
   }
-  spanParentObjectType() {
-    return SpanParentObjectType.EXPERIMENT;
+  parentObjectType() {
+    return SpanObjectType.EXPERIMENT;
   }
   async getState() {
     await this.lazyMetadata.get();
@@ -8645,9 +8733,9 @@ var Experiment = class extends ObjectFetcher {
     return new SpanImpl({
       ...startSpanParentArgs({
         parent: args?.parent,
-        parentId: args?.parentId,
-        spanParentObjectType: this.spanParentObjectType(),
-        spanParentObjectId: this.lazyId
+        parentObjectType: this.parentObjectType(),
+        parentObjectId: this.lazyId,
+        parentSpanIds: void 0
       }),
       ...args,
       defaultRootType: SpanTypeAttribute.EVAL
@@ -8737,16 +8825,15 @@ var Experiment = class extends ObjectFetcher {
    * @param event.source (Optional) the source of the feedback. Must be one of "external" (default), "app", or "api".
    */
   logFeedback(event) {
-    logFeedbackImpl(this.spanParentObjectType(), this.lazyId, event);
+    logFeedbackImpl(this.parentObjectType(), this.lazyId, event);
   }
   /**
    * Return a serialized representation of the experiment that can be used to start subspans in other places. See `Span.start_span` for more details.
    */
   async export() {
-    return new SpanParentComponents({
-      objectType: this.spanParentObjectType(),
-      objectId: await this.id,
-      rowId: ""
+    return new SpanComponents({
+      objectType: this.parentObjectType(),
+      objectId: await this.id
     }).toStr();
   }
   /**
@@ -8817,22 +8904,23 @@ var SpanImpl = class _SpanImpl {
   // For internal use only.
   parentObjectType;
   parentObjectId;
-  parentRowId;
   _id;
+  spanId;
+  rootSpanId;
+  spanParents;
   kind = "span";
   constructor(args) {
     const spanAttributes = args.spanAttributes ?? {};
     const event = args.event ?? {};
-    const type = args.type ?? (args.parentRowId ? void 0 : args.defaultRootType);
+    const type = args.type ?? (args.parentSpanIds ? void 0 : args.defaultRootType);
     this.loggedEndTime = void 0;
     this.parentObjectType = args.parentObjectType;
     this.parentObjectId = args.parentObjectId;
-    this.parentRowId = args.parentRowId;
     const callerLocation = isomorph_default.getCallerLocation();
     const name = (() => {
       if (args.name)
         return args.name;
-      if (!args.parentRowId)
+      if (!args.parentSpanIds)
         return "root";
       if (callerLocation) {
         const pathComponents = callerLocation.caller_filename.split("/");
@@ -8857,6 +8945,14 @@ var SpanImpl = class _SpanImpl {
       created: (/* @__PURE__ */ new Date()).toISOString()
     };
     this._id = event.id ?? v4_default();
+    this.spanId = v4_default();
+    if (args.parentSpanIds) {
+      this.rootSpanId = args.parentSpanIds.rootSpanId;
+      this.spanParents = [args.parentSpanIds.spanId];
+    } else {
+      this.rootSpanId = this.spanId;
+      this.spanParents = void 0;
+    }
     this.isMerge = false;
     const { id: _id, ...eventRest } = event;
     this.log(eventRest);
@@ -8871,6 +8967,10 @@ var SpanImpl = class _SpanImpl {
     mergeDicts(sanitizedAndInternalData, sanitized);
     this.internalData = {};
     let partialRecord = {
+      id: this.id,
+      span_id: this.spanId,
+      root_span_id: this.rootSpanId,
+      span_parents: this.spanParents,
       ...sanitizedAndInternalData,
       [IS_MERGE_FIELD]: this.isMerge
     };
@@ -8879,17 +8979,15 @@ var SpanImpl = class _SpanImpl {
     if (partialRecord.metrics?.end) {
       this.loggedEndTime = partialRecord.metrics?.end;
     }
-    if ((partialRecord.tags ?? []).length > 0 && this.parentRowId) {
+    if ((partialRecord.tags ?? []).length > 0 && this.spanParents?.length) {
       throw new Error("Tags can only be logged to the root span");
     }
     const computeRecord = async () => ({
       ...partialRecord,
-      ...new SpanParentComponents({
+      ...new SpanComponents({
         objectType: this.parentObjectType,
-        objectId: await this.parentObjectId.get(),
-        rowId: this.parentRowId
-      }).asDict(),
-      id: this.id
+        objectId: await this.parentObjectId.get()
+      }).objectIdFields()
     });
     _state.globalBgLogger().log([new LazyValue(computeRecord)]);
   }
@@ -8914,13 +9012,14 @@ var SpanImpl = class _SpanImpl {
     );
   }
   startSpan(args) {
+    const parentSpanIds = args?.parent ? void 0 : { spanId: this.spanId, rootSpanId: this.rootSpanId };
     return new _SpanImpl({
       ...args,
       ...startSpanParentArgs({
         parent: args?.parent,
-        parentId: args?.parentId ?? (args?.parent ? void 0 : this.id),
-        spanParentObjectType: this.parentObjectType,
-        spanParentObjectId: this.parentObjectId
+        parentObjectType: this.parentObjectType,
+        parentObjectId: this.parentObjectId,
+        parentSpanIds
       })
     });
   }
@@ -8936,10 +9035,14 @@ var SpanImpl = class _SpanImpl {
     return endTime;
   }
   async export() {
-    return new SpanParentComponents({
+    return new SpanComponents({
       objectType: this.parentObjectType,
       objectId: await this.parentObjectId.get(),
-      rowId: this.id
+      rowIds: new SpanRowIds({
+        rowId: this.id,
+        spanId: this.spanId,
+        rootSpanId: this.rootSpanId
+      })
     }).toStr();
   }
   async flush() {
@@ -8964,9 +9067,6 @@ var Dataset = class extends ObjectFetcher {
       (r) => ensureDatasetRecord(r, isLegacyDataset)
     );
     this.lazyMetadata = lazyMetadata;
-    const logConn = new LazyValue(
-      () => this.getState().then((state) => state.logConn())
-    );
   }
   get id() {
     return (async () => {