braintrust 0.0.132 → 0.0.133

package/dist/browser.js

@@ -5458,16 +5458,148 @@ function tryMakeUuid(s) {
     return { bytes: Buffer.from(s, "utf-8"), isUUID: false };
   }
 }
-var ENCODING_VERSION_NUMBER = 2;
+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 SpanObjectTypeV1 = /* @__PURE__ */ ((SpanObjectTypeV12) => {
+  SpanObjectTypeV12[SpanObjectTypeV12["EXPERIMENT"] = 0] = "EXPERIMENT";
+  SpanObjectTypeV12[SpanObjectTypeV12["PROJECT_LOGS"] = 1] = "PROJECT_LOGS";
+  return SpanObjectTypeV12;
+})(SpanObjectTypeV1 || {});
+var SpanObjectTypeV1EnumSchema = z.nativeEnum(SpanObjectTypeV1);
+var SpanRowIdsV1 = 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 SpanComponentsV1 = class _SpanComponentsV1 {
+  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 = SpanObjectTypeV1EnumSchema.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 SpanRowIdsV1({ rowId, spanId, rootSpanId });
+      })();
+      return new _SpanComponentsV1({ 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()
+    };
+  }
+};
+function tryMakeUuid2(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_NUMBER2 = 2;
+var INVALID_ENCODING_ERRMSG2 = `SpanComponents string is not properly encoded. This library only supports encoding versions up to ${ENCODING_VERSION_NUMBER2}. Please make sure the SDK library used to decode the SpanComponents is at least as new as any library used to encode it.`;
 var INTEGER_ENCODING_NUM_BYTES = 4;
-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 {
+var SpanObjectTypeV2 = /* @__PURE__ */ ((SpanObjectTypeV22) => {
+  SpanObjectTypeV22[SpanObjectTypeV22["EXPERIMENT"] = 0] = "EXPERIMENT";
+  SpanObjectTypeV22[SpanObjectTypeV22["PROJECT_LOGS"] = 1] = "PROJECT_LOGS";
+  return SpanObjectTypeV22;
+})(SpanObjectTypeV2 || {});
+var SpanObjectTypeV2EnumSchema = z.nativeEnum(SpanObjectTypeV2);
+var SpanRowIdsV2 = class {
   constructor(args) {
     this.rowId = args.rowId;
     this.spanId = args.spanId;
@@ -5490,7 +5622,7 @@ var SpanRowIds = class {
     };
   }
 };
-var SpanComponents = class _SpanComponents {
+var SpanComponentsV2 = class _SpanComponentsV2 {
   constructor(args) {
     this.objectType = args.objectType;
     this.objectId = args.objectId;
@@ -5504,10 +5636,10 @@ var SpanComponents = class _SpanComponents {
   }
   toStr() {
     const allBuffers = [];
-    const { bytes: rowIdBytes, isUUID: rowIdIsUUID } = this.rowIds ? tryMakeUuid(this.rowIds.rowId) : { bytes: Buffer.from(""), isUUID: false };
+    const { bytes: rowIdBytes, isUUID: rowIdIsUUID } = this.rowIds ? tryMakeUuid2(this.rowIds.rowId) : { bytes: Buffer.from(""), isUUID: false };
     allBuffers.push(
       Buffer.from([
-        ENCODING_VERSION_NUMBER,
+        ENCODING_VERSION_NUMBER2,
         this.objectType,
         this.objectId ? 1 : 0,
         this.computeObjectMetadataArgs ? 1 : 0,
@@ -5516,7 +5648,7 @@ var SpanComponents = class _SpanComponents {
       ])
     );
     if (this.objectId) {
-      const { bytes: objectIdBytes, isUUID: objectIdIsUUID } = tryMakeUuid(
+      const { bytes: objectIdBytes, isUUID: objectIdIsUUID } = tryMakeUuid2(
         this.objectId
       );
       if (!objectIdIsUUID) {
@@ -5534,13 +5666,13 @@ var SpanComponents = class _SpanComponents {
       allBuffers.push(serializedLenBytes, computeObjectMetadataBytes);
     }
     if (this.rowIds) {
-      const { bytes: spanIdBytes, isUUID: spanIdIsUUID } = tryMakeUuid(
+      const { bytes: spanIdBytes, isUUID: spanIdIsUUID } = tryMakeUuid2(
         this.rowIds.spanId
       );
       if (!spanIdIsUUID) {
         throw new Error("span_id component must be a valid UUID");
       }
-      const { bytes: rootSpanIdBytes, isUUID: rootSpanIdIsUUID } = tryMakeUuid(
+      const { bytes: rootSpanIdBytes, isUUID: rootSpanIdIsUUID } = tryMakeUuid2(
         this.rowIds.rootSpanId
       );
       if (!rootSpanIdIsUUID) {
@@ -5553,10 +5685,24 @@ var SpanComponents = class _SpanComponents {
   static fromStr(s) {
     try {
       const rawBytes = Buffer.from(s, "base64");
-      if (rawBytes[0] !== ENCODING_VERSION_NUMBER) {
+      if (rawBytes[0] < ENCODING_VERSION_NUMBER2) {
+        const spanComponentsOld = SpanComponentsV1.fromStr(s);
+        return new _SpanComponentsV2({
+          objectType: SpanObjectTypeV2EnumSchema.parse(
+            spanComponentsOld.objectType
+          ),
+          objectId: spanComponentsOld.objectId,
+          rowIds: spanComponentsOld.rowIds ? new SpanRowIdsV2({
+            rowId: spanComponentsOld.rowIds.rowId,
+            spanId: spanComponentsOld.rowIds.spanId,
+            rootSpanId: spanComponentsOld.rowIds.rootSpanId
+          }) : void 0
+        });
+      }
+      if (rawBytes[0] !== ENCODING_VERSION_NUMBER2) {
         throw new Error();
       }
-      const objectType2 = SpanObjectTypeEnumSchema.parse(rawBytes[1]);
+      const objectType2 = SpanObjectTypeV2EnumSchema.parse(rawBytes[1]);
       for (let i = 2; i < 6; ++i) {
         if (![0, 1].includes(rawBytes[i])) {
           throw new Error();
@@ -5601,22 +5747,22 @@ var SpanComponents = class _SpanComponents {
         );
         byteCursor = nextByteCursor;
         const rowId = rowIdIsUUID ? stringify_default(rawBytes.subarray(byteCursor)) : rawBytes.subarray(byteCursor).toString("utf-8");
-        return new SpanRowIds({ rowId, spanId, rootSpanId });
+        return new SpanRowIdsV2({ rowId, spanId, rootSpanId });
       })();
-      return new _SpanComponents({
+      return new _SpanComponentsV2({
         objectType: objectType2,
         objectId,
         computeObjectMetadataArgs,
         rowIds
       });
     } catch (e) {
-      throw new Error(INVALID_ENCODING_ERRMSG);
+      throw new Error(INVALID_ENCODING_ERRMSG2);
     }
   }
   objectIdFields() {
     if (!this.objectId) {
       throw new Error(
-        "Impossible: cannot invoke `object_id_fields` unless SpanComponents is initialized with an `object_id`"
+        "Impossible: cannot invoke `object_id_fields` unless SpanComponentsV2 is initialized with an `object_id`"
       );
     }
     switch (this.objectType) {
@@ -5969,7 +6115,6 @@ var apiKeyBaseSchema = generateBaseTableSchema("api key");
 var apiKeySchema = z.strictObject({
   id: apiKeyBaseSchema.shape.id,
   created: apiKeyBaseSchema.shape.created,
-  key_hash: z.string(),
   name: apiKeyBaseSchema.shape.name,
   preview_name: z.string(),
   user_id: userSchema.shape.id.nullish(),
@@ -6195,7 +6340,11 @@ var projectScoreSchema = z.strictObject({
     z.array(z.string()).describe(
       "For minimum-type project scores, the list of included scores"
     )
-  ]).nullish()
+  ]).nullish(),
+  config: z.strictObject({
+    multi_select: z.boolean().nullish(),
+    destination: z.literal("expected").nullish()
+  }).nullish()
 }).describe(
   "A project score is a user-configured score, which can be manually-labeled through the UI"
 ).openapi("ProjectScore");
@@ -7722,7 +7871,7 @@ function logFeedbackImpl(parentObjectType, parentObjectId, {
   updateEvent = Object.fromEntries(
     Object.entries(updateEvent).filter(([_, v]) => !isEmpty(v))
   );
-  const parentIds = async () => new SpanComponents({
+  const parentIds = async () => new SpanComponentsV2({
     objectType: parentObjectType,
     objectId: await parentObjectId.get()
   }).objectIdFields();
@@ -7771,11 +7920,11 @@ function spanComponentsToObjectIdLambda(components) {
     );
   }
   switch (components.objectType) {
-    case SpanObjectType.EXPERIMENT:
+    case SpanObjectTypeV2.EXPERIMENT:
       throw new Error(
         "Impossible: computeObjectMetadataArgs not supported for experiments"
       );
-    case SpanObjectType.PROJECT_LOGS:
+    case SpanObjectTypeV2.PROJECT_LOGS:
       const args = components.computeObjectMetadataArgs;
       return async () => (await computeLoggerMetadata(args)).project.id;
     default:
@@ -7790,7 +7939,7 @@ function startSpanParentArgs(args) {
     if (args.parentSpanIds) {
       throw new Error("Cannot specify both parent and parentSpanIds");
     }
-    const parentComponents = SpanComponents.fromStr(args.parent);
+    const parentComponents = SpanComponentsV2.fromStr(args.parent);
     if (args.parentObjectType !== parentComponents.objectType) {
       throw new Error(
         `Mismatch between expected span parent object type ${args.parentObjectType} and provided type ${parentComponents.objectType}`
@@ -7855,7 +8004,7 @@ var Logger = class {
     return (async () => (await this.project).id)();
   }
   parentObjectType() {
-    return SpanObjectType.PROJECT_LOGS;
+    return SpanObjectTypeV2.PROJECT_LOGS;
   }
   /**
    * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
@@ -7967,7 +8116,7 @@ var Logger = class {
     } else {
       objectId = await this.lazyId.get();
     }
-    return new SpanComponents({
+    return new SpanComponentsV2({
       objectType: this.parentObjectType(),
       objectId,
       computeObjectMetadataArgs
@@ -8821,7 +8970,7 @@ async function flush() {
 }
 function startSpanAndIsLogger(args) {
   if (args?.parent) {
-    const components = SpanComponents.fromStr(args?.parent);
+    const components = SpanComponentsV2.fromStr(args?.parent);
     const parentSpanIds = components.rowIds ? {
       spanId: components.rowIds.spanId,
       rootSpanId: components.rowIds.rootSpanId
@@ -8835,7 +8984,7 @@ function startSpanAndIsLogger(args) {
     });
     return {
       span,
-      isLogger: components.objectType === SpanObjectType.PROJECT_LOGS
+      isLogger: components.objectType === SpanObjectTypeV2.PROJECT_LOGS
     };
   } else {
     const parentObject = getSpanParentObject({
@@ -9046,7 +9195,7 @@ var Experiment = class extends ObjectFetcher {
     })();
   }
   parentObjectType() {
-    return SpanObjectType.EXPERIMENT;
+    return SpanObjectTypeV2.EXPERIMENT;
   }
   async getState() {
     await this.lazyMetadata.get();
@@ -9212,7 +9361,7 @@ var Experiment = class extends ObjectFetcher {
    * 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 SpanComponents({
+    return new SpanComponentsV2({
       objectType: this.parentObjectType(),
       objectId: await this.id
     }).toStr();
@@ -9367,7 +9516,7 @@ var SpanImpl = class _SpanImpl {
     }
     const computeRecord = async () => ({
       ...partialRecord,
-      ...new SpanComponents({
+      ...new SpanComponentsV2({
         objectType: this.parentObjectType,
         objectId: await this.parentObjectId.get()
       }).objectIdFields()
@@ -9426,11 +9575,11 @@ var SpanImpl = class _SpanImpl {
     } else {
       objectId = await this.parentObjectId.get();
     }
-    return new SpanComponents({
+    return new SpanComponentsV2({
       objectType: this.parentObjectType,
       objectId,
       computeObjectMetadataArgs,
-      rowIds: new SpanRowIds({
+      rowIds: new SpanRowIdsV2({
         rowId: this.id,
         spanId: this.spanId,
         rootSpanId: this.rootSpanId