braintrust 0.3.7 → 0.4.0

package/util/dist/index.mjs

@@ -609,22 +609,6 @@ var SpanComponentsV3 = class _SpanComponentsV3 {
     return new _SpanComponentsV3(spanComponentsV3Schema.parse(jsonObj));
   }
 };
-function parseParent(parent) {
-  return typeof parent === "string" ? parent : parent ? new SpanComponentsV3({
-    object_type: parent.object_type === "experiment" ? 1 /* EXPERIMENT */ : parent.object_type === "playground_logs" ? 3 /* PLAYGROUND_LOGS */ : 2 /* PROJECT_LOGS */,
-    object_id: parent.object_id,
-    ...parent.row_ids ? {
-      row_id: parent.row_ids.id,
-      span_id: parent.row_ids.span_id,
-      root_span_id: parent.row_ids.root_span_id
-    } : {
-      row_id: void 0,
-      span_id: void 0,
-      root_span_id: void 0
-    },
-    propagated_event: parent.propagated_event
-  }).toStr() : void 0;
-}
 
 // util/http_headers.ts
 var BT_FOUND_EXISTING_HEADER = "x-bt-found-existing";
@@ -1097,6 +1081,232 @@ function camelToSnakeCase(s) {
   return s.replace(/([A-Z])/g, (m) => "_" + m.toLowerCase()).replace(/^_/, "");
 }
 
+// util/span_identifier_v4.ts
+import { z as z4 } from "zod/v3";
+var ENCODING_VERSION_NUMBER_V4 = 4;
+function tryMakeHexTraceId(s) {
+  try {
+    if (typeof s === "string" && s.length === 32) {
+      const bytes = new Uint8Array(16);
+      for (let i = 0; i < 16; i++) {
+        const hex = s.substr(i * 2, 2);
+        const byte = parseInt(hex, 16);
+        if (isNaN(byte)) throw new Error();
+        bytes[i] = byte;
+      }
+      return { bytes, isHex: true };
+    }
+  } catch {
+  }
+  return { bytes: void 0, isHex: false };
+}
+function tryMakeHexSpanId(s) {
+  try {
+    if (typeof s === "string" && s.length === 16) {
+      const bytes = new Uint8Array(8);
+      for (let i = 0; i < 8; i++) {
+        const hex = s.substr(i * 2, 2);
+        const byte = parseInt(hex, 16);
+        if (isNaN(byte)) throw new Error();
+        bytes[i] = byte;
+      }
+      return { bytes, isHex: true };
+    }
+  } catch {
+  }
+  return { bytes: void 0, isHex: false };
+}
+var INVALID_ENCODING_ERRMSG_V4 = `SpanComponents string is not properly encoded. This library only supports encoding versions up to ${ENCODING_VERSION_NUMBER_V4}. Please make sure the SDK library used to decode the SpanComponents is at least as new as any library used to encode it.`;
+var FIELDS_ID_TO_NAME = {
+  [1 /* OBJECT_ID */]: "object_id",
+  [2 /* ROW_ID */]: "row_id",
+  [3 /* SPAN_ID */]: "span_id",
+  [4 /* ROOT_SPAN_ID */]: "root_span_id"
+};
+var spanComponentsV4Schema = z4.object({
+  object_type: spanObjectTypeV3EnumSchema,
+  propagated_event: z4.record(z4.unknown()).nullish()
+}).and(
+  z4.union([
+    // Must provide one or the other.
+    z4.object({
+      object_id: z4.string().nullish(),
+      compute_object_metadata_args: z4.optional(z4.null())
+    }),
+    z4.object({
+      object_id: z4.optional(z4.null()),
+      compute_object_metadata_args: z4.record(z4.unknown())
+    })
+  ])
+).and(
+  z4.union([
+    // Either all of these must be provided or none.
+    z4.object({
+      row_id: z4.string(),
+      span_id: z4.string(),
+      root_span_id: z4.string()
+    }),
+    z4.object({
+      row_id: z4.optional(z4.null()),
+      span_id: z4.optional(z4.null()),
+      root_span_id: z4.optional(z4.null())
+    })
+  ])
+);
+var SpanComponentsV4 = class _SpanComponentsV4 {
+  constructor(data) {
+    this.data = data;
+  }
+  toStr() {
+    const jsonObj = {
+      compute_object_metadata_args: this.data.compute_object_metadata_args || void 0,
+      propagated_event: this.data.propagated_event || void 0
+    };
+    Object.keys(jsonObj).forEach((key) => {
+      if (jsonObj[key] === void 0) {
+        delete jsonObj[key];
+      }
+    });
+    const allBuffers = [];
+    allBuffers.push(
+      new Uint8Array([ENCODING_VERSION_NUMBER_V4, this.data.object_type])
+    );
+    const hexEntries = [];
+    function addHexField(origVal, fieldId) {
+      let hexResult;
+      if (fieldId === 3 /* SPAN_ID */) {
+        hexResult = tryMakeHexSpanId(origVal);
+      } else if (fieldId === 4 /* ROOT_SPAN_ID */) {
+        hexResult = tryMakeHexTraceId(origVal);
+      } else {
+        hexResult = { bytes: void 0, isHex: false };
+      }
+      if (hexResult.isHex) {
+        hexEntries.push(
+          concatUint8Arrays(new Uint8Array([fieldId]), hexResult.bytes)
+        );
+      } else {
+        jsonObj[FIELDS_ID_TO_NAME[fieldId]] = origVal;
+      }
+    }
+    if (this.data.object_id) {
+      addHexField(this.data.object_id, 1 /* OBJECT_ID */);
+    }
+    if (this.data.row_id) {
+      addHexField(this.data.row_id, 2 /* ROW_ID */);
+    }
+    if (this.data.span_id) {
+      addHexField(this.data.span_id, 3 /* SPAN_ID */);
+    }
+    if (this.data.root_span_id) {
+      addHexField(this.data.root_span_id, 4 /* ROOT_SPAN_ID */);
+    }
+    if (hexEntries.length > 255) {
+      throw new Error("Impossible: too many hex entries to encode");
+    }
+    allBuffers.push(new Uint8Array([hexEntries.length]));
+    allBuffers.push(...hexEntries);
+    if (Object.keys(jsonObj).length > 0) {
+      allBuffers.push(stringToUint8Array(JSON.stringify(jsonObj)));
+    }
+    return uint8ArrayToBase64(concatUint8Arrays(...allBuffers));
+  }
+  static fromStr(s) {
+    try {
+      const rawBytes = base64ToUint8Array(s);
+      const jsonObj = {};
+      if (rawBytes[0] < ENCODING_VERSION_NUMBER_V4) {
+        const v3Components = SpanComponentsV3.fromStr(s);
+        jsonObj["object_type"] = v3Components.data.object_type;
+        jsonObj["object_id"] = v3Components.data.object_id;
+        jsonObj["compute_object_metadata_args"] = v3Components.data.compute_object_metadata_args;
+        jsonObj["row_id"] = v3Components.data.row_id;
+        jsonObj["span_id"] = v3Components.data.span_id;
+        jsonObj["root_span_id"] = v3Components.data.root_span_id;
+        jsonObj["propagated_event"] = v3Components.data.propagated_event;
+      } else {
+        jsonObj["object_type"] = rawBytes[1];
+        const numHexEntries = rawBytes[2];
+        let byteOffset = 3;
+        for (let i = 0; i < numHexEntries; i++) {
+          const fieldId = rawBytes[byteOffset];
+          if (fieldId === 3 /* SPAN_ID */) {
+            const hexBytes = rawBytes.subarray(byteOffset + 1, byteOffset + 9);
+            byteOffset += 9;
+            jsonObj[FIELDS_ID_TO_NAME[fieldId]] = Array.from(
+              hexBytes,
+              (b) => b.toString(16).padStart(2, "0")
+            ).join("");
+          } else if (fieldId === 4 /* ROOT_SPAN_ID */) {
+            const hexBytes = rawBytes.subarray(byteOffset + 1, byteOffset + 17);
+            byteOffset += 17;
+            jsonObj[FIELDS_ID_TO_NAME[fieldId]] = Array.from(
+              hexBytes,
+              (b) => b.toString(16).padStart(2, "0")
+            ).join("");
+          } else {
+            const hexBytes = rawBytes.subarray(byteOffset + 1, byteOffset + 17);
+            byteOffset += 17;
+            jsonObj[FIELDS_ID_TO_NAME[fieldId]] = Array.from(
+              hexBytes,
+              (b) => b.toString(16).padStart(2, "0")
+            ).join("");
+          }
+        }
+        if (byteOffset < rawBytes.length) {
+          const remainingJsonObj = JSON.parse(
+            uint8ArrayToString(rawBytes.subarray(byteOffset))
+          );
+          Object.assign(jsonObj, remainingJsonObj);
+        }
+      }
+      return _SpanComponentsV4.fromJsonObj(jsonObj);
+    } catch {
+      throw new Error(INVALID_ENCODING_ERRMSG_V4);
+    }
+  }
+  objectIdFields() {
+    if (!this.data.object_id) {
+      throw new Error(
+        "Impossible: cannot invoke `objectIdFields` unless SpanComponentsV4 is initialized with an `object_id`"
+      );
+    }
+    switch (this.data.object_type) {
+      case 1 /* EXPERIMENT */:
+        return { experiment_id: this.data.object_id };
+      case 2 /* PROJECT_LOGS */:
+        return { project_id: this.data.object_id, log_id: "g" };
+      case 3 /* PLAYGROUND_LOGS */:
+        return { prompt_session_id: this.data.object_id, log_id: "x" };
+      default:
+        const _ = this.data.object_type;
+        throw new Error(`Invalid object_type ${this.data.object_type}`);
+    }
+  }
+  async export() {
+    return this.toStr();
+  }
+  static fromJsonObj(jsonObj) {
+    return new _SpanComponentsV4(spanComponentsV4Schema.parse(jsonObj));
+  }
+};
+function parseParent(parent) {
+  return typeof parent === "string" ? parent : parent ? new SpanComponentsV4({
+    object_type: parent.object_type === "experiment" ? 1 /* EXPERIMENT */ : parent.object_type === "playground_logs" ? 3 /* PLAYGROUND_LOGS */ : 2 /* PROJECT_LOGS */,
+    object_id: parent.object_id,
+    ...parent.row_ids ? {
+      row_id: parent.row_ids.id,
+      span_id: parent.row_ids.span_id,
+      root_span_id: parent.row_ids.root_span_id
+    } : {
+      row_id: void 0,
+      span_id: void 0,
+      root_span_id: void 0
+    },
+    propagated_event: parent.propagated_event
+  }).toStr() : void 0;
+}
+
 // util/span_types.ts
 var spanTypeAttributeValues = [
   "llm",
@@ -1157,7 +1367,7 @@ function loadPrettyXact(encodedHex) {
 }
 
 // util/zod_util.ts
-import { z as z4 } from "zod/v3";
+import { z as z5 } from "zod/v3";
 var ExtraFieldsError = class extends Error {
   constructor(key, path) {
     super(
@@ -1179,7 +1389,7 @@ function parseNoStrip(schema, input) {
   return output;
 }
 function objectNullish(object) {
-  return new z4.ZodObject({
+  return new z5.ZodObject({
     ...object._def,
     shape: () => Object.fromEntries(
       Object.entries(object.shape).map(([k, v]) => [k, v.nullish()])
@@ -1206,6 +1416,7 @@ export {
   SpanComponentsV1,
   SpanComponentsV2,
   SpanComponentsV3,
+  SpanComponentsV4,
   SpanObjectTypeV1,
   SpanObjectTypeV2,
   SpanObjectTypeV3,
@@ -1254,6 +1465,7 @@ export {
   snakeToCamelCase,
   snakeToTitleCase,
   spanComponentsV3Schema,
+  spanComponentsV4Schema,
   spanObjectTypeV3EnumSchema,
   spanObjectTypeV3ToString,
   spanPurposeAttributeValues,