braintrust 0.2.6 → 0.3.7

package/dist/index.mjs

@@ -481,15 +481,15 @@ function mergeTwoObjects(one, two, level = 0, objects) {
       for (let i = 0, j = two.length; i < j; i++) {
         result.push(takeValue(two[i]));
       }
-    } else if (isObject3(two)) {
+    } else if (isObject2(two)) {
       const keys = Object.keys(two);
       for (let i = 0, j = keys.length; i < j; i++) {
         const key = keys[i];
         result[key] = takeValue(two[key]);
       }
     }
-  } else if (isObject3(one)) {
-    if (isObject3(two)) {
+  } else if (isObject2(one)) {
+    if (isObject2(two)) {
       if (!shouldMerge(one, two)) {
         return two;
       }
@@ -510,7 +510,7 @@ function mergeTwoObjects(one, two, level = 0, objects) {
           if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
             delete result[key];
           } else {
-            if (isObject3(obj1) && isObject3(obj2)) {
+            if (isObject2(obj1) && isObject2(obj2)) {
               const arr1 = objects.get(obj1) || [];
               const arr2 = objects.get(obj2) || [];
               arr1.push({ obj: one, key });
@@ -544,7 +544,7 @@ function isArray2(value) {
 function isFunction(value) {
   return typeof value === "function";
 }
-function isObject3(value) {
+function isObject2(value) {
   return !isPrimitive(value) && !isArray2(value) && !isFunction(value) && typeof value === "object";
 }
 function isPrimitive(value) {
@@ -3498,33 +3498,999 @@ var Queue = class {
   }
 };
 
-// src/logger.ts
-import {
-  _urljoin,
-  AUDIT_METADATA_FIELD,
-  AUDIT_SOURCE_FIELD,
-  batchItems,
-  constructJsonArray,
-  DEFAULT_IS_LEGACY_DATASET,
-  ensureDatasetRecord,
-  IS_MERGE_FIELD,
-  mergeDicts,
-  mergeGitMetadataSettings,
-  mergeRowBatch,
-  SpanComponentsV3,
-  SpanObjectTypeV3,
-  spanObjectTypeV3ToString,
-  SpanTypeAttribute,
-  TRANSACTION_ID_FIELD,
-  VALID_SOURCES,
-  isArray,
-  isObject
-} from "@braintrust/core";
+// util/db_fields.ts
+var TRANSACTION_ID_FIELD = "_xact_id";
+var IS_MERGE_FIELD = "_is_merge";
+var AUDIT_SOURCE_FIELD = "_audit_source";
+var AUDIT_METADATA_FIELD = "_audit_metadata";
+var VALID_SOURCES = ["app", "api", "external"];
+var PARENT_ID_FIELD = "_parent_id";
+
+// util/span_identifier_v3.ts
+import * as uuid3 from "uuid";
+
+// util/span_identifier_v2.ts
+import * as uuid2 from "uuid";
+
+// util/span_identifier_v1.ts
+import * as uuid from "uuid";
+import { z } from "zod/v3";
+function tryMakeUuid(s) {
+  try {
+    const ret = uuid.parse(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 SpanObjectTypeV1 = /* @__PURE__ */ ((SpanObjectTypeV12) => {
+  SpanObjectTypeV12[SpanObjectTypeV12["EXPERIMENT"] = 1] = "EXPERIMENT";
+  SpanObjectTypeV12[SpanObjectTypeV12["PROJECT_LOGS"] = 2] = "PROJECT_LOGS";
+  return SpanObjectTypeV12;
+})(SpanObjectTypeV1 || {});
+var SpanObjectTypeV1EnumSchema = z.nativeEnum(SpanObjectTypeV1);
+var SpanRowIdsV1 = class {
+  rowId;
+  spanId;
+  rootSpanId;
+  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 {
+  objectType;
+  objectId;
+  rowIds;
+  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 objectType = 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 = uuid.stringify(rawBytes.subarray(4, 20));
+      const rowIds = (() => {
+        if (!hasRowId) {
+          return void 0;
+        }
+        const spanId = uuid.stringify(rawBytes.subarray(20, 36));
+        const rootSpanId = uuid.stringify(rawBytes.subarray(36, 52));
+        const rowId = rowIdIsUUID ? uuid.stringify(rawBytes.subarray(52)) : rawBytes.subarray(52).toString("utf-8");
+        return new SpanRowIdsV1({ rowId, spanId, rootSpanId });
+      })();
+      return new _SpanComponentsV1({ objectType, objectId, rowIds });
+    } catch (e) {
+      throw new Error(INVALID_ENCODING_ERRMSG);
+    }
+  }
+  objectIdFields() {
+    switch (this.objectType) {
+      case 1 /* EXPERIMENT */:
+        return { experiment_id: this.objectId };
+      case 2 /* PROJECT_LOGS */:
+        return { project_id: this.objectId, log_id: "g" };
+      default:
+        throw new Error("Impossible");
+    }
+  }
+  toObject() {
+    return {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      rowIds: this.rowIds?.toObject()
+    };
+  }
+};
+
+// util/span_identifier_v2.ts
+import { z as z2 } from "zod/v3";
+function tryMakeUuid2(s) {
+  try {
+    const ret = uuid2.parse(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 SpanObjectTypeV2 = /* @__PURE__ */ ((SpanObjectTypeV22) => {
+  SpanObjectTypeV22[SpanObjectTypeV22["EXPERIMENT"] = 1] = "EXPERIMENT";
+  SpanObjectTypeV22[SpanObjectTypeV22["PROJECT_LOGS"] = 2] = "PROJECT_LOGS";
+  return SpanObjectTypeV22;
+})(SpanObjectTypeV2 || {});
+var SpanObjectTypeV2EnumSchema = z2.nativeEnum(SpanObjectTypeV2);
+var SpanRowIdsV2 = class {
+  rowId;
+  spanId;
+  rootSpanId;
+  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 SpanComponentsV2 = class _SpanComponentsV2 {
+  objectType;
+  objectId;
+  computeObjectMetadataArgs;
+  rowIds;
+  constructor(args) {
+    this.objectType = args.objectType;
+    this.objectId = args.objectId;
+    this.computeObjectMetadataArgs = args.computeObjectMetadataArgs;
+    this.rowIds = args.rowIds;
+    if (!(this.objectId || this.computeObjectMetadataArgs)) {
+      throw new Error(
+        "Must provide either objectId or computeObjectMetadataArgs"
+      );
+    }
+  }
+  toStr() {
+    const allBuffers = [];
+    const { bytes: rowIdBytes, isUUID: rowIdIsUUID } = this.rowIds ? tryMakeUuid2(this.rowIds.rowId) : { bytes: Buffer.from(""), isUUID: false };
+    allBuffers.push(
+      Buffer.from([
+        ENCODING_VERSION_NUMBER2,
+        this.objectType,
+        this.objectId ? 1 : 0,
+        this.computeObjectMetadataArgs ? 1 : 0,
+        this.rowIds ? 1 : 0,
+        rowIdIsUUID ? 1 : 0
+      ])
+    );
+    if (this.objectId) {
+      const { bytes: objectIdBytes, isUUID: objectIdIsUUID } = tryMakeUuid2(
+        this.objectId
+      );
+      if (!objectIdIsUUID) {
+        throw new Error("object_id component must be a valid UUID");
+      }
+      allBuffers.push(objectIdBytes);
+    }
+    if (this.computeObjectMetadataArgs) {
+      const computeObjectMetadataBytes = Buffer.from(
+        JSON.stringify(this.computeObjectMetadataArgs),
+        "utf-8"
+      );
+      const serializedLenBytes = Buffer.alloc(INTEGER_ENCODING_NUM_BYTES);
+      serializedLenBytes.writeInt32BE(computeObjectMetadataBytes.length);
+      allBuffers.push(serializedLenBytes, computeObjectMetadataBytes);
+    }
+    if (this.rowIds) {
+      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 } = tryMakeUuid2(
+        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_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 objectType = SpanObjectTypeV2EnumSchema.parse(rawBytes[1]);
+      for (let i = 2; i < 6; ++i) {
+        if (![0, 1].includes(rawBytes[i])) {
+          throw new Error();
+        }
+      }
+      const hasObjectId = rawBytes[2] == 1;
+      const hasComputeObjectMetadataArgs = rawBytes[3] == 1;
+      const hasRowId = rawBytes[4] == 1;
+      const rowIdIsUUID = rawBytes[5] == 1;
+      let byteCursor = 6;
+      let objectId = void 0;
+      if (hasObjectId) {
+        const nextByteCursor = byteCursor + 16;
+        objectId = uuid2.stringify(
+          rawBytes.subarray(byteCursor, nextByteCursor)
+        );
+        byteCursor = nextByteCursor;
+      }
+      let computeObjectMetadataArgs;
+      if (hasComputeObjectMetadataArgs) {
+        let nextByteCursor = byteCursor + INTEGER_ENCODING_NUM_BYTES;
+        const serializedLenBytes = rawBytes.readInt32BE(byteCursor);
+        byteCursor = nextByteCursor;
+        nextByteCursor = byteCursor + serializedLenBytes;
+        computeObjectMetadataArgs = JSON.parse(
+          rawBytes.subarray(byteCursor, nextByteCursor).toString("utf-8")
+        );
+        byteCursor = nextByteCursor;
+      }
+      const rowIds = (() => {
+        if (!hasRowId) {
+          return void 0;
+        }
+        let nextByteCursor = byteCursor + 16;
+        const spanId = uuid2.stringify(
+          rawBytes.subarray(byteCursor, nextByteCursor)
+        );
+        byteCursor = nextByteCursor;
+        nextByteCursor = byteCursor + 16;
+        const rootSpanId = uuid2.stringify(
+          rawBytes.subarray(byteCursor, nextByteCursor)
+        );
+        byteCursor = nextByteCursor;
+        const rowId = rowIdIsUUID ? uuid2.stringify(rawBytes.subarray(byteCursor)) : rawBytes.subarray(byteCursor).toString("utf-8");
+        return new SpanRowIdsV2({ rowId, spanId, rootSpanId });
+      })();
+      return new _SpanComponentsV2({
+        objectType,
+        objectId,
+        computeObjectMetadataArgs,
+        rowIds
+      });
+    } catch (e) {
+      throw new Error(INVALID_ENCODING_ERRMSG2);
+    }
+  }
+  objectIdFields() {
+    if (!this.objectId) {
+      throw new Error(
+        "Impossible: cannot invoke `object_id_fields` unless SpanComponentsV2 is initialized with an `object_id`"
+      );
+    }
+    switch (this.objectType) {
+      case 1 /* EXPERIMENT */:
+        return { experiment_id: this.objectId };
+      case 2 /* PROJECT_LOGS */:
+        return { project_id: this.objectId, log_id: "g" };
+      default:
+        throw new Error("Impossible");
+    }
+  }
+  toObject() {
+    return {
+      objectType: this.objectType,
+      objectId: this.objectId,
+      computeObjectMetadataArgs: this.computeObjectMetadataArgs,
+      rowIds: this.rowIds?.toObject()
+    };
+  }
+};
+
+// util/span_identifier_v3.ts
+import { z as z3 } from "zod/v3";
+
+// util/bytes.ts
+function concatUint8Arrays(...arrays) {
+  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function uint8ArrayToBase64(uint8Array) {
+  let binary = "";
+  for (let i = 0; i < uint8Array.length; i++) {
+    binary += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(base64) {
+  const binary = atob(base64);
+  const uint8Array = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    uint8Array[i] = binary.charCodeAt(i);
+  }
+  return uint8Array;
+}
+function uint8ArrayToString(uint8Array) {
+  const decoder = new TextDecoder("utf-8");
+  return decoder.decode(uint8Array);
+}
+function stringToUint8Array(str) {
+  const encoder = new TextEncoder();
+  return encoder.encode(str);
+}
+
+// util/span_identifier_v3.ts
+function tryMakeUuid3(s) {
+  try {
+    const ret = uuid3.parse(s);
+    if (ret.length !== 16) {
+      throw new Error();
+    }
+    return { bytes: new Uint8Array(ret), isUUID: true };
+  } catch {
+    return { bytes: void 0, isUUID: false };
+  }
+}
+var ENCODING_VERSION_NUMBER3 = 3;
+var INVALID_ENCODING_ERRMSG3 = `SpanComponents string is not properly encoded. This library only supports encoding versions up to ${ENCODING_VERSION_NUMBER3}. Please make sure the SDK library used to decode the SpanComponents is at least as new as any library used to encode it.`;
+var SpanObjectTypeV3 = /* @__PURE__ */ ((SpanObjectTypeV32) => {
+  SpanObjectTypeV32[SpanObjectTypeV32["EXPERIMENT"] = 1] = "EXPERIMENT";
+  SpanObjectTypeV32[SpanObjectTypeV32["PROJECT_LOGS"] = 2] = "PROJECT_LOGS";
+  SpanObjectTypeV32[SpanObjectTypeV32["PLAYGROUND_LOGS"] = 3] = "PLAYGROUND_LOGS";
+  return SpanObjectTypeV32;
+})(SpanObjectTypeV3 || {});
+var spanObjectTypeV3EnumSchema = z3.nativeEnum(SpanObjectTypeV3);
+function spanObjectTypeV3ToString(objectType) {
+  switch (objectType) {
+    case 1 /* EXPERIMENT */:
+      return "experiment";
+    case 2 /* PROJECT_LOGS */:
+      return "project_logs";
+    case 3 /* PLAYGROUND_LOGS */:
+      return "playground_logs";
+    default:
+      const x = objectType;
+      throw new Error(`Unknown SpanObjectTypeV3: ${x}`);
+  }
+}
+var InternalSpanComponentUUIDFields = /* @__PURE__ */ ((InternalSpanComponentUUIDFields2) => {
+  InternalSpanComponentUUIDFields2[InternalSpanComponentUUIDFields2["OBJECT_ID"] = 1] = "OBJECT_ID";
+  InternalSpanComponentUUIDFields2[InternalSpanComponentUUIDFields2["ROW_ID"] = 2] = "ROW_ID";
+  InternalSpanComponentUUIDFields2[InternalSpanComponentUUIDFields2["SPAN_ID"] = 3] = "SPAN_ID";
+  InternalSpanComponentUUIDFields2[InternalSpanComponentUUIDFields2["ROOT_SPAN_ID"] = 4] = "ROOT_SPAN_ID";
+  return InternalSpanComponentUUIDFields2;
+})(InternalSpanComponentUUIDFields || {});
+var internalSpanComponentUUIDFieldsEnumSchema = z3.nativeEnum(
+  InternalSpanComponentUUIDFields
+);
+var _INTERNAL_SPAN_COMPONENT_UUID_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 spanComponentsV3Schema = z3.object({
+  object_type: spanObjectTypeV3EnumSchema,
+  // TODO(manu): We should have a more elaborate zod schema for
+  // `propagated_event`. This will required zod-ifying the contents of
+  // sdk/js/util/object.ts.
+  propagated_event: z3.record(z3.unknown()).nullish()
+}).and(
+  z3.union([
+    // Must provide one or the other.
+    z3.object({
+      object_id: z3.string().nullish(),
+      compute_object_metadata_args: z3.optional(z3.null())
+    }),
+    z3.object({
+      object_id: z3.optional(z3.null()),
+      compute_object_metadata_args: z3.record(z3.unknown())
+    })
+  ])
+).and(
+  z3.union([
+    // Either all of these must be provided or none.
+    z3.object({
+      row_id: z3.string(),
+      span_id: z3.string(),
+      root_span_id: z3.string()
+    }),
+    z3.object({
+      row_id: z3.optional(z3.null()),
+      span_id: z3.optional(z3.null()),
+      root_span_id: z3.optional(z3.null())
+    })
+  ])
+);
+var SpanComponentsV3 = class _SpanComponentsV3 {
+  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
+    };
+    const allBuffers = [];
+    allBuffers.push(
+      new Uint8Array([ENCODING_VERSION_NUMBER3, this.data.object_type])
+    );
+    const uuidEntries = [];
+    function addUuidField(origVal, fieldId) {
+      const ret = tryMakeUuid3(origVal);
+      if (ret.isUUID) {
+        uuidEntries.push(
+          concatUint8Arrays(new Uint8Array([fieldId]), ret.bytes)
+        );
+      } else {
+        jsonObj[_INTERNAL_SPAN_COMPONENT_UUID_FIELDS_ID_TO_NAME[fieldId]] = origVal;
+      }
+    }
+    if (this.data.object_id) {
+      addUuidField(
+        this.data.object_id,
+        1 /* OBJECT_ID */
+      );
+    }
+    if (this.data.row_id) {
+      addUuidField(this.data.row_id, 2 /* ROW_ID */);
+    }
+    if (this.data.span_id) {
+      addUuidField(this.data.span_id, 3 /* SPAN_ID */);
+    }
+    if (this.data.root_span_id) {
+      addUuidField(
+        this.data.root_span_id,
+        4 /* ROOT_SPAN_ID */
+      );
+    }
+    if (uuidEntries.length > 255) {
+      throw new Error("Impossible: too many UUID entries to encode");
+    }
+    allBuffers.push(new Uint8Array([uuidEntries.length]));
+    allBuffers.push(...uuidEntries);
+    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_NUMBER3) {
+        const spanComponentsOld = SpanComponentsV2.fromStr(s);
+        jsonObj["object_type"] = spanComponentsOld.objectType;
+        jsonObj["object_id"] = spanComponentsOld.objectId;
+        jsonObj["compute_object_metadata_args"] = spanComponentsOld.computeObjectMetadataArgs;
+        if (spanComponentsOld.rowIds) {
+          jsonObj["row_id"] = spanComponentsOld.rowIds.rowId;
+          jsonObj["span_id"] = spanComponentsOld.rowIds.spanId;
+          jsonObj["root_span_id"] = spanComponentsOld.rowIds.rootSpanId;
+        }
+      } else {
+        jsonObj["object_type"] = rawBytes[1];
+        const numUuidEntries = rawBytes[2];
+        let byteOffset = 3;
+        for (let i = 0; i < numUuidEntries; ++i) {
+          const fieldId = internalSpanComponentUUIDFieldsEnumSchema.parse(
+            rawBytes[byteOffset]
+          );
+          const fieldBytes = rawBytes.subarray(byteOffset + 1, byteOffset + 17);
+          byteOffset += 17;
+          jsonObj[_INTERNAL_SPAN_COMPONENT_UUID_FIELDS_ID_TO_NAME[fieldId]] = uuid3.stringify(fieldBytes);
+        }
+        if (byteOffset < rawBytes.length) {
+          const remainingJsonObj = JSON.parse(
+            uint8ArrayToString(rawBytes.subarray(byteOffset))
+          );
+          Object.assign(jsonObj, remainingJsonObj);
+        }
+      }
+      return _SpanComponentsV3.fromJsonObj(jsonObj);
+    } catch {
+      throw new Error(INVALID_ENCODING_ERRMSG3);
+    }
+  }
+  objectIdFields() {
+    if (!this.data.object_id) {
+      throw new Error(
+        "Impossible: cannot invoke `objectIdFields` unless SpanComponentsV3 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("Impossible");
+    }
+  }
+  async export() {
+    return this.toStr();
+  }
+  static fromJsonObj(jsonObj) {
+    return new _SpanComponentsV3(spanComponentsV3Schema.parse(jsonObj));
+  }
+};
+
+// util/type_util.ts
+function isObject(value) {
+  return value instanceof Object && !(value instanceof Array);
+}
+function isArray(value) {
+  return value instanceof Array;
+}
+function isObjectOrArray(value) {
+  return value instanceof Object;
+}
+
+// util/object_util.ts
+function mergeDictsWithPaths({
+  mergeInto,
+  mergeFrom,
+  mergePaths
+}) {
+  const mergePathsSerialized = new Set(
+    mergePaths.map((p) => JSON.stringify(p))
+  );
+  return mergeDictsWithPathsHelper({
+    mergeInto,
+    mergeFrom,
+    path: [],
+    mergePaths: mergePathsSerialized
+  });
+}
+function mergeDictsWithPathsHelper({
+  mergeInto,
+  mergeFrom,
+  path: path3,
+  mergePaths
+}) {
+  Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
+    const fullPath = path3.concat([k]);
+    const fullPathSerialized = JSON.stringify(fullPath);
+    const mergeIntoV = recordFind(mergeInto, k);
+    if (isObject(mergeIntoV) && isObject(mergeFromV) && !mergePaths.has(fullPathSerialized)) {
+      mergeDictsWithPathsHelper({
+        mergeInto: mergeIntoV,
+        mergeFrom: mergeFromV,
+        path: fullPath,
+        mergePaths
+      });
+    } else {
+      mergeInto[k] = mergeFromV;
+    }
+  });
+  return mergeInto;
+}
+function mergeDicts(mergeInto, mergeFrom) {
+  return mergeDictsWithPaths({ mergeInto, mergeFrom, mergePaths: [] });
+}
+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 recordFind(m, k) {
+  return m[k];
+}
+function getObjValueByPath(row, path3) {
+  let curr = row;
+  for (const p of path3) {
+    if (!isObjectOrArray(curr)) {
+      return null;
+    }
+    curr = curr[p];
+  }
+  return curr;
+}
+
+// util/graph_util.ts
+function depthFirstSearch(args) {
+  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 = args.visitationOrder ?? [...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?.(vertex);
+      continue;
+    }
+    if (firstVisitedVertices.has(vertex)) {
+      continue;
+    }
+    firstVisitedVertices.add(vertex);
+    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?.parentVertex !== void 0 ? mapAt(vertexLabels, 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();
+}
+
+// util/merge_row_batch.ts
+function generateMergedRowKey(row, useParentIdForId) {
+  return JSON.stringify(
+    [
+      "org_id",
+      "project_id",
+      "experiment_id",
+      "dataset_id",
+      "prompt_session_id",
+      "log_id",
+      useParentIdForId ?? false ? PARENT_ID_FIELD : "id"
+    ].map((k) => row[k])
+  );
+}
+var MERGE_ROW_SKIP_FIELDS = [
+  "created",
+  "span_id",
+  "root_span_id",
+  "span_parents",
+  "_parent_id"
+  // TODO: handle merge paths.
+];
+function popMergeRowSkipFields(row) {
+  const popped = {};
+  for (const field of MERGE_ROW_SKIP_FIELDS) {
+    if (field in row) {
+      popped[field] = row[field];
+      delete row[field];
+    }
+  }
+  return popped;
+}
+function restoreMergeRowSkipFields(row, skipFields) {
+  for (const field of MERGE_ROW_SKIP_FIELDS) {
+    delete row[field];
+    if (field in skipFields) {
+      row[field] = skipFields[field];
+    }
+  }
+}
+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@braintrust.dev 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 skipFields = popMergeRowSkipFields(existingRow);
+      const preserveNoMerge = !existingRow[IS_MERGE_FIELD];
+      mergeDicts(existingRow, row);
+      restoreMergeRowSkipFields(existingRow, skipFields);
+      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) {
+  let { items } = args;
+  const batchMaxNumItems = args.batchMaxNumItems ?? Number.POSITIVE_INFINITY;
+  const batchMaxNumBytes = args.batchMaxNumBytes ?? 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;
+}
+
+// util/object.ts
+var DEFAULT_IS_LEGACY_DATASET = false;
+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;
+}
+
+// util/json_util.ts
+function constructJsonArray(items) {
+  return `[${items.join(",")}]`;
+}
+
+// util/string_util.ts
+function _urljoin(...parts) {
+  return parts.map(
+    (x, i) => x.replace(/^\//, "").replace(i < parts.length - 1 ? /\/$/ : "", "")
+  ).filter((x) => x.trim() !== "").join("/");
+}
+
+// util/git_fields.ts
+function mergeGitMetadataSettings(s1, s2) {
+  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 = (s1.fields ?? []).filter((f) => (s2.fields ?? []).includes(f));
+  const collect = fields.length > 0 ? "some" : "none";
+  return { collect, fields };
+}
+
+// util/xact-ids.ts
+var TOP_BITS = BigInt("0x0DE1") << BigInt(48);
+var MOD = BigInt(1) << BigInt(64);
+var COPRIME = BigInt("205891132094649");
+var COPRIME_INVERSE = BigInt("1522336535492693385");
+function modularMultiply(value, prime) {
+  return value * prime % MOD;
+}
+function prettifyXact(valueString) {
+  const value = BigInt(valueString);
+  const encoded = modularMultiply(value, COPRIME);
+  return encoded.toString(16).padStart(16, "0");
+}
+function loadPrettyXact(encodedHex) {
+  if (encodedHex.length !== 16) {
+    return encodedHex;
+  }
+  const value = BigInt(`0x${encodedHex}`);
+  const multipliedInverse = modularMultiply(value, COPRIME_INVERSE);
+  const withTopBits = TOP_BITS | multipliedInverse;
+  return withTopBits.toString();
+}
+
+// util/zod_util.ts
+import { z as z4 } from "zod/v3";
 
 // src/generated_types.ts
-import { z } from "zod";
-var AclObjectType = z.union([
-  z.enum([
+import { z as z5 } from "zod/v3";
+var AclObjectType = z5.union([
+  z5.enum([
     "organization",
     "project",
     "experiment",
@@ -3537,9 +4503,9 @@ var AclObjectType = z.union([
     "project_log",
     "org_project"
   ]),
-  z.null()
+  z5.null()
 ]);
-var Permission = z.enum([
+var Permission = z5.enum([
   "create",
   "read",
   "update",
@@ -3549,310 +4515,310 @@ var Permission = z.enum([
   "update_acls",
   "delete_acls"
 ]);
-var Acl = z.object({
-  id: z.string().uuid(),
-  object_type: AclObjectType.and(z.string()),
-  object_id: z.string().uuid(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  group_id: z.union([z.string(), z.null()]).optional(),
-  permission: Permission.and(z.union([z.string(), z.null()])).optional(),
-  restrict_object_type: AclObjectType.and(z.unknown()).optional(),
-  role_id: z.union([z.string(), z.null()]).optional(),
-  _object_org_id: z.string().uuid(),
-  created: z.union([z.string(), z.null()]).optional()
-});
-var AISecret = z.object({
-  id: z.string().uuid(),
-  created: z.union([z.string(), z.null()]).optional(),
-  updated_at: z.union([z.string(), z.null()]).optional(),
-  org_id: z.string().uuid(),
-  name: z.string(),
-  type: z.union([z.string(), z.null()]).optional(),
-  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
-  preview_secret: z.union([z.string(), z.null()]).optional()
-});
-var ResponseFormatJsonSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  schema: z.union([z.object({}).partial().passthrough(), z.string()]).optional(),
-  strict: z.union([z.boolean(), z.null()]).optional()
-});
-var ResponseFormatNullish = z.union([
-  z.object({ type: z.literal("json_object") }),
-  z.object({
-    type: z.literal("json_schema"),
+var Acl = z5.object({
+  id: z5.string().uuid(),
+  object_type: AclObjectType.and(z5.string()),
+  object_id: z5.string().uuid(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  group_id: z5.union([z5.string(), z5.null()]).optional(),
+  permission: Permission.and(z5.union([z5.string(), z5.null()])).optional(),
+  restrict_object_type: AclObjectType.and(z5.unknown()).optional(),
+  role_id: z5.union([z5.string(), z5.null()]).optional(),
+  _object_org_id: z5.string().uuid(),
+  created: z5.union([z5.string(), z5.null()]).optional()
+});
+var AISecret = z5.object({
+  id: z5.string().uuid(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  updated_at: z5.union([z5.string(), z5.null()]).optional(),
+  org_id: z5.string().uuid(),
+  name: z5.string(),
+  type: z5.union([z5.string(), z5.null()]).optional(),
+  metadata: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional(),
+  preview_secret: z5.union([z5.string(), z5.null()]).optional()
+});
+var ResponseFormatJsonSchema = z5.object({
+  name: z5.string(),
+  description: z5.string().optional(),
+  schema: z5.union([z5.object({}).partial().passthrough(), z5.string()]).optional(),
+  strict: z5.union([z5.boolean(), z5.null()]).optional()
+});
+var ResponseFormatNullish = z5.union([
+  z5.object({ type: z5.literal("json_object") }),
+  z5.object({
+    type: z5.literal("json_schema"),
     json_schema: ResponseFormatJsonSchema
   }),
-  z.object({ type: z.literal("text") }),
-  z.null()
+  z5.object({ type: z5.literal("text") }),
+  z5.null()
 ]);
-var AnyModelParams = z.object({
-  temperature: z.number().optional(),
-  top_p: z.number().optional(),
-  max_tokens: z.number(),
-  max_completion_tokens: z.number().optional(),
-  frequency_penalty: z.number().optional(),
-  presence_penalty: z.number().optional(),
+var AnyModelParams = z5.object({
+  temperature: z5.number().optional(),
+  top_p: z5.number().optional(),
+  max_tokens: z5.number(),
+  max_completion_tokens: z5.number().optional(),
+  frequency_penalty: z5.number().optional(),
+  presence_penalty: z5.number().optional(),
   response_format: ResponseFormatNullish.optional(),
-  tool_choice: z.union([
-    z.literal("auto"),
-    z.literal("none"),
-    z.literal("required"),
-    z.object({
-      type: z.literal("function"),
-      function: z.object({ name: z.string() })
+  tool_choice: z5.union([
+    z5.literal("auto"),
+    z5.literal("none"),
+    z5.literal("required"),
+    z5.object({
+      type: z5.literal("function"),
+      function: z5.object({ name: z5.string() })
     })
   ]).optional(),
-  function_call: z.union([
-    z.literal("auto"),
-    z.literal("none"),
-    z.object({ name: z.string() })
+  function_call: z5.union([
+    z5.literal("auto"),
+    z5.literal("none"),
+    z5.object({ name: z5.string() })
   ]).optional(),
-  n: z.number().optional(),
-  stop: z.array(z.string()).optional(),
-  reasoning_effort: z.enum(["minimal", "low", "medium", "high"]).optional(),
-  verbosity: z.enum(["low", "medium", "high"]).optional(),
-  top_k: z.number().optional(),
-  stop_sequences: z.array(z.string()).optional(),
-  max_tokens_to_sample: z.number().optional(),
-  maxOutputTokens: z.number().optional(),
-  topP: z.number().optional(),
-  topK: z.number().optional(),
-  use_cache: z.boolean().optional()
-});
-var ApiKey = z.object({
-  id: z.string().uuid(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  preview_name: z.string(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  user_email: z.union([z.string(), z.null()]).optional(),
-  user_given_name: z.union([z.string(), z.null()]).optional(),
-  user_family_name: z.union([z.string(), z.null()]).optional(),
-  org_id: z.union([z.string(), z.null()]).optional()
-});
-var AsyncScoringState = z.union([
-  z.object({
-    status: z.literal("enabled"),
-    token: z.string(),
-    function_ids: z.array(z.unknown()).min(1),
-    skip_logging: z.union([z.boolean(), z.null()]).optional()
+  n: z5.number().optional(),
+  stop: z5.array(z5.string()).optional(),
+  reasoning_effort: z5.enum(["minimal", "low", "medium", "high"]).optional(),
+  verbosity: z5.enum(["low", "medium", "high"]).optional(),
+  top_k: z5.number().optional(),
+  stop_sequences: z5.array(z5.string()).optional(),
+  max_tokens_to_sample: z5.number().optional(),
+  maxOutputTokens: z5.number().optional(),
+  topP: z5.number().optional(),
+  topK: z5.number().optional(),
+  use_cache: z5.boolean().optional()
+});
+var ApiKey = z5.object({
+  id: z5.string().uuid(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  preview_name: z5.string(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  user_email: z5.union([z5.string(), z5.null()]).optional(),
+  user_given_name: z5.union([z5.string(), z5.null()]).optional(),
+  user_family_name: z5.union([z5.string(), z5.null()]).optional(),
+  org_id: z5.union([z5.string(), z5.null()]).optional()
+});
+var AsyncScoringState = z5.union([
+  z5.object({
+    status: z5.literal("enabled"),
+    token: z5.string(),
+    function_ids: z5.array(z5.unknown()).min(1),
+    skip_logging: z5.union([z5.boolean(), z5.null()]).optional()
   }),
-  z.object({ status: z.literal("disabled") }),
-  z.null(),
-  z.null()
+  z5.object({ status: z5.literal("disabled") }),
+  z5.null(),
+  z5.null()
 ]);
-var AsyncScoringControl = z.union([
-  z.object({ kind: z.literal("score_update"), token: z.string() }),
-  z.object({ kind: z.literal("state_override"), state: AsyncScoringState }),
-  z.object({ kind: z.literal("state_force_reselect") }),
-  z.object({ kind: z.literal("state_enabled_force_rescore") })
+var AsyncScoringControl = z5.union([
+  z5.object({ kind: z5.literal("score_update"), token: z5.string() }),
+  z5.object({ kind: z5.literal("state_override"), state: AsyncScoringState }),
+  z5.object({ kind: z5.literal("state_force_reselect") }),
+  z5.object({ kind: z5.literal("state_enabled_force_rescore") })
 ]);
-var BraintrustAttachmentReference = z.object({
-  type: z.literal("braintrust_attachment"),
-  filename: z.string().min(1),
-  content_type: z.string().min(1),
-  key: z.string().min(1)
-});
-var ExternalAttachmentReference = z.object({
-  type: z.literal("external_attachment"),
-  filename: z.string().min(1),
-  content_type: z.string().min(1),
-  url: z.string().min(1)
-});
-var AttachmentReference = z.discriminatedUnion("type", [
+var BraintrustAttachmentReference = z5.object({
+  type: z5.literal("braintrust_attachment"),
+  filename: z5.string().min(1),
+  content_type: z5.string().min(1),
+  key: z5.string().min(1)
+});
+var ExternalAttachmentReference = z5.object({
+  type: z5.literal("external_attachment"),
+  filename: z5.string().min(1),
+  content_type: z5.string().min(1),
+  url: z5.string().min(1)
+});
+var AttachmentReference = z5.discriminatedUnion("type", [
   BraintrustAttachmentReference,
   ExternalAttachmentReference
 ]);
-var UploadStatus = z.enum(["uploading", "done", "error"]);
-var AttachmentStatus = z.object({
+var UploadStatus = z5.enum(["uploading", "done", "error"]);
+var AttachmentStatus = z5.object({
   upload_status: UploadStatus,
-  error_message: z.string().optional()
-});
-var BraintrustModelParams = z.object({ use_cache: z.boolean() }).partial();
-var CallEvent = z.union([
-  z.object({
-    id: z.string().optional(),
-    data: z.string(),
-    event: z.literal("text_delta")
+  error_message: z5.string().optional()
+});
+var BraintrustModelParams = z5.object({ use_cache: z5.boolean() }).partial();
+var CallEvent = z5.union([
+  z5.object({
+    id: z5.string().optional(),
+    data: z5.string(),
+    event: z5.literal("text_delta")
   }),
-  z.object({
-    id: z.string().optional(),
-    data: z.string(),
-    event: z.literal("reasoning_delta")
+  z5.object({
+    id: z5.string().optional(),
+    data: z5.string(),
+    event: z5.literal("reasoning_delta")
   }),
-  z.object({
-    id: z.string().optional(),
-    data: z.string(),
-    event: z.literal("json_delta")
+  z5.object({
+    id: z5.string().optional(),
+    data: z5.string(),
+    event: z5.literal("json_delta")
   }),
-  z.object({
-    id: z.string().optional(),
-    data: z.string(),
-    event: z.literal("progress")
+  z5.object({
+    id: z5.string().optional(),
+    data: z5.string(),
+    event: z5.literal("progress")
   }),
-  z.object({
-    id: z.string().optional(),
-    data: z.string(),
-    event: z.literal("error")
+  z5.object({
+    id: z5.string().optional(),
+    data: z5.string(),
+    event: z5.literal("error")
   }),
-  z.object({
-    id: z.string().optional(),
-    data: z.string(),
-    event: z.literal("console")
+  z5.object({
+    id: z5.string().optional(),
+    data: z5.string(),
+    event: z5.literal("console")
   }),
-  z.object({
-    id: z.string().optional(),
-    event: z.literal("start"),
-    data: z.literal("")
+  z5.object({
+    id: z5.string().optional(),
+    event: z5.literal("start"),
+    data: z5.literal("")
   }),
-  z.object({
-    id: z.string().optional(),
-    event: z.literal("done"),
-    data: z.literal("")
+  z5.object({
+    id: z5.string().optional(),
+    event: z5.literal("done"),
+    data: z5.literal("")
   })
 ]);
-var ChatCompletionContentPartTextWithTitle = z.object({
-  text: z.string().default(""),
-  type: z.literal("text"),
-  cache_control: z.object({ type: z.literal("ephemeral") }).optional()
-});
-var ChatCompletionContentPartImageWithTitle = z.object({
-  image_url: z.object({
-    url: z.string(),
-    detail: z.union([z.literal("auto"), z.literal("low"), z.literal("high")]).optional()
+var ChatCompletionContentPartTextWithTitle = z5.object({
+  text: z5.string().default(""),
+  type: z5.literal("text"),
+  cache_control: z5.object({ type: z5.literal("ephemeral") }).optional()
+});
+var ChatCompletionContentPartImageWithTitle = z5.object({
+  image_url: z5.object({
+    url: z5.string(),
+    detail: z5.union([z5.literal("auto"), z5.literal("low"), z5.literal("high")]).optional()
   }),
-  type: z.literal("image_url")
+  type: z5.literal("image_url")
 });
-var ChatCompletionContentPart = z.union([
+var ChatCompletionContentPart = z5.union([
   ChatCompletionContentPartTextWithTitle,
   ChatCompletionContentPartImageWithTitle
 ]);
-var ChatCompletionContentPartText = z.object({
-  text: z.string().default(""),
-  type: z.literal("text"),
-  cache_control: z.object({ type: z.literal("ephemeral") }).optional()
-});
-var ChatCompletionMessageToolCall = z.object({
-  id: z.string(),
-  function: z.object({ arguments: z.string(), name: z.string() }),
-  type: z.literal("function")
-});
-var ChatCompletionMessageReasoning = z.object({ id: z.string(), content: z.string() }).partial();
-var ChatCompletionMessageParam = z.union([
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
-    role: z.literal("system"),
-    name: z.string().optional()
+var ChatCompletionContentPartText = z5.object({
+  text: z5.string().default(""),
+  type: z5.literal("text"),
+  cache_control: z5.object({ type: z5.literal("ephemeral") }).optional()
+});
+var ChatCompletionMessageToolCall = z5.object({
+  id: z5.string(),
+  function: z5.object({ arguments: z5.string(), name: z5.string() }),
+  type: z5.literal("function")
+});
+var ChatCompletionMessageReasoning = z5.object({ id: z5.string(), content: z5.string() }).partial();
+var ChatCompletionMessageParam = z5.union([
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText)]),
+    role: z5.literal("system"),
+    name: z5.string().optional()
   }),
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPart)]),
-    role: z.literal("user"),
-    name: z.string().optional()
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPart)]),
+    role: z5.literal("user"),
+    name: z5.string().optional()
   }),
-  z.object({
-    role: z.literal("assistant"),
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText), z.null()]).optional(),
-    function_call: z.object({ arguments: z.string(), name: z.string() }).optional(),
-    name: z.string().optional(),
-    tool_calls: z.array(ChatCompletionMessageToolCall).optional(),
-    reasoning: z.array(ChatCompletionMessageReasoning).optional()
+  z5.object({
+    role: z5.literal("assistant"),
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText), z5.null()]).optional(),
+    function_call: z5.object({ arguments: z5.string(), name: z5.string() }).optional(),
+    name: z5.string().optional(),
+    tool_calls: z5.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: z5.array(ChatCompletionMessageReasoning).optional()
   }),
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
-    role: z.literal("tool"),
-    tool_call_id: z.string().default("")
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText)]),
+    role: z5.literal("tool"),
+    tool_call_id: z5.string().default("")
   }),
-  z.object({
-    content: z.union([z.string(), z.null()]),
-    name: z.string(),
-    role: z.literal("function")
+  z5.object({
+    content: z5.union([z5.string(), z5.null()]),
+    name: z5.string(),
+    role: z5.literal("function")
   }),
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
-    role: z.literal("developer"),
-    name: z.string().optional()
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText)]),
+    role: z5.literal("developer"),
+    name: z5.string().optional()
   }),
-  z.object({
-    role: z.literal("model"),
-    content: z.union([z.string(), z.null()]).optional()
+  z5.object({
+    role: z5.literal("model"),
+    content: z5.union([z5.string(), z5.null()]).optional()
   })
 ]);
-var ChatCompletionOpenAIMessageParam = z.union([
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
-    role: z.literal("system"),
-    name: z.string().optional()
+var ChatCompletionOpenAIMessageParam = z5.union([
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText)]),
+    role: z5.literal("system"),
+    name: z5.string().optional()
   }),
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPart)]),
-    role: z.literal("user"),
-    name: z.string().optional()
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPart)]),
+    role: z5.literal("user"),
+    name: z5.string().optional()
   }),
-  z.object({
-    role: z.literal("assistant"),
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText), z.null()]).optional(),
-    function_call: z.object({ arguments: z.string(), name: z.string() }).optional(),
-    name: z.string().optional(),
-    tool_calls: z.array(ChatCompletionMessageToolCall).optional(),
-    reasoning: z.array(ChatCompletionMessageReasoning).optional()
+  z5.object({
+    role: z5.literal("assistant"),
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText), z5.null()]).optional(),
+    function_call: z5.object({ arguments: z5.string(), name: z5.string() }).optional(),
+    name: z5.string().optional(),
+    tool_calls: z5.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: z5.array(ChatCompletionMessageReasoning).optional()
   }),
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
-    role: z.literal("tool"),
-    tool_call_id: z.string().default("")
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText)]),
+    role: z5.literal("tool"),
+    tool_call_id: z5.string().default("")
   }),
-  z.object({
-    content: z.union([z.string(), z.null()]),
-    name: z.string(),
-    role: z.literal("function")
+  z5.object({
+    content: z5.union([z5.string(), z5.null()]),
+    name: z5.string(),
+    role: z5.literal("function")
   }),
-  z.object({
-    content: z.union([z.string(), z.array(ChatCompletionContentPartText)]),
-    role: z.literal("developer"),
-    name: z.string().optional()
+  z5.object({
+    content: z5.union([z5.string(), z5.array(ChatCompletionContentPartText)]),
+    role: z5.literal("developer"),
+    name: z5.string().optional()
   })
 ]);
-var ChatCompletionTool = z.object({
-  function: z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    parameters: z.object({}).partial().passthrough().optional()
+var ChatCompletionTool = z5.object({
+  function: z5.object({
+    name: z5.string(),
+    description: z5.string().optional(),
+    parameters: z5.object({}).partial().passthrough().optional()
   }),
-  type: z.literal("function")
+  type: z5.literal("function")
 });
-var CodeBundle = z.object({
-  runtime_context: z.object({
-    runtime: z.enum(["node", "python"]),
-    version: z.string()
+var CodeBundle = z5.object({
+  runtime_context: z5.object({
+    runtime: z5.enum(["node", "python"]),
+    version: z5.string()
   }),
-  location: z.union([
-    z.object({
-      type: z.literal("experiment"),
-      eval_name: z.string(),
-      position: z.union([
-        z.object({ type: z.literal("task") }),
-        z.object({ type: z.literal("scorer"), index: z.number().int().gte(0) })
+  location: z5.union([
+    z5.object({
+      type: z5.literal("experiment"),
+      eval_name: z5.string(),
+      position: z5.union([
+        z5.object({ type: z5.literal("task") }),
+        z5.object({ type: z5.literal("scorer"), index: z5.number().int().gte(0) })
       ])
     }),
-    z.object({ type: z.literal("function"), index: z.number().int().gte(0) })
+    z5.object({ type: z5.literal("function"), index: z5.number().int().gte(0) })
   ]),
-  bundle_id: z.string(),
-  preview: z.union([z.string(), z.null()]).optional()
-});
-var Dataset = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
-});
-var ObjectReferenceNullish = z.union([
-  z.object({
-    object_type: z.enum([
+  bundle_id: z5.string(),
+  preview: z5.union([z5.string(), z5.null()]).optional()
+});
+var Dataset = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  metadata: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional()
+});
+var ObjectReferenceNullish = z5.union([
+  z5.object({
+    object_type: z5.enum([
       "project_logs",
       "experiment",
       "dataset",
@@ -3860,399 +4826,399 @@ var ObjectReferenceNullish = z.union([
       "function",
       "prompt_session"
     ]),
-    object_id: z.string().uuid(),
-    id: z.string(),
-    _xact_id: z.union([z.string(), z.null()]).optional(),
-    created: z.union([z.string(), z.null()]).optional()
+    object_id: z5.string().uuid(),
+    id: z5.string(),
+    _xact_id: z5.union([z5.string(), z5.null()]).optional(),
+    created: z5.union([z5.string(), z5.null()]).optional()
   }),
-  z.null()
+  z5.null()
 ]);
-var DatasetEvent = z.object({
-  id: z.string(),
-  _xact_id: z.string(),
-  created: z.string().datetime({ offset: true }),
-  _pagination_key: z.union([z.string(), z.null()]).optional(),
-  project_id: z.string().uuid(),
-  dataset_id: z.string().uuid(),
-  input: z.unknown().optional(),
-  expected: z.unknown().optional(),
-  metadata: z.union([
-    z.object({ model: z.union([z.string(), z.null()]) }).partial().passthrough(),
-    z.null()
+var DatasetEvent = z5.object({
+  id: z5.string(),
+  _xact_id: z5.string(),
+  created: z5.string().datetime({ offset: true }),
+  _pagination_key: z5.union([z5.string(), z5.null()]).optional(),
+  project_id: z5.string().uuid(),
+  dataset_id: z5.string().uuid(),
+  input: z5.unknown().optional(),
+  expected: z5.unknown().optional(),
+  metadata: z5.union([
+    z5.object({ model: z5.union([z5.string(), z5.null()]) }).partial().passthrough(),
+    z5.null()
   ]).optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional(),
-  span_id: z.string(),
-  root_span_id: z.string(),
-  is_root: z.union([z.boolean(), z.null()]).optional(),
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  span_id: z5.string(),
+  root_span_id: z5.string(),
+  is_root: z5.union([z5.boolean(), z5.null()]).optional(),
   origin: ObjectReferenceNullish.optional()
 });
-var EnvVar = z.object({
-  id: z.string().uuid(),
-  object_type: z.enum(["organization", "project", "function"]),
-  object_id: z.string().uuid(),
-  name: z.string(),
-  created: z.union([z.string(), z.null()]).optional(),
-  used: z.union([z.string(), z.null()]).optional()
-});
-var RepoInfo = z.union([
-  z.object({
-    commit: z.union([z.string(), z.null()]),
-    branch: z.union([z.string(), z.null()]),
-    tag: z.union([z.string(), z.null()]),
-    dirty: z.union([z.boolean(), z.null()]),
-    author_name: z.union([z.string(), z.null()]),
-    author_email: z.union([z.string(), z.null()]),
-    commit_message: z.union([z.string(), z.null()]),
-    commit_time: z.union([z.string(), z.null()]),
-    git_diff: z.union([z.string(), z.null()])
+var EnvVar = z5.object({
+  id: z5.string().uuid(),
+  object_type: z5.enum(["organization", "project", "function"]),
+  object_id: z5.string().uuid(),
+  name: z5.string(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  used: z5.union([z5.string(), z5.null()]).optional()
+});
+var RepoInfo = z5.union([
+  z5.object({
+    commit: z5.union([z5.string(), z5.null()]),
+    branch: z5.union([z5.string(), z5.null()]),
+    tag: z5.union([z5.string(), z5.null()]),
+    dirty: z5.union([z5.boolean(), z5.null()]),
+    author_name: z5.union([z5.string(), z5.null()]),
+    author_email: z5.union([z5.string(), z5.null()]),
+    commit_message: z5.union([z5.string(), z5.null()]),
+    commit_time: z5.union([z5.string(), z5.null()]),
+    git_diff: z5.union([z5.string(), z5.null()])
   }).partial(),
-  z.null()
+  z5.null()
 ]);
-var Experiment = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
+var Experiment = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
   repo_info: RepoInfo.optional(),
-  commit: z.union([z.string(), z.null()]).optional(),
-  base_exp_id: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional(),
-  dataset_id: z.union([z.string(), z.null()]).optional(),
-  dataset_version: z.union([z.string(), z.null()]).optional(),
-  public: z.boolean(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional()
-});
-var SpanType = z.union([
-  z.enum(["llm", "score", "function", "eval", "task", "tool"]),
-  z.null()
+  commit: z5.union([z5.string(), z5.null()]).optional(),
+  base_exp_id: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional(),
+  dataset_id: z5.union([z5.string(), z5.null()]).optional(),
+  dataset_version: z5.union([z5.string(), z5.null()]).optional(),
+  public: z5.boolean(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  metadata: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional(),
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional()
+});
+var SpanType = z5.union([
+  z5.enum(["llm", "score", "function", "eval", "task", "tool"]),
+  z5.null()
 ]);
-var SpanAttributes = z.union([
-  z.object({ name: z.union([z.string(), z.null()]), type: SpanType }).partial().passthrough(),
-  z.null()
+var SpanAttributes = z5.union([
+  z5.object({ name: z5.union([z5.string(), z5.null()]), type: SpanType }).partial().passthrough(),
+  z5.null()
 ]);
-var ExperimentEvent = z.object({
-  id: z.string(),
-  _xact_id: z.string(),
-  created: z.string().datetime({ offset: true }),
-  _pagination_key: z.union([z.string(), z.null()]).optional(),
-  project_id: z.string().uuid(),
-  experiment_id: z.string().uuid(),
-  input: z.unknown().optional(),
-  output: z.unknown().optional(),
-  expected: z.unknown().optional(),
-  error: z.unknown().optional(),
-  scores: z.union([z.record(z.union([z.number(), z.null()])), z.null()]).optional(),
-  metadata: z.union([
-    z.object({ model: z.union([z.string(), z.null()]) }).partial().passthrough(),
-    z.null()
+var ExperimentEvent = z5.object({
+  id: z5.string(),
+  _xact_id: z5.string(),
+  created: z5.string().datetime({ offset: true }),
+  _pagination_key: z5.union([z5.string(), z5.null()]).optional(),
+  project_id: z5.string().uuid(),
+  experiment_id: z5.string().uuid(),
+  input: z5.unknown().optional(),
+  output: z5.unknown().optional(),
+  expected: z5.unknown().optional(),
+  error: z5.unknown().optional(),
+  scores: z5.union([z5.record(z5.union([z5.number(), z5.null()])), z5.null()]).optional(),
+  metadata: z5.union([
+    z5.object({ model: z5.union([z5.string(), z5.null()]) }).partial().passthrough(),
+    z5.null()
   ]).optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional(),
-  metrics: z.union([z.record(z.number()), z.null()]).optional(),
-  context: z.union([
-    z.object({
-      caller_functionname: z.union([z.string(), z.null()]),
-      caller_filename: z.union([z.string(), z.null()]),
-      caller_lineno: z.union([z.number(), z.null()])
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  metrics: z5.union([z5.record(z5.number()), z5.null()]).optional(),
+  context: z5.union([
+    z5.object({
+      caller_functionname: z5.union([z5.string(), z5.null()]),
+      caller_filename: z5.union([z5.string(), z5.null()]),
+      caller_lineno: z5.union([z5.number(), z5.null()])
     }).partial().passthrough(),
-    z.null()
+    z5.null()
   ]).optional(),
-  span_id: z.string(),
-  span_parents: z.union([z.array(z.string()), z.null()]).optional(),
-  root_span_id: z.string(),
+  span_id: z5.string(),
+  span_parents: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  root_span_id: z5.string(),
   span_attributes: SpanAttributes.optional(),
-  is_root: z.union([z.boolean(), z.null()]).optional(),
+  is_root: z5.union([z5.boolean(), z5.null()]).optional(),
   origin: ObjectReferenceNullish.optional()
 });
-var ExtendedSavedFunctionId = z.union([
-  z.object({ type: z.literal("function"), id: z.string() }),
-  z.object({ type: z.literal("global"), name: z.string() }),
-  z.object({
-    type: z.literal("slug"),
-    project_id: z.string(),
-    slug: z.string()
+var ExtendedSavedFunctionId = z5.union([
+  z5.object({ type: z5.literal("function"), id: z5.string() }),
+  z5.object({ type: z5.literal("global"), name: z5.string() }),
+  z5.object({
+    type: z5.literal("slug"),
+    project_id: z5.string(),
+    slug: z5.string()
   })
 ]);
-var PromptBlockDataNullish = z.union([
-  z.object({ type: z.literal("completion"), content: z.string() }),
-  z.object({
-    type: z.literal("chat"),
-    messages: z.array(ChatCompletionMessageParam),
-    tools: z.string().optional()
+var PromptBlockDataNullish = z5.union([
+  z5.object({ type: z5.literal("completion"), content: z5.string() }),
+  z5.object({
+    type: z5.literal("chat"),
+    messages: z5.array(ChatCompletionMessageParam),
+    tools: z5.string().optional()
   }),
-  z.null()
+  z5.null()
 ]);
-var ModelParams = z.union([
-  z.object({
-    use_cache: z.boolean(),
-    temperature: z.number(),
-    top_p: z.number(),
-    max_tokens: z.number(),
-    max_completion_tokens: z.number(),
-    frequency_penalty: z.number(),
-    presence_penalty: z.number(),
+var ModelParams = z5.union([
+  z5.object({
+    use_cache: z5.boolean(),
+    temperature: z5.number(),
+    top_p: z5.number(),
+    max_tokens: z5.number(),
+    max_completion_tokens: z5.number(),
+    frequency_penalty: z5.number(),
+    presence_penalty: z5.number(),
     response_format: ResponseFormatNullish,
-    tool_choice: z.union([
-      z.literal("auto"),
-      z.literal("none"),
-      z.literal("required"),
-      z.object({
-        type: z.literal("function"),
-        function: z.object({ name: z.string() })
+    tool_choice: z5.union([
+      z5.literal("auto"),
+      z5.literal("none"),
+      z5.literal("required"),
+      z5.object({
+        type: z5.literal("function"),
+        function: z5.object({ name: z5.string() })
       })
     ]),
-    function_call: z.union([
-      z.literal("auto"),
-      z.literal("none"),
-      z.object({ name: z.string() })
+    function_call: z5.union([
+      z5.literal("auto"),
+      z5.literal("none"),
+      z5.object({ name: z5.string() })
     ]),
-    n: z.number(),
-    stop: z.array(z.string()),
-    reasoning_effort: z.enum(["minimal", "low", "medium", "high"]),
-    verbosity: z.enum(["low", "medium", "high"])
+    n: z5.number(),
+    stop: z5.array(z5.string()),
+    reasoning_effort: z5.enum(["minimal", "low", "medium", "high"]),
+    verbosity: z5.enum(["low", "medium", "high"])
   }).partial().passthrough(),
-  z.object({
-    use_cache: z.boolean().optional(),
-    max_tokens: z.number(),
-    temperature: z.number(),
-    top_p: z.number().optional(),
-    top_k: z.number().optional(),
-    stop_sequences: z.array(z.string()).optional(),
-    max_tokens_to_sample: z.number().optional()
+  z5.object({
+    use_cache: z5.boolean().optional(),
+    max_tokens: z5.number(),
+    temperature: z5.number(),
+    top_p: z5.number().optional(),
+    top_k: z5.number().optional(),
+    stop_sequences: z5.array(z5.string()).optional(),
+    max_tokens_to_sample: z5.number().optional()
   }).passthrough(),
-  z.object({
-    use_cache: z.boolean(),
-    temperature: z.number(),
-    maxOutputTokens: z.number(),
-    topP: z.number(),
-    topK: z.number()
+  z5.object({
+    use_cache: z5.boolean(),
+    temperature: z5.number(),
+    maxOutputTokens: z5.number(),
+    topP: z5.number(),
+    topK: z5.number()
   }).partial().passthrough(),
-  z.object({
-    use_cache: z.boolean(),
-    temperature: z.number(),
-    topK: z.number()
+  z5.object({
+    use_cache: z5.boolean(),
+    temperature: z5.number(),
+    topK: z5.number()
   }).partial().passthrough(),
-  z.object({ use_cache: z.boolean() }).partial().passthrough()
+  z5.object({ use_cache: z5.boolean() }).partial().passthrough()
 ]);
-var PromptOptionsNullish = z.union([
-  z.object({ model: z.string(), params: ModelParams, position: z.string() }).partial(),
-  z.null()
+var PromptOptionsNullish = z5.union([
+  z5.object({ model: z5.string(), params: ModelParams, position: z5.string() }).partial(),
+  z5.null()
 ]);
-var PromptParserNullish = z.union([
-  z.object({
-    type: z.literal("llm_classifier"),
-    use_cot: z.boolean(),
-    choice_scores: z.record(z.number().gte(0).lte(1))
+var PromptParserNullish = z5.union([
+  z5.object({
+    type: z5.literal("llm_classifier"),
+    use_cot: z5.boolean(),
+    choice_scores: z5.record(z5.number().gte(0).lte(1))
   }),
-  z.null()
+  z5.null()
 ]);
-var SavedFunctionId = z.union([
-  z.object({ type: z.literal("function"), id: z.string() }),
-  z.object({ type: z.literal("global"), name: z.string() })
+var SavedFunctionId = z5.union([
+  z5.object({ type: z5.literal("function"), id: z5.string() }),
+  z5.object({ type: z5.literal("global"), name: z5.string() })
 ]);
-var PromptDataNullish = z.union([
-  z.object({
+var PromptDataNullish = z5.union([
+  z5.object({
     prompt: PromptBlockDataNullish,
     options: PromptOptionsNullish,
     parser: PromptParserNullish,
-    tool_functions: z.union([z.array(SavedFunctionId), z.null()]),
-    origin: z.union([
-      z.object({
-        prompt_id: z.string(),
-        project_id: z.string(),
-        prompt_version: z.string()
+    tool_functions: z5.union([z5.array(SavedFunctionId), z5.null()]),
+    origin: z5.union([
+      z5.object({
+        prompt_id: z5.string(),
+        project_id: z5.string(),
+        prompt_version: z5.string()
       }).partial(),
-      z.null()
+      z5.null()
     ])
   }).partial(),
-  z.null()
+  z5.null()
 ]);
-var FunctionTypeEnumNullish = z.union([
-  z.enum(["llm", "scorer", "task", "tool"]),
-  z.null()
+var FunctionTypeEnumNullish = z5.union([
+  z5.enum(["llm", "scorer", "task", "tool"]),
+  z5.null()
 ]);
-var FunctionIdRef = z.object({}).partial().passthrough();
-var PromptBlockData = z.union([
-  z.object({ type: z.literal("completion"), content: z.string() }),
-  z.object({
-    type: z.literal("chat"),
-    messages: z.array(ChatCompletionMessageParam),
-    tools: z.string().optional()
+var FunctionIdRef = z5.object({}).partial().passthrough();
+var PromptBlockData = z5.union([
+  z5.object({ type: z5.literal("completion"), content: z5.string() }),
+  z5.object({
+    type: z5.literal("chat"),
+    messages: z5.array(ChatCompletionMessageParam),
+    tools: z5.string().optional()
   })
 ]);
-var GraphNode = z.union([
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("function"),
+var GraphNode = z5.union([
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("function"),
     function: FunctionIdRef
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("input")
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("input")
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("output")
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("output")
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("literal"),
-    value: z.unknown().optional()
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("literal"),
+    value: z5.unknown().optional()
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("btql"),
-    expr: z.string()
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("btql"),
+    expr: z5.string()
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("gate"),
-    condition: z.union([z.string(), z.null()]).optional()
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("gate"),
+    condition: z5.union([z5.string(), z5.null()]).optional()
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("aggregator")
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("aggregator")
   }),
-  z.object({
-    description: z.union([z.string(), z.null()]).optional(),
-    position: z.union([z.object({ x: z.number(), y: z.number() }), z.null()]).optional(),
-    type: z.literal("prompt_template"),
+  z5.object({
+    description: z5.union([z5.string(), z5.null()]).optional(),
+    position: z5.union([z5.object({ x: z5.number(), y: z5.number() }), z5.null()]).optional(),
+    type: z5.literal("prompt_template"),
     prompt: PromptBlockData
   })
 ]);
-var GraphEdge = z.object({
-  source: z.object({ node: z.string().max(1024), variable: z.string() }),
-  target: z.object({ node: z.string().max(1024), variable: z.string() }),
-  purpose: z.enum(["control", "data", "messages"])
-});
-var GraphData = z.object({
-  type: z.literal("graph"),
-  nodes: z.record(GraphNode),
-  edges: z.record(GraphEdge)
-});
-var FunctionData = z.union([
-  z.object({ type: z.literal("prompt") }),
-  z.object({
-    type: z.literal("code"),
-    data: z.union([
-      z.object({ type: z.literal("bundle") }).and(CodeBundle),
-      z.object({
-        type: z.literal("inline"),
-        runtime_context: z.object({
-          runtime: z.enum(["node", "python"]),
-          version: z.string()
+var GraphEdge = z5.object({
+  source: z5.object({ node: z5.string().max(1024), variable: z5.string() }),
+  target: z5.object({ node: z5.string().max(1024), variable: z5.string() }),
+  purpose: z5.enum(["control", "data", "messages"])
+});
+var GraphData = z5.object({
+  type: z5.literal("graph"),
+  nodes: z5.record(GraphNode),
+  edges: z5.record(GraphEdge)
+});
+var FunctionData = z5.union([
+  z5.object({ type: z5.literal("prompt") }),
+  z5.object({
+    type: z5.literal("code"),
+    data: z5.union([
+      z5.object({ type: z5.literal("bundle") }).and(CodeBundle),
+      z5.object({
+        type: z5.literal("inline"),
+        runtime_context: z5.object({
+          runtime: z5.enum(["node", "python"]),
+          version: z5.string()
         }),
-        code: z.string()
+        code: z5.string()
       })
     ])
   }),
   GraphData,
-  z.object({
-    type: z.literal("remote_eval"),
-    endpoint: z.string(),
-    eval_name: z.string(),
-    parameters: z.object({}).partial().passthrough()
+  z5.object({
+    type: z5.literal("remote_eval"),
+    endpoint: z5.string(),
+    eval_name: z5.string(),
+    parameters: z5.object({}).partial().passthrough()
   }),
-  z.object({ type: z.literal("global"), name: z.string() })
+  z5.object({ type: z5.literal("global"), name: z5.string() })
 ]);
-var Function2 = z.object({
-  id: z.string().uuid(),
-  _xact_id: z.string(),
-  project_id: z.string().uuid(),
-  log_id: z.literal("p"),
-  org_id: z.string().uuid(),
-  name: z.string(),
-  slug: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
+var Function2 = z5.object({
+  id: z5.string().uuid(),
+  _xact_id: z5.string(),
+  project_id: z5.string().uuid(),
+  log_id: z5.literal("p"),
+  org_id: z5.string().uuid(),
+  name: z5.string(),
+  slug: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
   prompt_data: PromptDataNullish.optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional(),
-  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  metadata: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional(),
   function_type: FunctionTypeEnumNullish.optional(),
   function_data: FunctionData,
-  origin: z.union([
-    z.object({
-      object_type: AclObjectType.and(z.string()),
-      object_id: z.string().uuid(),
-      internal: z.union([z.boolean(), z.null()]).optional()
+  origin: z5.union([
+    z5.object({
+      object_type: AclObjectType.and(z5.string()),
+      object_id: z5.string().uuid(),
+      internal: z5.union([z5.boolean(), z5.null()]).optional()
     }),
-    z.null()
+    z5.null()
   ]).optional(),
-  function_schema: z.union([
-    z.object({ parameters: z.unknown(), returns: z.unknown() }).partial(),
-    z.null()
+  function_schema: z5.union([
+    z5.object({ parameters: z5.unknown(), returns: z5.unknown() }).partial(),
+    z5.null()
   ]).optional()
 });
-var FunctionFormat = z.enum(["llm", "code", "global", "graph"]);
-var PromptData = z.object({
+var FunctionFormat = z5.enum(["llm", "code", "global", "graph"]);
+var PromptData = z5.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
   parser: PromptParserNullish,
-  tool_functions: z.union([z.array(SavedFunctionId), z.null()]),
-  origin: z.union([
-    z.object({
-      prompt_id: z.string(),
-      project_id: z.string(),
-      prompt_version: z.string()
+  tool_functions: z5.union([z5.array(SavedFunctionId), z5.null()]),
+  origin: z5.union([
+    z5.object({
+      prompt_id: z5.string(),
+      project_id: z5.string(),
+      prompt_version: z5.string()
     }).partial(),
-    z.null()
+    z5.null()
   ])
 }).partial();
-var FunctionTypeEnum = z.enum(["llm", "scorer", "task", "tool"]);
-var FunctionId = z.union([
-  z.object({ function_id: z.string(), version: z.string().optional() }),
-  z.object({
-    project_name: z.string(),
-    slug: z.string(),
-    version: z.string().optional()
+var FunctionTypeEnum = z5.enum(["llm", "scorer", "task", "tool"]);
+var FunctionId = z5.union([
+  z5.object({ function_id: z5.string(), version: z5.string().optional() }),
+  z5.object({
+    project_name: z5.string(),
+    slug: z5.string(),
+    version: z5.string().optional()
   }),
-  z.object({ global_function: z.string() }),
-  z.object({
-    prompt_session_id: z.string(),
-    prompt_session_function_id: z.string(),
-    version: z.string().optional()
+  z5.object({ global_function: z5.string() }),
+  z5.object({
+    prompt_session_id: z5.string(),
+    prompt_session_function_id: z5.string(),
+    version: z5.string().optional()
   }),
-  z.object({
-    inline_context: z.object({
-      runtime: z.enum(["node", "python"]),
-      version: z.string()
+  z5.object({
+    inline_context: z5.object({
+      runtime: z5.enum(["node", "python"]),
+      version: z5.string()
     }),
-    code: z.string(),
-    name: z.union([z.string(), z.null()]).optional()
+    code: z5.string(),
+    name: z5.union([z5.string(), z5.null()]).optional()
   }),
-  z.object({
+  z5.object({
     inline_prompt: PromptData.optional(),
-    inline_function: z.object({}).partial().passthrough(),
+    inline_function: z5.object({}).partial().passthrough(),
     function_type: FunctionTypeEnum.optional(),
-    name: z.union([z.string(), z.null()]).optional()
+    name: z5.union([z5.string(), z5.null()]).optional()
   }),
-  z.object({
+  z5.object({
     inline_prompt: PromptData,
     function_type: FunctionTypeEnum.optional(),
-    name: z.union([z.string(), z.null()]).optional()
+    name: z5.union([z5.string(), z5.null()]).optional()
   })
 ]);
-var FunctionObjectType = z.enum([
+var FunctionObjectType = z5.enum([
   "prompt",
   "tool",
   "scorer",
   "task",
   "agent"
 ]);
-var FunctionOutputType = z.enum(["completion", "score", "any"]);
-var GitMetadataSettings = z.object({
-  collect: z.enum(["all", "none", "some"]),
-  fields: z.array(
-    z.enum([
+var FunctionOutputType = z5.enum(["completion", "score", "any"]);
+var GitMetadataSettings = z5.object({
+  collect: z5.enum(["all", "none", "some"]),
+  fields: z5.array(
+    z5.enum([
       "commit",
       "branch",
       "tag",
@@ -4265,49 +5231,49 @@ var GitMetadataSettings = z.object({
     ])
   ).optional()
 });
-var Group = z.object({
-  id: z.string().uuid(),
-  org_id: z.string().uuid(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional(),
-  member_users: z.union([z.array(z.string().uuid()), z.null()]).optional(),
-  member_groups: z.union([z.array(z.string().uuid()), z.null()]).optional()
-});
-var IfExists = z.enum(["error", "ignore", "replace"]);
-var InvokeParent = z.union([
-  z.object({
-    object_type: z.enum(["project_logs", "experiment", "playground_logs"]),
-    object_id: z.string(),
-    row_ids: z.union([
-      z.object({
-        id: z.string(),
-        span_id: z.string(),
-        root_span_id: z.string()
+var Group = z5.object({
+  id: z5.string().uuid(),
+  org_id: z5.string().uuid(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional(),
+  member_users: z5.union([z5.array(z5.string().uuid()), z5.null()]).optional(),
+  member_groups: z5.union([z5.array(z5.string().uuid()), z5.null()]).optional()
+});
+var IfExists = z5.enum(["error", "ignore", "replace"]);
+var InvokeParent = z5.union([
+  z5.object({
+    object_type: z5.enum(["project_logs", "experiment", "playground_logs"]),
+    object_id: z5.string(),
+    row_ids: z5.union([
+      z5.object({
+        id: z5.string(),
+        span_id: z5.string(),
+        root_span_id: z5.string()
       }),
-      z.null()
+      z5.null()
     ]).optional(),
-    propagated_event: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+    propagated_event: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional()
   }),
-  z.string()
+  z5.string()
 ]);
-var StreamingMode = z.union([z.enum(["auto", "parallel"]), z.null()]);
+var StreamingMode = z5.union([z5.enum(["auto", "parallel"]), z5.null()]);
 var InvokeFunction = FunctionId.and(
-  z.object({
-    input: z.unknown(),
-    expected: z.unknown(),
-    metadata: z.union([z.object({}).partial().passthrough(), z.null()]),
-    tags: z.union([z.array(z.string()), z.null()]),
-    messages: z.array(ChatCompletionMessageParam),
+  z5.object({
+    input: z5.unknown(),
+    expected: z5.unknown(),
+    metadata: z5.union([z5.object({}).partial().passthrough(), z5.null()]),
+    tags: z5.union([z5.array(z5.string()), z5.null()]),
+    messages: z5.array(ChatCompletionMessageParam),
     parent: InvokeParent,
-    stream: z.union([z.boolean(), z.null()]),
+    stream: z5.union([z5.boolean(), z5.null()]),
     mode: StreamingMode,
-    strict: z.union([z.boolean(), z.null()])
+    strict: z5.union([z5.boolean(), z5.null()])
   }).partial()
 );
-var MessageRole = z.enum([
+var MessageRole = z5.enum([
   "system",
   "user",
   "assistant",
@@ -4316,8 +5282,8 @@ var MessageRole = z.enum([
   "model",
   "developer"
 ]);
-var ObjectReference = z.object({
-  object_type: z.enum([
+var ObjectReference = z5.object({
+  object_type: z5.enum([
     "project_logs",
     "experiment",
     "dataset",
@@ -4325,146 +5291,146 @@ var ObjectReference = z.object({
     "function",
     "prompt_session"
   ]),
-  object_id: z.string().uuid(),
-  id: z.string(),
-  _xact_id: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional()
-});
-var OnlineScoreConfig = z.union([
-  z.object({
-    sampling_rate: z.number().gte(0).lte(1),
-    scorers: z.array(SavedFunctionId),
-    btql_filter: z.union([z.string(), z.null()]).optional(),
-    apply_to_root_span: z.union([z.boolean(), z.null()]).optional(),
-    apply_to_span_names: z.union([z.array(z.string()), z.null()]).optional(),
-    skip_logging: z.union([z.boolean(), z.null()]).optional()
+  object_id: z5.string().uuid(),
+  id: z5.string(),
+  _xact_id: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional()
+});
+var OnlineScoreConfig = z5.union([
+  z5.object({
+    sampling_rate: z5.number().gte(0).lte(1),
+    scorers: z5.array(SavedFunctionId),
+    btql_filter: z5.union([z5.string(), z5.null()]).optional(),
+    apply_to_root_span: z5.union([z5.boolean(), z5.null()]).optional(),
+    apply_to_span_names: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+    skip_logging: z5.union([z5.boolean(), z5.null()]).optional()
   }),
-  z.null()
+  z5.null()
 ]);
-var Organization = z.object({
-  id: z.string().uuid(),
-  name: z.string(),
-  api_url: z.union([z.string(), z.null()]).optional(),
-  is_universal_api: z.union([z.boolean(), z.null()]).optional(),
-  proxy_url: z.union([z.string(), z.null()]).optional(),
-  realtime_url: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional()
-});
-var ProjectSettings = z.union([
-  z.object({
-    comparison_key: z.union([z.string(), z.null()]),
-    baseline_experiment_id: z.union([z.string(), z.null()]),
-    spanFieldOrder: z.union([
-      z.array(
-        z.object({
-          object_type: z.string(),
-          column_id: z.string(),
-          position: z.string(),
-          layout: z.union([z.literal("full"), z.literal("two_column"), z.null()]).optional()
+var Organization = z5.object({
+  id: z5.string().uuid(),
+  name: z5.string(),
+  api_url: z5.union([z5.string(), z5.null()]).optional(),
+  is_universal_api: z5.union([z5.boolean(), z5.null()]).optional(),
+  proxy_url: z5.union([z5.string(), z5.null()]).optional(),
+  realtime_url: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional()
+});
+var ProjectSettings = z5.union([
+  z5.object({
+    comparison_key: z5.union([z5.string(), z5.null()]),
+    baseline_experiment_id: z5.union([z5.string(), z5.null()]),
+    spanFieldOrder: z5.union([
+      z5.array(
+        z5.object({
+          object_type: z5.string(),
+          column_id: z5.string(),
+          position: z5.string(),
+          layout: z5.union([z5.literal("full"), z5.literal("two_column"), z5.null()]).optional()
         })
       ),
-      z.null()
+      z5.null()
     ]),
-    remote_eval_sources: z.union([
-      z.array(
-        z.object({
-          url: z.string(),
-          name: z.string(),
-          description: z.union([z.string(), z.null()]).optional()
+    remote_eval_sources: z5.union([
+      z5.array(
+        z5.object({
+          url: z5.string(),
+          name: z5.string(),
+          description: z5.union([z5.string(), z5.null()]).optional()
         })
       ),
-      z.null()
+      z5.null()
     ])
   }).partial(),
-  z.null()
+  z5.null()
 ]);
-var Project = z.object({
-  id: z.string().uuid(),
-  org_id: z.string().uuid(),
-  name: z.string(),
-  created: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional(),
-  user_id: z.union([z.string(), z.null()]).optional(),
+var Project = z5.object({
+  id: z5.string().uuid(),
+  org_id: z5.string().uuid(),
+  name: z5.string(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
   settings: ProjectSettings.optional()
 });
-var RetentionObjectType = z.enum([
+var RetentionObjectType = z5.enum([
   "project_logs",
   "experiment",
   "dataset"
 ]);
-var ProjectAutomation = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  config: z.union([
-    z.object({
-      event_type: z.literal("logs"),
-      btql_filter: z.string(),
-      interval_seconds: z.number().gte(1).lte(2592e3),
-      action: z.object({ type: z.literal("webhook"), url: z.string() })
+var ProjectAutomation = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  config: z5.union([
+    z5.object({
+      event_type: z5.literal("logs"),
+      btql_filter: z5.string(),
+      interval_seconds: z5.number().gte(1).lte(2592e3),
+      action: z5.object({ type: z5.literal("webhook"), url: z5.string() })
     }),
-    z.object({
-      event_type: z.literal("btql_export"),
-      export_definition: z.union([
-        z.object({ type: z.literal("log_traces") }),
-        z.object({ type: z.literal("log_spans") }),
-        z.object({ type: z.literal("btql_query"), btql_query: z.string() })
+    z5.object({
+      event_type: z5.literal("btql_export"),
+      export_definition: z5.union([
+        z5.object({ type: z5.literal("log_traces") }),
+        z5.object({ type: z5.literal("log_spans") }),
+        z5.object({ type: z5.literal("btql_query"), btql_query: z5.string() })
       ]),
-      export_path: z.string(),
-      format: z.enum(["jsonl", "parquet"]),
-      interval_seconds: z.number().gte(1).lte(2592e3),
-      credentials: z.object({
-        type: z.literal("aws_iam"),
-        role_arn: z.string(),
-        external_id: z.string()
+      export_path: z5.string(),
+      format: z5.enum(["jsonl", "parquet"]),
+      interval_seconds: z5.number().gte(1).lte(2592e3),
+      credentials: z5.object({
+        type: z5.literal("aws_iam"),
+        role_arn: z5.string(),
+        external_id: z5.string()
       }),
-      batch_size: z.union([z.number(), z.null()]).optional()
+      batch_size: z5.union([z5.number(), z5.null()]).optional()
     }),
-    z.object({
-      event_type: z.literal("retention"),
+    z5.object({
+      event_type: z5.literal("retention"),
       object_type: RetentionObjectType,
-      retention_days: z.number().gte(0)
+      retention_days: z5.number().gte(0)
     })
   ])
 });
-var ProjectLogsEvent = z.object({
-  id: z.string(),
-  _xact_id: z.string(),
-  _pagination_key: z.union([z.string(), z.null()]).optional(),
-  created: z.string().datetime({ offset: true }),
-  org_id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  log_id: z.literal("g"),
-  input: z.unknown().optional(),
-  output: z.unknown().optional(),
-  expected: z.unknown().optional(),
-  error: z.unknown().optional(),
-  scores: z.union([z.record(z.union([z.number(), z.null()])), z.null()]).optional(),
-  metadata: z.union([
-    z.object({ model: z.union([z.string(), z.null()]) }).partial().passthrough(),
-    z.null()
+var ProjectLogsEvent = z5.object({
+  id: z5.string(),
+  _xact_id: z5.string(),
+  _pagination_key: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.string().datetime({ offset: true }),
+  org_id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  log_id: z5.literal("g"),
+  input: z5.unknown().optional(),
+  output: z5.unknown().optional(),
+  expected: z5.unknown().optional(),
+  error: z5.unknown().optional(),
+  scores: z5.union([z5.record(z5.union([z5.number(), z5.null()])), z5.null()]).optional(),
+  metadata: z5.union([
+    z5.object({ model: z5.union([z5.string(), z5.null()]) }).partial().passthrough(),
+    z5.null()
   ]).optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional(),
-  metrics: z.union([z.record(z.number()), z.null()]).optional(),
-  context: z.union([
-    z.object({
-      caller_functionname: z.union([z.string(), z.null()]),
-      caller_filename: z.union([z.string(), z.null()]),
-      caller_lineno: z.union([z.number(), z.null()])
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  metrics: z5.union([z5.record(z5.number()), z5.null()]).optional(),
+  context: z5.union([
+    z5.object({
+      caller_functionname: z5.union([z5.string(), z5.null()]),
+      caller_filename: z5.union([z5.string(), z5.null()]),
+      caller_lineno: z5.union([z5.number(), z5.null()])
     }).partial().passthrough(),
-    z.null()
+    z5.null()
   ]).optional(),
-  span_id: z.string(),
-  span_parents: z.union([z.array(z.string()), z.null()]).optional(),
-  root_span_id: z.string(),
-  is_root: z.union([z.boolean(), z.null()]).optional(),
+  span_id: z5.string(),
+  span_parents: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  root_span_id: z5.string(),
+  is_root: z5.union([z5.boolean(), z5.null()]).optional(),
   span_attributes: SpanAttributes.optional(),
   origin: ObjectReferenceNullish.optional()
 });
-var ProjectScoreType = z.enum([
+var ProjectScoreType = z5.enum([
   "slider",
   "categorical",
   "weighted",
@@ -4473,172 +5439,172 @@ var ProjectScoreType = z.enum([
   "online",
   "free-form"
 ]);
-var ProjectScoreCategory = z.object({
-  name: z.string(),
-  value: z.number()
-});
-var ProjectScoreCategories = z.union([
-  z.array(ProjectScoreCategory),
-  z.record(z.number()),
-  z.array(z.string()),
-  z.null()
+var ProjectScoreCategory = z5.object({
+  name: z5.string(),
+  value: z5.number()
+});
+var ProjectScoreCategories = z5.union([
+  z5.array(ProjectScoreCategory),
+  z5.record(z5.number()),
+  z5.array(z5.string()),
+  z5.null()
 ]);
-var ProjectScoreConfig = z.union([
-  z.object({
-    multi_select: z.union([z.boolean(), z.null()]),
-    destination: z.union([z.string(), z.null()]),
+var ProjectScoreConfig = z5.union([
+  z5.object({
+    multi_select: z5.union([z5.boolean(), z5.null()]),
+    destination: z5.union([z5.string(), z5.null()]),
     online: OnlineScoreConfig
   }).partial(),
-  z.null()
+  z5.null()
 ]);
-var ProjectScore = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  user_id: z.string().uuid(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
+var ProjectScore = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  user_id: z5.string().uuid(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
   score_type: ProjectScoreType,
   categories: ProjectScoreCategories.optional(),
   config: ProjectScoreConfig.optional(),
-  position: z.union([z.string(), z.null()]).optional()
-});
-var ProjectTag = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  user_id: z.string().uuid(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  color: z.union([z.string(), z.null()]).optional(),
-  position: z.union([z.string(), z.null()]).optional()
-});
-var Prompt = z.object({
-  id: z.string().uuid(),
-  _xact_id: z.string(),
-  project_id: z.string().uuid(),
-  log_id: z.literal("p"),
-  org_id: z.string().uuid(),
-  name: z.string(),
-  slug: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
+  position: z5.union([z5.string(), z5.null()]).optional()
+});
+var ProjectTag = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  user_id: z5.string().uuid(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  color: z5.union([z5.string(), z5.null()]).optional(),
+  position: z5.union([z5.string(), z5.null()]).optional()
+});
+var Prompt = z5.object({
+  id: z5.string().uuid(),
+  _xact_id: z5.string(),
+  project_id: z5.string().uuid(),
+  log_id: z5.literal("p"),
+  org_id: z5.string().uuid(),
+  name: z5.string(),
+  slug: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
   prompt_data: PromptDataNullish.optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional(),
-  metadata: z.union([z.object({}).partial().passthrough(), z.null()]).optional(),
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional(),
+  metadata: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional(),
   function_type: FunctionTypeEnumNullish.optional()
 });
-var PromptOptions = z.object({ model: z.string(), params: ModelParams, position: z.string() }).partial();
-var PromptSessionEvent = z.object({
-  id: z.string(),
-  _xact_id: z.string(),
-  created: z.string().datetime({ offset: true }),
-  _pagination_key: z.union([z.string(), z.null()]).optional(),
-  project_id: z.string().uuid(),
-  prompt_session_id: z.string().uuid(),
-  prompt_session_data: z.unknown().optional(),
-  prompt_data: z.unknown().optional(),
-  function_data: z.unknown().optional(),
+var PromptOptions = z5.object({ model: z5.string(), params: ModelParams, position: z5.string() }).partial();
+var PromptSessionEvent = z5.object({
+  id: z5.string(),
+  _xact_id: z5.string(),
+  created: z5.string().datetime({ offset: true }),
+  _pagination_key: z5.union([z5.string(), z5.null()]).optional(),
+  project_id: z5.string().uuid(),
+  prompt_session_id: z5.string().uuid(),
+  prompt_session_data: z5.unknown().optional(),
+  prompt_data: z5.unknown().optional(),
+  function_data: z5.unknown().optional(),
   function_type: FunctionTypeEnumNullish.optional(),
-  object_data: z.unknown().optional(),
-  completion: z.unknown().optional(),
-  tags: z.union([z.array(z.string()), z.null()]).optional()
-});
-var ResponseFormat = z.union([
-  z.object({ type: z.literal("json_object") }),
-  z.object({
-    type: z.literal("json_schema"),
+  object_data: z5.unknown().optional(),
+  completion: z5.unknown().optional(),
+  tags: z5.union([z5.array(z5.string()), z5.null()]).optional()
+});
+var ResponseFormat = z5.union([
+  z5.object({ type: z5.literal("json_object") }),
+  z5.object({
+    type: z5.literal("json_schema"),
     json_schema: ResponseFormatJsonSchema
   }),
-  z.object({ type: z.literal("text") })
+  z5.object({ type: z5.literal("text") })
 ]);
-var Role = z.object({
-  id: z.string().uuid(),
-  org_id: z.union([z.string(), z.null()]).optional(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional(),
-  member_permissions: z.union([
-    z.array(
-      z.object({
+var Role = z5.object({
+  id: z5.string().uuid(),
+  org_id: z5.union([z5.string(), z5.null()]).optional(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional(),
+  member_permissions: z5.union([
+    z5.array(
+      z5.object({
         permission: Permission,
         restrict_object_type: AclObjectType.optional()
       })
     ),
-    z.null()
+    z5.null()
   ]).optional(),
-  member_roles: z.union([z.array(z.string().uuid()), z.null()]).optional()
-});
-var RunEval = z.object({
-  project_id: z.string(),
-  data: z.union([
-    z.object({
-      dataset_id: z.string(),
-      _internal_btql: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+  member_roles: z5.union([z5.array(z5.string().uuid()), z5.null()]).optional()
+});
+var RunEval = z5.object({
+  project_id: z5.string(),
+  data: z5.union([
+    z5.object({
+      dataset_id: z5.string(),
+      _internal_btql: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional()
     }),
-    z.object({
-      project_name: z.string(),
-      dataset_name: z.string(),
-      _internal_btql: z.union([z.object({}).partial().passthrough(), z.null()]).optional()
+    z5.object({
+      project_name: z5.string(),
+      dataset_name: z5.string(),
+      _internal_btql: z5.union([z5.object({}).partial().passthrough(), z5.null()]).optional()
     }),
-    z.object({ data: z.array(z.unknown()) })
+    z5.object({ data: z5.array(z5.unknown()) })
   ]),
-  task: FunctionId.and(z.unknown()),
-  scores: z.array(FunctionId),
-  experiment_name: z.string().optional(),
-  metadata: z.object({}).partial().passthrough().optional(),
-  parent: InvokeParent.and(z.unknown()).optional(),
-  stream: z.boolean().optional(),
-  trial_count: z.union([z.number(), z.null()]).optional(),
-  is_public: z.union([z.boolean(), z.null()]).optional(),
-  timeout: z.union([z.number(), z.null()]).optional(),
-  max_concurrency: z.union([z.number(), z.null()]).optional().default(10),
-  base_experiment_name: z.union([z.string(), z.null()]).optional(),
-  base_experiment_id: z.union([z.string(), z.null()]).optional(),
+  task: FunctionId.and(z5.unknown()),
+  scores: z5.array(FunctionId),
+  experiment_name: z5.string().optional(),
+  metadata: z5.object({}).partial().passthrough().optional(),
+  parent: InvokeParent.and(z5.unknown()).optional(),
+  stream: z5.boolean().optional(),
+  trial_count: z5.union([z5.number(), z5.null()]).optional(),
+  is_public: z5.union([z5.boolean(), z5.null()]).optional(),
+  timeout: z5.union([z5.number(), z5.null()]).optional(),
+  max_concurrency: z5.union([z5.number(), z5.null()]).optional().default(10),
+  base_experiment_name: z5.union([z5.string(), z5.null()]).optional(),
+  base_experiment_id: z5.union([z5.string(), z5.null()]).optional(),
   git_metadata_settings: GitMetadataSettings.and(
-    z.union([z.object({}).partial(), z.null()])
+    z5.union([z5.object({}).partial(), z5.null()])
   ).optional(),
-  repo_info: RepoInfo.and(z.unknown()).optional(),
-  strict: z.union([z.boolean(), z.null()]).optional(),
-  stop_token: z.union([z.string(), z.null()]).optional(),
-  extra_messages: z.string().optional(),
-  tags: z.array(z.string()).optional()
-});
-var ServiceToken = z.object({
-  id: z.string().uuid(),
-  created: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  preview_name: z.string(),
-  service_account_id: z.union([z.string(), z.null()]).optional(),
-  service_account_email: z.union([z.string(), z.null()]).optional(),
-  service_account_name: z.union([z.string(), z.null()]).optional(),
-  org_id: z.union([z.string(), z.null()]).optional()
-});
-var SpanIFrame = z.object({
-  id: z.string().uuid(),
-  project_id: z.string().uuid(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional(),
-  name: z.string(),
-  description: z.union([z.string(), z.null()]).optional(),
-  url: z.string(),
-  post_message: z.union([z.boolean(), z.null()]).optional()
-});
-var SSEConsoleEventData = z.object({
-  stream: z.enum(["stderr", "stdout"]),
-  message: z.string()
-});
-var SSEProgressEventData = z.object({
-  id: z.string(),
+  repo_info: RepoInfo.and(z5.unknown()).optional(),
+  strict: z5.union([z5.boolean(), z5.null()]).optional(),
+  stop_token: z5.union([z5.string(), z5.null()]).optional(),
+  extra_messages: z5.string().optional(),
+  tags: z5.array(z5.string()).optional()
+});
+var ServiceToken = z5.object({
+  id: z5.string().uuid(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  preview_name: z5.string(),
+  service_account_id: z5.union([z5.string(), z5.null()]).optional(),
+  service_account_email: z5.union([z5.string(), z5.null()]).optional(),
+  service_account_name: z5.union([z5.string(), z5.null()]).optional(),
+  org_id: z5.union([z5.string(), z5.null()]).optional()
+});
+var SpanIFrame = z5.object({
+  id: z5.string().uuid(),
+  project_id: z5.string().uuid(),
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional(),
+  name: z5.string(),
+  description: z5.union([z5.string(), z5.null()]).optional(),
+  url: z5.string(),
+  post_message: z5.union([z5.boolean(), z5.null()]).optional()
+});
+var SSEConsoleEventData = z5.object({
+  stream: z5.enum(["stderr", "stdout"]),
+  message: z5.string()
+});
+var SSEProgressEventData = z5.object({
+  id: z5.string(),
   object_type: FunctionObjectType,
-  origin: ObjectReferenceNullish.and(z.unknown()).optional(),
+  origin: ObjectReferenceNullish.and(z5.unknown()).optional(),
   format: FunctionFormat,
   output_type: FunctionOutputType,
-  name: z.string(),
-  event: z.enum([
+  name: z5.string(),
+  event: z5.enum([
     "reasoning_delta",
     "text_delta",
     "json_delta",
@@ -4648,110 +5614,110 @@ var SSEProgressEventData = z.object({
     "done",
     "progress"
   ]),
-  data: z.string()
-});
-var ToolFunctionDefinition = z.object({
-  type: z.literal("function"),
-  function: z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    parameters: z.object({}).partial().passthrough().optional(),
-    strict: z.union([z.boolean(), z.null()]).optional()
+  data: z5.string()
+});
+var ToolFunctionDefinition = z5.object({
+  type: z5.literal("function"),
+  function: z5.object({
+    name: z5.string(),
+    description: z5.string().optional(),
+    parameters: z5.object({}).partial().passthrough().optional(),
+    strict: z5.union([z5.boolean(), z5.null()]).optional()
   })
 });
-var User = z.object({
-  id: z.string().uuid(),
-  given_name: z.union([z.string(), z.null()]).optional(),
-  family_name: z.union([z.string(), z.null()]).optional(),
-  email: z.union([z.string(), z.null()]).optional(),
-  avatar_url: z.union([z.string(), z.null()]).optional(),
-  created: z.union([z.string(), z.null()]).optional()
-});
-var ViewDataSearch = z.union([
-  z.object({
-    filter: z.union([z.array(z.unknown()), z.null()]),
-    tag: z.union([z.array(z.unknown()), z.null()]),
-    match: z.union([z.array(z.unknown()), z.null()]),
-    sort: z.union([z.array(z.unknown()), z.null()])
+var User = z5.object({
+  id: z5.string().uuid(),
+  given_name: z5.union([z5.string(), z5.null()]).optional(),
+  family_name: z5.union([z5.string(), z5.null()]).optional(),
+  email: z5.union([z5.string(), z5.null()]).optional(),
+  avatar_url: z5.union([z5.string(), z5.null()]).optional(),
+  created: z5.union([z5.string(), z5.null()]).optional()
+});
+var ViewDataSearch = z5.union([
+  z5.object({
+    filter: z5.union([z5.array(z5.unknown()), z5.null()]),
+    tag: z5.union([z5.array(z5.unknown()), z5.null()]),
+    match: z5.union([z5.array(z5.unknown()), z5.null()]),
+    sort: z5.union([z5.array(z5.unknown()), z5.null()])
   }).partial(),
-  z.null()
+  z5.null()
 ]);
-var ViewData = z.union([
-  z.object({ search: ViewDataSearch }).partial(),
-  z.null()
+var ViewData = z5.union([
+  z5.object({ search: ViewDataSearch }).partial(),
+  z5.null()
 ]);
-var ViewOptions = z.union([
-  z.object({
-    viewType: z.literal("monitor"),
-    options: z.object({
-      spanType: z.union([z.enum(["range", "frame"]), z.null()]),
-      rangeValue: z.union([z.string(), z.null()]),
-      frameStart: z.union([z.string(), z.null()]),
-      frameEnd: z.union([z.string(), z.null()]),
-      tzUTC: z.union([z.boolean(), z.null()]),
-      chartVisibility: z.union([z.record(z.boolean()), z.null()]),
-      projectId: z.union([z.string(), z.null()]),
-      type: z.union([z.enum(["project", "experiment"]), z.null()]),
-      groupBy: z.union([z.string(), z.null()])
+var ViewOptions = z5.union([
+  z5.object({
+    viewType: z5.literal("monitor"),
+    options: z5.object({
+      spanType: z5.union([z5.enum(["range", "frame"]), z5.null()]),
+      rangeValue: z5.union([z5.string(), z5.null()]),
+      frameStart: z5.union([z5.string(), z5.null()]),
+      frameEnd: z5.union([z5.string(), z5.null()]),
+      tzUTC: z5.union([z5.boolean(), z5.null()]),
+      chartVisibility: z5.union([z5.record(z5.boolean()), z5.null()]),
+      projectId: z5.union([z5.string(), z5.null()]),
+      type: z5.union([z5.enum(["project", "experiment"]), z5.null()]),
+      groupBy: z5.union([z5.string(), z5.null()])
     }).partial()
   }),
-  z.object({
-    columnVisibility: z.union([z.record(z.boolean()), z.null()]),
-    columnOrder: z.union([z.array(z.string()), z.null()]),
-    columnSizing: z.union([z.record(z.number()), z.null()]),
-    grouping: z.union([z.string(), z.null()]),
-    rowHeight: z.union([z.string(), z.null()]),
-    tallGroupRows: z.union([z.boolean(), z.null()]),
-    layout: z.union([z.string(), z.null()]),
-    chartHeight: z.union([z.number(), z.null()]),
-    excludedMeasures: z.union([
-      z.array(
-        z.object({
-          type: z.enum(["none", "score", "metric", "metadata"]),
-          value: z.string()
+  z5.object({
+    columnVisibility: z5.union([z5.record(z5.boolean()), z5.null()]),
+    columnOrder: z5.union([z5.array(z5.string()), z5.null()]),
+    columnSizing: z5.union([z5.record(z5.number()), z5.null()]),
+    grouping: z5.union([z5.string(), z5.null()]),
+    rowHeight: z5.union([z5.string(), z5.null()]),
+    tallGroupRows: z5.union([z5.boolean(), z5.null()]),
+    layout: z5.union([z5.string(), z5.null()]),
+    chartHeight: z5.union([z5.number(), z5.null()]),
+    excludedMeasures: z5.union([
+      z5.array(
+        z5.object({
+          type: z5.enum(["none", "score", "metric", "metadata"]),
+          value: z5.string()
         })
       ),
-      z.null()
+      z5.null()
     ]),
-    yMetric: z.union([
-      z.object({
-        type: z.enum(["none", "score", "metric", "metadata"]),
-        value: z.string()
+    yMetric: z5.union([
+      z5.object({
+        type: z5.enum(["none", "score", "metric", "metadata"]),
+        value: z5.string()
       }),
-      z.null()
+      z5.null()
     ]),
-    xAxis: z.union([
-      z.object({
-        type: z.enum(["none", "score", "metric", "metadata"]),
-        value: z.string()
+    xAxis: z5.union([
+      z5.object({
+        type: z5.enum(["none", "score", "metric", "metadata"]),
+        value: z5.string()
       }),
-      z.null()
+      z5.null()
     ]),
-    symbolGrouping: z.union([
-      z.object({
-        type: z.enum(["none", "score", "metric", "metadata"]),
-        value: z.string()
+    symbolGrouping: z5.union([
+      z5.object({
+        type: z5.enum(["none", "score", "metric", "metadata"]),
+        value: z5.string()
       }),
-      z.null()
+      z5.null()
     ]),
-    xAxisAggregation: z.union([z.string(), z.null()]),
-    chartAnnotations: z.union([
-      z.array(z.object({ id: z.string(), text: z.string() })),
-      z.null()
+    xAxisAggregation: z5.union([z5.string(), z5.null()]),
+    chartAnnotations: z5.union([
+      z5.array(z5.object({ id: z5.string(), text: z5.string() })),
+      z5.null()
     ]),
-    timeRangeFilter: z.union([
-      z.string(),
-      z.object({ from: z.string(), to: z.string() }),
-      z.null()
+    timeRangeFilter: z5.union([
+      z5.string(),
+      z5.object({ from: z5.string(), to: z5.string() }),
+      z5.null()
     ])
   }).partial(),
-  z.null()
+  z5.null()
 ]);
-var View = z.object({
-  id: z.string().uuid(),
-  object_type: AclObjectType.and(z.string()),
-  object_id: z.string().uuid(),
-  view_type: z.enum([
+var View = z5.object({
+  id: z5.string().uuid(),
+  object_type: AclObjectType.and(z5.string()),
+  object_id: z5.string().uuid(),
+  view_type: z5.enum([
     "projects",
     "experiments",
     "experiment",
@@ -4766,56 +5732,56 @@ var View = z.object({
     "agents",
     "monitor"
   ]),
-  name: z.string(),
-  created: z.union([z.string(), z.null()]).optional(),
+  name: z5.string(),
+  created: z5.union([z5.string(), z5.null()]).optional(),
   view_data: ViewData.optional(),
   options: ViewOptions.optional(),
-  user_id: z.union([z.string(), z.null()]).optional(),
-  deleted_at: z.union([z.string(), z.null()]).optional()
+  user_id: z5.union([z5.string(), z5.null()]).optional(),
+  deleted_at: z5.union([z5.string(), z5.null()]).optional()
 });
 
 // src/logger.ts
 import { waitUntil } from "@vercel/functions";
 import Mustache2 from "mustache";
-import { z as z3, ZodError } from "zod";
+import { z as z7, ZodError } from "zod";
 
 // src/functions/stream.ts
 import {
   createParser
 } from "eventsource-parser";
-import { z as z2 } from "zod";
-var braintrustStreamChunkSchema = z2.union([
-  z2.object({
-    type: z2.literal("text_delta"),
-    data: z2.string()
+import { z as z6 } from "zod/v3";
+var braintrustStreamChunkSchema = z6.union([
+  z6.object({
+    type: z6.literal("text_delta"),
+    data: z6.string()
   }),
-  z2.object({
-    type: z2.literal("reasoning_delta"),
-    data: z2.string()
+  z6.object({
+    type: z6.literal("reasoning_delta"),
+    data: z6.string()
   }),
-  z2.object({
-    type: z2.literal("json_delta"),
-    data: z2.string()
+  z6.object({
+    type: z6.literal("json_delta"),
+    data: z6.string()
   }),
-  z2.object({
-    type: z2.literal("error"),
-    data: z2.string()
+  z6.object({
+    type: z6.literal("error"),
+    data: z6.string()
   }),
-  z2.object({
-    type: z2.literal("console"),
+  z6.object({
+    type: z6.literal("console"),
     data: SSEConsoleEventData
   }),
-  z2.object({
-    type: z2.literal("progress"),
+  z6.object({
+    type: z6.literal("progress"),
     data: SSEProgressEventData
   }),
-  z2.object({
-    type: z2.literal("start"),
-    data: z2.string()
+  z6.object({
+    type: z6.literal("start"),
+    data: z6.string()
   }),
-  z2.object({
-    type: z2.literal("done"),
-    data: z2.string()
+  z6.object({
+    type: z6.literal("done"),
+    data: z6.string()
   })
 ]);
 var BraintrustStream = class _BraintrustStream {
@@ -5412,7 +6378,6 @@ function objectIsEmpty(obj) {
 }
 
 // src/mustache-utils.ts
-import { getObjValueByPath } from "@braintrust/core";
 import Mustache from "mustache";
 function lintTemplate(template, context2) {
   const variables = getMustacheVars(template);
@@ -5435,7 +6400,6 @@ function getMustacheVars(prompt) {
 }
 
 // src/logger.ts
-import { prettifyXact } from "@braintrust/core";
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
@@ -5523,14 +6487,14 @@ var NoopSpan = class {
 };
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
-var loginSchema = z3.strictObject({
-  appUrl: z3.string(),
-  appPublicUrl: z3.string(),
-  orgName: z3.string(),
-  apiUrl: z3.string(),
-  proxyUrl: z3.string(),
-  loginToken: z3.string(),
-  orgId: z3.string().nullish(),
+var loginSchema = z7.strictObject({
+  appUrl: z7.string(),
+  appPublicUrl: z7.string(),
+  orgName: z7.string(),
+  apiUrl: z7.string(),
+  proxyUrl: z7.string(),
+  loginToken: z7.string(),
+  orgId: z7.string().nullish(),
   gitMetadataSettings: GitMetadataSettings.nullish()
 });
 var stateNonce = 0;
@@ -6007,9 +6971,9 @@ var Attachment = class extends BaseAttachment {
       let signedUrl;
       let headers;
       try {
-        ({ signedUrl, headers } = z3.object({
-          signedUrl: z3.string().url(),
-          headers: z3.record(z3.string())
+        ({ signedUrl, headers } = z7.object({
+          signedUrl: z7.string().url(),
+          headers: z7.record(z7.string())
         }).parse(await metadataResponse.json()));
       } catch (error2) {
         if (error2 instanceof ZodError) {
@@ -6164,8 +7128,8 @@ var ExternalAttachment = class extends BaseAttachment {
     });
   }
 };
-var attachmentMetadataSchema = z3.object({
-  downloadUrl: z3.string(),
+var attachmentMetadataSchema = z7.object({
+  downloadUrl: z7.string(),
   status: AttachmentStatus
 });
 var ReadonlyAttachment = class {
@@ -6377,15 +7341,15 @@ function spanComponentsToObjectIdLambda(state, components) {
     );
   }
   switch (components.data.object_type) {
-    case SpanObjectTypeV3.EXPERIMENT:
+    case 1 /* EXPERIMENT */:
       throw new Error(
         "Impossible: computeObjectMetadataArgs not supported for experiments"
       );
-    case SpanObjectTypeV3.PLAYGROUND_LOGS:
+    case 3 /* PLAYGROUND_LOGS */:
       throw new Error(
         "Impossible: computeObjectMetadataArgs not supported for prompt sessions"
       );
-    case SpanObjectTypeV3.PROJECT_LOGS:
+    case 2 /* PROJECT_LOGS */:
       return async () => (await computeLoggerMetadata(state, {
         ...components.data.compute_object_metadata_args
       })).project.id;
@@ -6537,7 +7501,7 @@ var Logger = class {
     return (async () => (await this.project).id)();
   }
   parentObjectType() {
-    return SpanObjectTypeV3.PROJECT_LOGS;
+    return 2 /* PROJECT_LOGS */;
   }
   /**
    * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
@@ -6631,7 +7595,7 @@ var Logger = class {
         parentSpanIds: args?.parentSpanIds,
         propagatedEvent: args?.propagatedEvent
       }),
-      defaultRootType: SpanTypeAttribute.TASK
+      defaultRootType: "task" /* TASK */
     });
   }
   /**
@@ -7749,6 +8713,8 @@ function getSpanParentObject(options) {
   if (!Object.is(parentSpan, NOOP_SPAN)) {
     return parentSpan;
   }
+  const parentStr = options?.parent ?? state.currentParent.getStore();
+  if (parentStr) return SpanComponentsV3.fromStr(parentStr);
   const experiment = currentExperiment();
   if (experiment) {
     return experiment;
@@ -7965,35 +8931,35 @@ function setFetch(fetch2) {
 }
 function startSpanAndIsLogger(args) {
   const state = args?.state ?? _globalState;
-  const parentStr = args?.parent ?? state.currentParent.getStore();
-  const components = parentStr ? SpanComponentsV3.fromStr(parentStr) : void 0;
-  if (components) {
-    const parentSpanIds = components.data.row_id ? {
-      spanId: components.data.span_id,
-      rootSpanId: components.data.root_span_id
+  const parentObject = getSpanParentObject({
+    asyncFlush: args?.asyncFlush,
+    parent: args?.parent,
+    state
+  });
+  if (parentObject instanceof SpanComponentsV3) {
+    const parentSpanIds = parentObject.data.row_id ? {
+      spanId: parentObject.data.span_id,
+      rootSpanId: parentObject.data.root_span_id
     } : void 0;
     const span = new SpanImpl({
       state,
       ...args,
-      parentObjectType: components.data.object_type,
+      parentObjectType: parentObject.data.object_type,
       parentObjectId: new LazyValue(
-        spanComponentsToObjectIdLambda(state, components)
+        spanComponentsToObjectIdLambda(state, parentObject)
       ),
-      parentComputeObjectMetadataArgs: components.data.compute_object_metadata_args ?? void 0,
+      parentComputeObjectMetadataArgs: parentObject.data.compute_object_metadata_args ?? void 0,
       parentSpanIds,
       propagatedEvent: args?.propagatedEvent ?? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      (components.data.propagated_event ?? void 0)
+      (parentObject.data.propagated_event ?? void 0)
     });
     return {
       span,
-      isSyncFlushLogger: components.data.object_type === SpanObjectTypeV3.PROJECT_LOGS && // Since there's no parent logger here, we're free to choose the async flush
+      isSyncFlushLogger: parentObject.data.object_type === 2 /* PROJECT_LOGS */ && // Since there's no parent logger here, we're free to choose the async flush
       // behavior, and therefore propagate along whatever we get from the arguments
       args?.asyncFlush === false
     };
   } else {
-    const parentObject = getSpanParentObject({
-      asyncFlush: args?.asyncFlush
-    });
     const span = parentObject.startSpan(args);
     return {
       span,
@@ -8143,7 +9109,7 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
 function deepCopyEvent(event) {
   const attachments = [];
   const IDENTIFIER = "_bt_internal_saved_attachment";
-  const savedAttachmentSchema = z3.strictObject({ [IDENTIFIER]: z3.number() });
+  const savedAttachmentSchema = z7.strictObject({ [IDENTIFIER]: z7.number() });
   const serialized = JSON.stringify(event, (_k, v) => {
     if (v instanceof SpanImpl || v instanceof NoopSpan) {
       return `<span>`;
@@ -8378,7 +9344,7 @@ var Experiment2 = class extends ObjectFetcher {
     })();
   }
   parentObjectType() {
-    return SpanObjectTypeV3.EXPERIMENT;
+    return 1 /* EXPERIMENT */;
   }
   async getState() {
     await this.lazyMetadata.get();
@@ -8462,7 +9428,7 @@ var Experiment2 = class extends ObjectFetcher {
         parentSpanIds: void 0,
         propagatedEvent: args?.propagatedEvent
       }),
-      defaultRootType: SpanTypeAttribute.EVAL
+      defaultRootType: "eval" /* EVAL */
     });
   }
   async fetchBaseExperiment() {
@@ -8881,7 +9847,7 @@ var SpanImpl = class _SpanImpl {
     const baseUrl = `${appUrl}/app/${orgName}`;
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
-      case SpanObjectTypeV3.PROJECT_LOGS: {
+      case 2 /* PROJECT_LOGS */: {
         const projectID = args?.project_id || this.parentObjectId.getSync().value;
         const projectName = args?.project_name;
         if (projectID) {
@@ -8892,7 +9858,7 @@ var SpanImpl = class _SpanImpl {
           return getErrPermlink("provide-project-name-or-id");
         }
       }
-      case SpanObjectTypeV3.EXPERIMENT: {
+      case 1 /* EXPERIMENT */: {
         const expID = args?.experiment_id || this.parentObjectId?.getSync()?.value;
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
@@ -8900,7 +9866,7 @@ var SpanImpl = class _SpanImpl {
           return `${baseUrl}/object?object_type=experiment&object_id=${expID}&id=${this._id}`;
         }
       }
-      case SpanObjectTypeV3.PLAYGROUND_LOGS: {
+      case 3 /* PLAYGROUND_LOGS */: {
         return NOOP_SPAN_PERMALINK;
       }
       default: {
@@ -9148,8 +10114,8 @@ var Dataset2 = class extends ObjectFetcher {
     )}`;
     let dataSummary;
     if (summarizeData) {
-      const rawDataSummary = z3.object({
-        total_records: z3.number()
+      const rawDataSummary = z7.object({
+        total_records: z7.number()
       }).parse(
         await state.apiConn().get_json(
           "dataset-summary",
@@ -9272,11 +10238,11 @@ function renderTemplatedObject(obj, args, options) {
   return obj;
 }
 function renderPromptParams(params, args, options) {
-  const schemaParsed = z3.object({
-    response_format: z3.object({
-      type: z3.literal("json_schema"),
+  const schemaParsed = z7.object({
+    response_format: z7.object({
+      type: z7.literal("json_schema"),
       json_schema: ResponseFormatJsonSchema.omit({ schema: true }).extend({
-        schema: z3.unknown()
+        schema: z7.unknown()
       })
     })
   }).safeParse(params);
@@ -9394,7 +10360,7 @@ var Prompt2 = class _Prompt {
     if (!prompt) {
       throw new Error("Empty prompt");
     }
-    const dictArgParsed = z3.record(z3.unknown()).safeParse(buildArgs);
+    const dictArgParsed = z7.record(z7.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -9449,7 +10415,7 @@ var Prompt2 = class _Prompt {
         return JSON.stringify(v);
       }
     };
-    const dictArgParsed = z3.record(z3.unknown()).safeParse(buildArgs);
+    const dictArgParsed = z7.record(z7.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -9725,6 +10691,7 @@ __export(exports_node_exports, {
   withExperiment: () => withExperiment,
   withLogger: () => withLogger,
   withParent: () => withParent,
+  wrapAISDK: () => wrapAISDK,
   wrapAISDKModel: () => wrapAISDKModel,
   wrapAnthropic: () => wrapAnthropic,
   wrapOpenAI: () => wrapOpenAI,
@@ -9820,9 +10787,6 @@ function initFunction({
   return f;
 }
 
-// src/framework.ts
-import { SpanTypeAttribute as SpanTypeAttribute2, mergeDicts as mergeDicts2 } from "@braintrust/core";
-
 // ../../node_modules/.pnpm/async@3.2.5/node_modules/async/dist/async.mjs
 function initialParams(fn) {
   return function(...args) {
@@ -10902,13 +11866,12 @@ var BarProgressReporter = class {
 };
 
 // src/eval-parameters.ts
-import { z as z5 } from "zod";
+import { z as z9 } from "zod/v3";
 
 // src/framework2.ts
 import path2 from "path";
 import slugifyLib from "slugify";
-import { z as z4 } from "zod";
-import { loadPrettyXact } from "@braintrust/core";
+import { z as z8 } from "zod/v3";
 var ProjectBuilder = class {
   create(opts) {
     return new Project2(opts);
@@ -11142,23 +12105,23 @@ var CodePrompt = class {
     };
   }
 };
-var promptContentsSchema = z4.union([
-  z4.object({
-    prompt: z4.string()
+var promptContentsSchema = z8.union([
+  z8.object({
+    prompt: z8.string()
   }),
-  z4.object({
-    messages: z4.array(ChatCompletionMessageParam)
+  z8.object({
+    messages: z8.array(ChatCompletionMessageParam)
   })
 ]);
 var promptDefinitionSchema = promptContentsSchema.and(
-  z4.object({
-    model: z4.string(),
+  z8.object({
+    model: z8.string(),
     params: ModelParams.optional()
   })
 );
 var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
-  z4.object({
-    tools: z4.array(ToolFunctionDefinition).optional()
+  z8.object({
+    tools: z8.array(ToolFunctionDefinition).optional()
   })
 );
 var PromptBuilder = class {
@@ -11226,7 +12189,7 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
         project_name: projectName
       });
-      const result = z4.object({
+      const result = z8.object({
         project: Project
       }).parse(response);
       const projectId = result.project.id;
@@ -11240,7 +12203,7 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
         id: projectId
       });
-      const result = z4.array(Project).nonempty().parse(response);
+      const result = z8.array(Project).nonempty().parse(response);
       const projectName = result[0].name;
       this.idToName[projectId] = projectName;
       this.nameToId[projectName] = projectId;
@@ -11256,15 +12219,15 @@ var ProjectNameIdMap = class {
 };
 
 // src/eval-parameters.ts
-var evalParametersSchema = z5.record(
-  z5.string(),
-  z5.union([
-    z5.object({
-      type: z5.literal("prompt"),
+var evalParametersSchema = z9.record(
+  z9.string(),
+  z9.union([
+    z9.object({
+      type: z9.literal("prompt"),
       default: promptDefinitionWithToolsSchema.optional(),
-      description: z5.string().optional()
+      description: z9.string().optional()
     }),
-    z5.instanceof(z5.ZodType)
+    z9.instanceof(z9.ZodType)
     // For Zod schemas
   ])
 );
@@ -11566,7 +12529,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       const baseEvent = {
         name: "eval",
         spanAttributes: {
-          type: SpanTypeAttribute2.EVAL
+          type: "eval" /* EVAL */
         },
         event: {
           input: datum.input,
@@ -11626,7 +12589,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             },
             {
               name: "task",
-              spanAttributes: { type: SpanTypeAttribute2.TASK },
+              spanAttributes: { type: "task" /* TASK */ },
               event: { input: datum.input }
             }
           );
@@ -11672,17 +12635,17 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                     return rest;
                   };
                   const resultMetadata = results3.length === 1 ? results3[0].metadata : results3.reduce(
-                    (prev, s) => mergeDicts2(prev, {
+                    (prev, s) => mergeDicts(prev, {
                       [s.name]: s.metadata
                     }),
                     {}
                   );
                   const resultOutput = results3.length === 1 ? getOtherFields(results3[0]) : results3.reduce(
-                    (prev, s) => mergeDicts2(prev, { [s.name]: getOtherFields(s) }),
+                    (prev, s) => mergeDicts(prev, { [s.name]: getOtherFields(s) }),
                     {}
                   );
                   const scores2 = results3.reduce(
-                    (prev, s) => mergeDicts2(prev, { [s.name]: s.score }),
+                    (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
                     {}
                   );
                   span.log({
@@ -11695,7 +12658,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                 const results2 = await rootSpan.traced(runScorer, {
                   name: scorerNames[score_idx],
                   spanAttributes: {
-                    type: SpanTypeAttribute2.SCORE
+                    type: "score" /* SCORE */
                   },
                   event: { input: scoringArgs }
                 });
@@ -12038,11 +13001,11 @@ var GraphBuilder = class {
   // }
   // Helper to generate node IDs
   generateId(name) {
-    const uuid = newId();
+    const uuid4 = newId();
     if (name) {
-      return `${name}-${uuid.slice(0, 8)}`;
+      return `${name}-${uuid4.slice(0, 8)}`;
     } else {
-      return uuid;
+      return uuid4;
     }
   }
   // Create an input node
@@ -12195,12 +13158,7 @@ function unescapePath(path3) {
 }
 var graph_framework_default = { createGraph };
 
-// src/wrappers/oai.ts
-import { SpanTypeAttribute as SpanTypeAttribute3 } from "@braintrust/core";
-import { mergeDicts as mergeDicts3 } from "@braintrust/core";
-
 // src/wrappers/oai_responses.ts
-import { isObject as isObject2 } from "@braintrust/core";
 function responsesProxy(openai) {
   if (!openai.responses) {
     return openai;
@@ -12228,19 +13186,15 @@ function responsesCreateProxy(target) {
   return proxyCreate(target, hooks);
 }
 function parseSpanFromResponseCreateParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.create",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -12252,25 +13206,29 @@ function parseSpanFromResponseCreateParams(params) {
   };
 }
 function parseEventFromResponseCreateResult(result) {
-  return {
-    output: result?.output_text || "",
-    metrics: parseMetricsFromUsage(result?.usage)
-  };
+  const data = {};
+  if (result?.output !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(result?.usage);
+  return data;
 }
 function parseSpanFromResponseParseParams(params) {
-  const input = [{ role: "user", content: params.input }];
-  if (params.instructions) {
-    input.push({ role: "system", content: params.instructions });
-  }
   const spanArgs = {
     name: "openai.responses.parse",
     spanAttributes: {
       type: "llm"
     },
     event: {
-      input,
+      input: params.input,
       metadata: {
-        ...filterFrom(params, ["input", "instructions"]),
+        ...filterFrom(params, ["input"]),
         provider: "openai"
       }
     },
@@ -12282,10 +13240,18 @@ function parseSpanFromResponseParseParams(params) {
   };
 }
 function parseEventFromResponseParseResult(result) {
-  return {
-    output: result?.output_parsed || result?.output_text || "",
-    metrics: parseMetricsFromUsage(result?.usage)
-  };
+  const data = {};
+  if (result?.output !== void 0) {
+    data.output = result.output;
+  }
+  if (result) {
+    const { output, usage, ...metadata } = result;
+    if (Object.keys(metadata).length > 0) {
+      data.metadata = metadata;
+    }
+  }
+  data.metrics = parseMetricsFromUsage(result?.usage);
+  return data;
 }
 function traceResponseCreateStream(stream, timedSpan) {
   const span = timedSpan.span;
@@ -12318,18 +13284,18 @@ function parseLogFromItem(item) {
   const response = item.response;
   switch (item.type) {
     case "response.completed":
-      const texts = [];
-      for (const output of response?.output || []) {
-        for (const content of output?.content || []) {
-          if (content?.type === "output_text") {
-            texts.push(content.text);
-          }
+      const data = {};
+      if (response?.output !== void 0) {
+        data.output = response.output;
+      }
+      if (response) {
+        const { usage, output, ...metadata } = response;
+        if (Object.keys(metadata).length > 0) {
+          data.metadata = metadata;
         }
       }
-      return {
-        output: texts.join(""),
-        metrics: parseMetricsFromUsage(response?.usage)
-      };
+      data.metrics = parseMetricsFromUsage(response?.usage);
+      return data;
     default:
       return {};
   }
@@ -12390,7 +13356,7 @@ function parseMetricsFromUsage(usage) {
       const metricName = TOKEN_NAME_MAP[oai_name] || oai_name;
       metrics[metricName] = value;
     } else if (oai_name.endsWith("_tokens_details")) {
-      if (!isObject2(value)) {
+      if (!isObject(value)) {
         continue;
       }
       const rawPrefix = oai_name.slice(0, -"_tokens_details".length);
@@ -12572,11 +13538,11 @@ function wrapBetaChatCompletionParse(completion) {
   return async (allParams) => {
     const { span_info: _, ...params } = allParams;
     const span = startSpan(
-      mergeDicts3(
+      mergeDicts(
         {
           name: "Chat Completion",
           spanAttributes: {
-            type: SpanTypeAttribute3.LLM
+            type: "llm" /* LLM */
           }
         },
         parseChatCompletionParams(allParams)
@@ -12596,11 +13562,11 @@ function wrapBetaChatCompletionStream(completion) {
   return (allParams) => {
     const { span_info: _, ...params } = allParams;
     const span = startSpan(
-      mergeDicts3(
+      mergeDicts(
         {
           name: "Chat Completion",
           spanAttributes: {
-            type: SpanTypeAttribute3.LLM
+            type: "llm" /* LLM */
           }
         },
         parseChatCompletionParams(allParams)
@@ -12656,55 +13622,83 @@ function logHeaders(response, span) {
   }
 }
 function wrapChatCompletion(completion) {
-  return async (allParams, options) => {
+  return (allParams, options) => {
     const { span_info: _, ...params } = allParams;
-    const span = startSpan(
-      mergeDicts3(
-        {
-          name: "Chat Completion",
-          spanAttributes: {
-            type: SpanTypeAttribute3.LLM
+    let executionPromise = null;
+    let dataPromise = null;
+    const ensureExecuted = () => {
+      if (!executionPromise) {
+        executionPromise = (async () => {
+          const span = startSpan(
+            mergeDicts(
+              {
+                name: "Chat Completion",
+                spanAttributes: {
+                  type: "llm" /* LLM */
+                }
+              },
+              parseChatCompletionParams(allParams)
+            )
+          );
+          const startTime = getCurrentUnixTimestamp();
+          if (params.stream) {
+            const { data: ret, response } = await completion(
+              // We could get rid of this type coercion if we could somehow enforce
+              // that `P extends ChatParams` BUT does not have the property
+              // `span_info`.
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              params,
+              options
+            ).withResponse();
+            logHeaders(response, span);
+            const wrapperStream = new WrapperStream(
+              span,
+              startTime,
+              ret.iterator()
+            );
+            ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
+            return { data: ret, response };
+          } else {
+            try {
+              const completionResponse = completion(
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                params,
+                options
+              );
+              const { data: ret, response } = await completionResponse.withResponse();
+              logHeaders(response, span);
+              const { messages, ...rest } = params;
+              span.log({
+                input: messages,
+                metadata: {
+                  ...rest
+                }
+              });
+              logCompletionResponse(startTime, ret, span);
+              return { data: ret, response };
+            } finally {
+              span.end();
+            }
           }
-        },
-        parseChatCompletionParams(allParams)
-      )
-    );
-    const startTime = getCurrentUnixTimestamp();
-    if (params.stream) {
-      const { data: ret, response } = await completion(
-        // We could get rid of this type coercion if we could somehow enforce
-        // that `P extends ChatParams` BUT does not have the property
-        // `span_info`.
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        params,
-        options
-      ).withResponse();
-      logHeaders(response, span);
-      const wrapperStream = new WrapperStream(span, startTime, ret.iterator());
-      ret.iterator = () => wrapperStream[Symbol.asyncIterator]();
-      return ret;
-    } else {
-      try {
-        const completionResponse = completion(
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          params,
-          options
-        );
-        const { data: ret, response } = await completionResponse.withResponse();
-        logHeaders(response, span);
-        const { messages, ...rest } = params;
-        span.log({
-          input: messages,
-          metadata: {
-            ...rest
+        })();
+      }
+      return executionPromise;
+    };
+    return new Proxy({}, {
+      get(target, prop, receiver) {
+        if (prop === "withResponse") {
+          return () => ensureExecuted();
+        }
+        if (prop === "then" || prop === "catch" || prop === "finally" || prop in Promise.prototype) {
+          if (!dataPromise) {
+            dataPromise = ensureExecuted().then((result) => result.data);
           }
-        });
-        logCompletionResponse(startTime, ret, span);
-        return ret;
-      } finally {
-        span.end();
+          const value = Reflect.get(dataPromise, prop, receiver);
+          return typeof value === "function" ? value.bind(dataPromise) : value;
+        }
+        return Reflect.get(target, prop, receiver);
       }
-    }
+    });
   };
 }
 function parseBaseParams(allParams, inputField) {
@@ -12719,7 +13713,7 @@ function parseBaseParams(allParams, inputField) {
   const input = params[inputField];
   const paramsRest = { ...params, provider: "openai" };
   delete paramsRest[inputField];
-  return mergeDicts3(ret, { event: { input, metadata: paramsRest } });
+  return mergeDicts(ret, { event: { input, metadata: paramsRest } });
 }
 function createApiWrapper(name, create, processResponse, parseParams) {
   return async (allParams, options) => {
@@ -12734,11 +13728,11 @@ function createApiWrapper(name, create, processResponse, parseParams) {
         processResponse(result, span);
         return result;
       },
-      mergeDicts3(
+      mergeDicts(
         {
           name,
           spanAttributes: {
-            type: SpanTypeAttribute3.LLM
+            type: "llm" /* LLM */
           }
         },
         parseParams(allParams)
@@ -12876,9 +13870,6 @@ var WrapperStream = class {
   }
 };
 
-// src/wrappers/ai-sdk-v2.ts
-import { SpanTypeAttribute as SpanTypeAttribute4 } from "@braintrust/core";
-
 // src/wrappers/anthropic-tokens-util.ts
 function finalizeAnthropicTokens(metrics) {
   const prompt_tokens = (metrics.prompt_tokens || 0) + (metrics.prompt_cached_tokens || 0) + (metrics.prompt_cache_creation_tokens || 0);
@@ -12899,7 +13890,7 @@ function extractAnthropicCacheTokens(cacheReadTokens = 0, cacheCreationTokens =
   return cacheTokens;
 }
 
-// src/wrappers/ai-sdk-v2.ts
+// src/wrappers/ai-sdk-shared.ts
 function detectProviderFromResult(result) {
   if (!result?.providerMetadata) {
     return void 0;
@@ -12919,20 +13910,8 @@ function extractModelFromResult(result) {
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
-function extractModelParameters(params) {
+function extractModelParameters(params, excludeKeys) {
   const modelParams = {};
-  const excludeKeys = /* @__PURE__ */ new Set([
-    "prompt",
-    // Already captured as input
-    "system",
-    // Already captured as input
-    "messages",
-    // Already captured as input
-    "model",
-    // Already captured in metadata.model
-    "providerOptions"
-    // Internal AI SDK configuration
-  ]);
   for (const [key, value] of Object.entries(params)) {
     if (value !== void 0 && !excludeKeys.has(key)) {
       const snakeKey = camelToSnake(key);
@@ -12988,18 +13967,128 @@ function normalizeUsageMetrics(usage, provider, providerMetadata) {
   }
   return metrics;
 }
+function normalizeFinishReason(reason) {
+  if (typeof reason !== "string") return void 0;
+  return reason.replace(/-/g, "_");
+}
+function extractToolCallsFromSteps(steps) {
+  const toolCalls = [];
+  if (!Array.isArray(steps)) return toolCalls;
+  let idx = 0;
+  for (const step of steps) {
+    const blocks = step?.content;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (block && typeof block === "object" && block.type === "tool-call") {
+        toolCalls.push({
+          id: block.toolCallId,
+          type: "function",
+          index: idx++,
+          function: {
+            name: block.toolName,
+            arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {})
+          }
+        });
+      }
+    }
+  }
+  return toolCalls;
+}
+function buildAssistantOutputWithToolCalls(result, toolCalls) {
+  return [
+    {
+      index: 0,
+      logprobs: null,
+      finish_reason: normalizeFinishReason(result?.finishReason) ?? (toolCalls.length ? "tool_calls" : void 0),
+      message: {
+        role: "assistant",
+        tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+      }
+    }
+  ];
+}
+function extractToolCallsFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  return extractToolCallsFromSteps([{ content: blocks }]);
+}
+function wrapTools(tools) {
+  if (!tools) return tools;
+  const inferName = (tool, fallback2) => tool && (tool.name || tool.toolName || tool.id) || fallback2;
+  if (Array.isArray(tools)) {
+    const arr = tools;
+    const out = arr.map((tool, idx) => {
+      if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
+        const name = inferName(tool, `tool[${idx}]`);
+        return {
+          ...tool,
+          execute: wrapTraced(tool.execute.bind(tool), {
+            name,
+            type: "tool"
+          })
+        };
+      }
+      return tool;
+    });
+    return out;
+  }
+  const wrappedTools = {};
+  for (const [key, tool] of Object.entries(tools)) {
+    if (tool != null && typeof tool === "object" && "execute" in tool && typeof tool.execute === "function") {
+      wrappedTools[key] = {
+        ...tool,
+        execute: wrapTraced(tool.execute.bind(tool), {
+          name: key,
+          type: "tool"
+        })
+      };
+    } else {
+      wrappedTools[key] = tool;
+    }
+  }
+  return wrappedTools;
+}
+function extractInput(params) {
+  return params?.prompt ?? params?.messages ?? params?.system;
+}
+function wrapStreamObject(iterable, onFirst) {
+  let sawFirst = false;
+  async function* wrapStream() {
+    for await (const chunk of iterable) {
+      if (!sawFirst) {
+        sawFirst = true;
+        onFirst();
+      }
+      yield chunk;
+    }
+  }
+  return wrapStream();
+}
+
+// src/wrappers/ai-sdk-v2.ts
+var V2_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
+  "prompt",
+  // Already captured as input
+  "system",
+  // Already captured as input
+  "messages",
+  // Already captured as input
+  "model",
+  // Already captured in metadata.model
+  "providerOptions"
+  // Internal AI SDK configuration
+]);
 function BraintrustMiddleware(config = {}) {
   return {
     wrapGenerate: async ({ doGenerate, params }) => {
       const spanArgs = {
         name: "ai-sdk.generateText",
         spanAttributes: {
-          type: SpanTypeAttribute4.LLM
+          type: "llm" /* LLM */
         },
         event: {
           input: params.prompt,
           metadata: {
-            ...extractModelParameters(params)
+            ...extractModelParameters(params, V2_EXCLUDE_KEYS)
           }
         }
       };
@@ -13018,8 +14107,12 @@ function BraintrustMiddleware(config = {}) {
         if (model !== void 0) {
           metadata.model = model;
         }
+        let toolCalls = extractToolCallsFromSteps(result?.steps);
+        if (!toolCalls || toolCalls.length === 0) {
+          toolCalls = extractToolCallsFromBlocks(result?.content);
+        }
         span.log({
-          output: result.content,
+          output: toolCalls.length > 0 ? buildAssistantOutputWithToolCalls(result, toolCalls) : result?.content,
           metadata,
           metrics: normalizeUsageMetrics(
             result.usage,
@@ -13041,12 +14134,12 @@ function BraintrustMiddleware(config = {}) {
       const spanArgs = {
         name: "ai-sdk.streamText",
         spanAttributes: {
-          type: SpanTypeAttribute4.LLM
+          type: "llm" /* LLM */
         },
         event: {
           input: params.prompt,
           metadata: {
-            ...extractModelParameters(params)
+            ...extractModelParameters(params, V2_EXCLUDE_KEYS)
           }
         }
       };
@@ -13054,6 +14147,7 @@ function BraintrustMiddleware(config = {}) {
       try {
         const { stream, ...rest } = await doStream();
         const textChunks = [];
+        const toolBlocks = [];
         let finalUsage = {};
         let finalFinishReason = void 0;
         let providerMetadata = {};
@@ -13064,6 +14158,9 @@ function BraintrustMiddleware(config = {}) {
               if (chunk.type === "text-delta" && chunk.delta) {
                 textChunks.push(chunk.delta);
               }
+              if (chunk.type === "tool-call" || chunk.type === "tool-result") {
+                toolBlocks.push(chunk);
+              }
               if (chunk.type === "finish") {
                 finalFinishReason = chunk.finishReason;
                 finalUsage = chunk.usage || {};
@@ -13081,11 +14178,12 @@ function BraintrustMiddleware(config = {}) {
           flush() {
             try {
               const generatedText = textChunks.join("");
-              const output = generatedText ? [{ type: "text", text: generatedText }] : [];
+              let output = generatedText ? [{ type: "text", text: generatedText }] : [];
               const resultForDetection = {
                 providerMetadata,
                 response: rest.response,
-                ...rest
+                ...rest,
+                finishReason: finalFinishReason
               };
               const metadata = {};
               const provider = detectProviderFromResult(resultForDetection);
@@ -13099,6 +14197,17 @@ function BraintrustMiddleware(config = {}) {
               if (model !== void 0) {
                 metadata.model = model;
               }
+              if (toolBlocks.length > 0) {
+                const toolCalls = extractToolCallsFromSteps([
+                  { content: toolBlocks }
+                ]);
+                if (toolCalls.length > 0) {
+                  output = buildAssistantOutputWithToolCalls(
+                    resultForDetection,
+                    toolCalls
+                  );
+                }
+              }
               span.log({
                 output,
                 metadata,
@@ -13408,8 +14517,245 @@ function postProcessOutput(text, toolCalls, finishReason) {
   ];
 }
 
+// src/wrappers/ai-sdk-v3.ts
+var V3_EXCLUDE_KEYS = /* @__PURE__ */ new Set([
+  "prompt",
+  // Already captured as input
+  "system",
+  // Already captured as input
+  "messages",
+  // Already captured as input
+  "model",
+  // Already captured in metadata.model
+  "providerOptions",
+  // Internal AI SDK configuration
+  "tools"
+  // Already captured in metadata.tools
+]);
+function wrapAISDK(ai) {
+  const {
+    wrapLanguageModel,
+    generateText,
+    streamText,
+    generateObject,
+    streamObject
+  } = ai;
+  const wrappedGenerateText = (params) => {
+    return traced(
+      async (span) => {
+        const wrappedModel = wrapLanguageModel({
+          model: params.model,
+          middleware: BraintrustMiddleware()
+        });
+        const result = await generateText({
+          ...params,
+          tools: params.tools ? wrapTools(params.tools) : void 0,
+          model: wrappedModel
+        });
+        const provider = detectProviderFromResult(result);
+        const model = extractModelFromResult(result);
+        const finishReason = normalizeFinishReason(result?.finishReason);
+        span.log({
+          input: extractInput(params),
+          output: result.text,
+          metadata: {
+            ...extractModelParameters(params, V3_EXCLUDE_KEYS),
+            ...provider ? { provider } : {},
+            ...model ? { model } : {},
+            ...finishReason ? { finish_reason: finishReason } : {}
+          }
+        });
+        return result;
+      },
+      {
+        name: "ai-sdk.generateText"
+      }
+    );
+  };
+  const wrappedGenerateObject = (params) => {
+    return traced(
+      async (span) => {
+        const wrappedModel = wrapLanguageModel({
+          model: params.model,
+          middleware: BraintrustMiddleware()
+        });
+        const result = await generateObject({
+          ...params,
+          tools: params.tools ? wrapTools(params.tools) : void 0,
+          model: wrappedModel
+        });
+        const provider = detectProviderFromResult(result);
+        const model = extractModelFromResult(result);
+        const finishReason = normalizeFinishReason(result.finishReason);
+        span.log({
+          input: extractInput(params),
+          output: result.object,
+          metadata: {
+            ...extractModelParameters(params, V3_EXCLUDE_KEYS),
+            ...provider ? { provider } : {},
+            ...model ? { model } : {},
+            ...finishReason ? { finish_reason: finishReason } : {}
+          }
+        });
+        return result;
+      },
+      {
+        name: "ai-sdk.generateObject"
+      }
+    );
+  };
+  const wrappedStreamText = (params) => {
+    const span = startSpan({
+      name: "ai-sdk.streamText",
+      event: {
+        input: extractInput(params),
+        metadata: extractModelParameters(params, V3_EXCLUDE_KEYS)
+      }
+    });
+    const userOnFinish = params.onFinish;
+    const userOnError = params.onError;
+    const userOnChunk = params.onChunk;
+    try {
+      const wrappedModel = wrapLanguageModel({
+        model: params.model,
+        middleware: BraintrustMiddleware()
+      });
+      const startTime = Date.now();
+      let receivedFirst = false;
+      const result = withCurrent(
+        span,
+        () => streamText({
+          ...params,
+          tools: params.tools ? wrapTools(params.tools) : void 0,
+          model: wrappedModel,
+          onChunk: (chunk) => {
+            if (!receivedFirst) {
+              receivedFirst = true;
+              span.log({
+                metrics: {
+                  time_to_first_token: (Date.now() - startTime) / 1e3
+                }
+              });
+            }
+            if (typeof userOnChunk === "function") {
+              userOnChunk(chunk);
+            }
+          },
+          onFinish: async (event) => {
+            if (typeof userOnFinish === "function") {
+              await userOnFinish(event);
+            }
+            const provider = detectProviderFromResult(event);
+            const model = extractModelFromResult(event);
+            const finishReason = normalizeFinishReason(event?.finishReason);
+            span.log({
+              output: event?.text,
+              metadata: {
+                ...extractModelParameters(params, V3_EXCLUDE_KEYS),
+                ...provider ? { provider } : {},
+                ...model ? { model } : {},
+                ...finishReason ? { finish_reason: finishReason } : {}
+              }
+            });
+            span.end();
+          },
+          onError: async (err) => {
+            if (typeof userOnError === "function") {
+              await userOnError(err);
+            }
+            span.log({
+              error: err instanceof Error ? err.message : String(err)
+            });
+            span.end();
+          }
+        })
+      );
+      return result;
+    } catch (error2) {
+      span.log({
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+      span.end();
+      throw error2;
+    }
+  };
+  const wrappedStreamObject = (params) => {
+    const span = startSpan({
+      name: "ai-sdk.streamObject",
+      event: {
+        input: extractInput(params),
+        metadata: extractModelParameters(params, V3_EXCLUDE_KEYS)
+      }
+    });
+    const userOnFinish = params.onFinish;
+    const userOnError = params.onError;
+    try {
+      const wrappedModel = wrapLanguageModel({
+        model: params.model,
+        middleware: BraintrustMiddleware()
+      });
+      const startTime = Date.now();
+      const result = withCurrent(
+        span,
+        () => streamObject({
+          ...params,
+          tools: params.tools ? wrapTools(params.tools) : void 0,
+          model: wrappedModel,
+          onFinish: async (event) => {
+            if (typeof userOnFinish === "function") {
+              await userOnFinish(event);
+            }
+            const provider = detectProviderFromResult(event);
+            const model = extractModelFromResult(event);
+            const finishReason = normalizeFinishReason(event?.finishReason);
+            span.log({
+              output: event?.object,
+              metadata: {
+                ...extractModelParameters(params, V3_EXCLUDE_KEYS),
+                ...provider ? { provider } : {},
+                ...model ? { model } : {},
+                ...finishReason ? { finish_reason: finishReason } : {}
+              }
+            });
+            span.end();
+          },
+          onError: async (err) => {
+            if (typeof userOnError === "function") {
+              await userOnError(err);
+            }
+            span.log({
+              error: err instanceof Error ? err.message : String(err)
+            });
+            span.end();
+          }
+        })
+      );
+      const wrapStream = wrapStreamObject(result.partialObjectStream, () => {
+        span.log({
+          metrics: { time_to_first_token: (Date.now() - startTime) / 1e3 }
+        });
+      });
+      return {
+        ...result,
+        partialObjectStream: wrapStream
+      };
+    } catch (error2) {
+      span.log({
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+      span.end();
+      throw error2;
+    }
+  };
+  return {
+    generateText: wrappedGenerateText,
+    generateObject: wrappedGenerateObject,
+    streamText: wrappedStreamText,
+    streamObject: wrappedStreamObject
+  };
+}
+
 // src/wrappers/anthropic.ts
-import { SpanTypeAttribute as SpanTypeAttribute5 } from "@braintrust/core";
 function wrapAnthropic(anthropic) {
   const au = anthropic;
   if (au && typeof au === "object" && "messages" in au && typeof au.messages === "object" && au.messages && "create" in au.messages) {
@@ -13467,7 +14813,7 @@ function createProxy(create) {
       const spanArgs = {
         name: "anthropic.messages.create",
         spanAttributes: {
-          type: SpanTypeAttribute5.LLM
+          type: "llm" /* LLM */
         },
         event: {
           input,
@@ -13811,6 +15157,15 @@ var BraintrustSpanProcessor = class _BraintrustSpanProcessor {
                 if (!span.instrumentationScope && span.instrumentationLibrary) {
                   span.instrumentationScope = span.instrumentationLibrary;
                 }
+                if (!span.parentSpanContext && span.parentSpanId) {
+                  const spanContext = span.spanContext?.();
+                  if (spanContext?.traceId) {
+                    span.parentSpanContext = {
+                      spanId: span.parentSpanId,
+                      traceId: spanContext.traceId
+                    };
+                  }
+                }
                 return span;
               });
               return Reflect.apply(target.export, target, [
@@ -13901,44 +15256,44 @@ var BraintrustExporter = class _BraintrustExporter {
 };
 
 // dev/types.ts
-import { z as z6 } from "zod";
-var evalBodySchema = z6.object({
-  name: z6.string(),
-  parameters: z6.record(z6.string(), z6.unknown()).nullish(),
+import { z as z10 } from "zod/v3";
+var evalBodySchema = z10.object({
+  name: z10.string(),
+  parameters: z10.record(z10.string(), z10.unknown()).nullish(),
   data: RunEval.shape.data,
-  scores: z6.array(
-    z6.object({
+  scores: z10.array(
+    z10.object({
       function_id: FunctionId,
-      name: z6.string()
+      name: z10.string()
     })
   ).nullish(),
-  experiment_name: z6.string().nullish(),
-  project_id: z6.string().nullish(),
+  experiment_name: z10.string().nullish(),
+  project_id: z10.string().nullish(),
   parent: InvokeParent.optional(),
-  stream: z6.boolean().optional()
+  stream: z10.boolean().optional()
 });
-var evalParametersSerializedSchema = z6.record(
-  z6.string(),
-  z6.union([
-    z6.object({
-      type: z6.literal("prompt"),
+var evalParametersSerializedSchema = z10.record(
+  z10.string(),
+  z10.union([
+    z10.object({
+      type: z10.literal("prompt"),
       default: PromptData.optional(),
-      description: z6.string().optional()
+      description: z10.string().optional()
     }),
-    z6.object({
-      type: z6.literal("data"),
-      schema: z6.record(z6.unknown()),
+    z10.object({
+      type: z10.literal("data"),
+      schema: z10.record(z10.unknown()),
       // JSON Schema
-      default: z6.unknown().optional(),
-      description: z6.string().optional()
+      default: z10.unknown().optional(),
+      description: z10.string().optional()
     })
   ])
 );
-var evaluatorDefinitionSchema = z6.object({
+var evaluatorDefinitionSchema = z10.object({
   parameters: evalParametersSerializedSchema.optional()
 });
-var evaluatorDefinitionsSchema = z6.record(
-  z6.string(),
+var evaluatorDefinitionsSchema = z10.record(
+  z10.string(),
   evaluatorDefinitionSchema
 );
 
@@ -14039,6 +15394,7 @@ export {
   withExperiment,
   withLogger,
   withParent,
+  wrapAISDK,
   wrapAISDKModel,
   wrapAnthropic,
   wrapOpenAI,