braintrust 0.2.6 → 0.3.7

package/dist/cli.js

@@ -1232,7 +1232,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "braintrust",
-      version: "0.2.6",
+      version: "0.3.7",
       description: "SDK for integrating Braintrust",
       repository: {
         type: "git",
@@ -1270,26 +1270,32 @@ var require_package = __commonJS({
           import: "./dev/dist/index.mjs",
           module: "./dev/dist/index.mjs",
           require: "./dev/dist/index.js"
+        },
+        "./util": {
+          types: "./util/dist/index.d.ts",
+          import: "./util/dist/index.mjs",
+          module: "./util/dist/index.mjs",
+          require: "./util/dist/index.js"
         }
       },
       files: [
         "dist/**/*",
-        "dev/dist/**/*"
+        "dev/dist/**/*",
+        "util/dist/**/*"
       ],
       scripts: {
         build: 'cross-env NODE_OPTIONS="--max-old-space-size=8192" tsup',
         watch: "tsup --watch",
         clean: "rm -r dist/* && rm -r dev/dist/*",
         docs: "npx typedoc --options typedoc.json src/index.ts",
-        prepublishOnly: "../../scripts/node_prepublish_sdk.py",
-        postpublish: "../../scripts/node_postpublish_sdk.py",
-        test: "vitest run --exclude src/wrappers/anthropic.test.ts --exclude src/wrappers/oai.test.ts --exclude src/otel.test.ts --exclude src/otel-no-deps.test.ts  --exclude src/wrappers/ai-sdk-v1.test.ts --exclude src/wrappers/ai-sdk-v2.test.ts",
+        test: "vitest run --exclude src/wrappers/anthropic.test.ts --exclude src/wrappers/oai.test.ts --exclude src/otel.test.ts --exclude src/otel-no-deps.test.ts  --exclude src/wrappers/ai-sdk-v1.test.ts --exclude src/wrappers/ai-sdk-v2.test.ts --exclude src/wrappers/ai-sdk-v3.test.ts",
         "test:anthropic": "vitest run src/wrappers/anthropic.test.ts",
         "test:openai": "vitest run src/wrappers/oai.test.ts",
         "test:otel": "vitest run src/otel.test.ts",
         "test:otel-no-deps": "vitest run src/otel-no-deps.test.ts --reporter=verbose",
         "test:ai-sdk-v1": "vitest run src/wrappers/ai-sdk-v1.test.ts",
-        "test:ai-sdk-v2": "vitest run src/wrappers/ai-sdk-v2.test.ts src/wrappers/ai-sdk-v1.test.ts"
+        "test:ai-sdk-v2": "vitest run src/wrappers/ai-sdk-v2.test.ts src/wrappers/ai-sdk-v1.test.ts",
+        "test:ai-sdk-v3": "vitest run src/wrappers/ai-sdk-v3.test.ts"
       },
       author: "",
       license: "MIT",
@@ -1328,7 +1334,6 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@ai-sdk/provider": "^1.1.3",
-        "@braintrust/core": "0.0.95",
         "@next/env": "^14.2.3",
         "@vercel/functions": "^1.0.2",
         argparse: "^2.0.1",
@@ -1371,7 +1376,7 @@ var dotenv2 = __toESM(require("dotenv"));
 var import_fs2 = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path6 = __toESM(require("path"));
-var import_util6 = __toESM(require("util"));
+var import_util14 = __toESM(require("util"));
 var fsWalk = __toESM(require_out3());
 var import_minimatch = require("minimatch");
 var import_argparse = require("argparse");
@@ -1437,13 +1442,1026 @@ var Queue = class {
   }
 };
 
-// src/logger.ts
-var import_core2 = require("@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
+var uuid3 = __toESM(require("uuid"));
+
+// util/span_identifier_v2.ts
+var uuid2 = __toESM(require("uuid"));
+
+// util/span_identifier_v1.ts
+var uuid = __toESM(require("uuid"));
+var import_v3 = require("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 = import_v3.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
+var import_v32 = require("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 = import_v32.z.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
+var import_v33 = require("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 = import_v33.z.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 = import_v33.z.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 = import_v33.z.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: import_v33.z.record(import_v33.z.unknown()).nullish()
+}).and(
+  import_v33.z.union([
+    // Must provide one or the other.
+    import_v33.z.object({
+      object_id: import_v33.z.string().nullish(),
+      compute_object_metadata_args: import_v33.z.optional(import_v33.z.null())
+    }),
+    import_v33.z.object({
+      object_id: import_v33.z.optional(import_v33.z.null()),
+      compute_object_metadata_args: import_v33.z.record(import_v33.z.unknown())
+    })
+  ])
+).and(
+  import_v33.z.union([
+    // Either all of these must be provided or none.
+    import_v33.z.object({
+      row_id: import_v33.z.string(),
+      span_id: import_v33.z.string(),
+      root_span_id: import_v33.z.string()
+    }),
+    import_v33.z.object({
+      row_id: import_v33.z.optional(import_v33.z.null()),
+      span_id: import_v33.z.optional(import_v33.z.null()),
+      root_span_id: import_v33.z.optional(import_v33.z.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));
+  }
+};
+function parseParent(parent) {
+  return typeof parent === "string" ? parent : parent ? new SpanComponentsV3({
+    object_type: parent.object_type === "experiment" ? 1 /* EXPERIMENT */ : parent.object_type === "playground_logs" ? 3 /* PLAYGROUND_LOGS */ : 2 /* PROJECT_LOGS */,
+    object_id: parent.object_id,
+    ...parent.row_ids ? {
+      row_id: parent.row_ids.id,
+      span_id: parent.row_ids.span_id,
+      root_span_id: parent.row_ids.root_span_id
+    } : {
+      row_id: void 0,
+      span_id: void 0,
+      root_span_id: void 0
+    },
+    propagated_event: parent.propagated_event
+  }).toStr() : void 0;
+}
+
+// util/http_headers.ts
+var BT_FOUND_EXISTING_HEADER = "x-bt-found-existing";
+var BT_CURSOR_HEADER = "x-bt-cursor";
+
+// 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;
+}
+function isEmpty(a) {
+  return a === void 0 || a === null;
+}
+
+// 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: path9,
+  mergePaths
+}) {
+  Object.entries(mergeFrom).forEach(([k, mergeFromV]) => {
+    const fullPath = path9.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, path9) {
+  let curr = row;
+  for (const p of path9) {
+    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("/");
+}
+function capitalize(s, sep) {
+  const items = sep ? s.split(sep) : [s];
+  return items.map((s2) => s2 ? s2.charAt(0).toUpperCase() + s2.slice(1) : s2).join(sep || "");
+}
+
+// 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
+var import_v34 = require("zod/v3");
 
 // src/generated_types.ts
-var import_zod = require("zod");
-var AclObjectType = import_zod.z.union([
-  import_zod.z.enum([
+var import_v35 = require("zod/v3");
+var AclObjectType = import_v35.z.union([
+  import_v35.z.enum([
     "organization",
     "project",
     "experiment",
@@ -1456,9 +2474,9 @@ var AclObjectType = import_zod.z.union([
     "project_log",
     "org_project"
   ]),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var Permission = import_zod.z.enum([
+var Permission = import_v35.z.enum([
   "create",
   "read",
   "update",
@@ -1468,310 +2486,310 @@ var Permission = import_zod.z.enum([
   "update_acls",
   "delete_acls"
 ]);
-var Acl = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  object_type: AclObjectType.and(import_zod.z.string()),
-  object_id: import_zod.z.string().uuid(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  group_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  permission: Permission.and(import_zod.z.union([import_zod.z.string(), import_zod.z.null()])).optional(),
-  restrict_object_type: AclObjectType.and(import_zod.z.unknown()).optional(),
-  role_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  _object_org_id: import_zod.z.string().uuid(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var Acl = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  object_type: AclObjectType.and(import_v35.z.string()),
+  object_id: import_v35.z.string().uuid(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  group_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  permission: Permission.and(import_v35.z.union([import_v35.z.string(), import_v35.z.null()])).optional(),
+  restrict_object_type: AclObjectType.and(import_v35.z.unknown()).optional(),
+  role_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  _object_org_id: import_v35.z.string().uuid(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var AISecret = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  updated_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  org_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  type: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
-  preview_secret: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var AISecret = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  updated_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  org_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  type: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional(),
+  preview_secret: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var ResponseFormatJsonSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  description: import_zod.z.string().optional(),
-  schema: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.string()]).optional(),
-  strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+var ResponseFormatJsonSchema = import_v35.z.object({
+  name: import_v35.z.string(),
+  description: import_v35.z.string().optional(),
+  schema: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.string()]).optional(),
+  strict: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional()
 });
-var ResponseFormatNullish = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("json_object") }),
-  import_zod.z.object({
-    type: import_zod.z.literal("json_schema"),
+var ResponseFormatNullish = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("json_object") }),
+  import_v35.z.object({
+    type: import_v35.z.literal("json_schema"),
     json_schema: ResponseFormatJsonSchema
   }),
-  import_zod.z.object({ type: import_zod.z.literal("text") }),
-  import_zod.z.null()
+  import_v35.z.object({ type: import_v35.z.literal("text") }),
+  import_v35.z.null()
 ]);
-var AnyModelParams = import_zod.z.object({
-  temperature: import_zod.z.number().optional(),
-  top_p: import_zod.z.number().optional(),
-  max_tokens: import_zod.z.number(),
-  max_completion_tokens: import_zod.z.number().optional(),
-  frequency_penalty: import_zod.z.number().optional(),
-  presence_penalty: import_zod.z.number().optional(),
+var AnyModelParams = import_v35.z.object({
+  temperature: import_v35.z.number().optional(),
+  top_p: import_v35.z.number().optional(),
+  max_tokens: import_v35.z.number(),
+  max_completion_tokens: import_v35.z.number().optional(),
+  frequency_penalty: import_v35.z.number().optional(),
+  presence_penalty: import_v35.z.number().optional(),
   response_format: ResponseFormatNullish.optional(),
-  tool_choice: import_zod.z.union([
-    import_zod.z.literal("auto"),
-    import_zod.z.literal("none"),
-    import_zod.z.literal("required"),
-    import_zod.z.object({
-      type: import_zod.z.literal("function"),
-      function: import_zod.z.object({ name: import_zod.z.string() })
+  tool_choice: import_v35.z.union([
+    import_v35.z.literal("auto"),
+    import_v35.z.literal("none"),
+    import_v35.z.literal("required"),
+    import_v35.z.object({
+      type: import_v35.z.literal("function"),
+      function: import_v35.z.object({ name: import_v35.z.string() })
     })
   ]).optional(),
-  function_call: import_zod.z.union([
-    import_zod.z.literal("auto"),
-    import_zod.z.literal("none"),
-    import_zod.z.object({ name: import_zod.z.string() })
+  function_call: import_v35.z.union([
+    import_v35.z.literal("auto"),
+    import_v35.z.literal("none"),
+    import_v35.z.object({ name: import_v35.z.string() })
   ]).optional(),
-  n: import_zod.z.number().optional(),
-  stop: import_zod.z.array(import_zod.z.string()).optional(),
-  reasoning_effort: import_zod.z.enum(["minimal", "low", "medium", "high"]).optional(),
-  verbosity: import_zod.z.enum(["low", "medium", "high"]).optional(),
-  top_k: import_zod.z.number().optional(),
-  stop_sequences: import_zod.z.array(import_zod.z.string()).optional(),
-  max_tokens_to_sample: import_zod.z.number().optional(),
-  maxOutputTokens: import_zod.z.number().optional(),
-  topP: import_zod.z.number().optional(),
-  topK: import_zod.z.number().optional(),
-  use_cache: import_zod.z.boolean().optional()
+  n: import_v35.z.number().optional(),
+  stop: import_v35.z.array(import_v35.z.string()).optional(),
+  reasoning_effort: import_v35.z.enum(["minimal", "low", "medium", "high"]).optional(),
+  verbosity: import_v35.z.enum(["low", "medium", "high"]).optional(),
+  top_k: import_v35.z.number().optional(),
+  stop_sequences: import_v35.z.array(import_v35.z.string()).optional(),
+  max_tokens_to_sample: import_v35.z.number().optional(),
+  maxOutputTokens: import_v35.z.number().optional(),
+  topP: import_v35.z.number().optional(),
+  topK: import_v35.z.number().optional(),
+  use_cache: import_v35.z.boolean().optional()
 });
-var ApiKey = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  preview_name: import_zod.z.string(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  user_email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  user_given_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  user_family_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  org_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var ApiKey = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  preview_name: import_v35.z.string(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  user_email: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  user_given_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  user_family_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  org_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var AsyncScoringState = import_zod.z.union([
-  import_zod.z.object({
-    status: import_zod.z.literal("enabled"),
-    token: import_zod.z.string(),
-    function_ids: import_zod.z.array(import_zod.z.unknown()).min(1),
-    skip_logging: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+var AsyncScoringState = import_v35.z.union([
+  import_v35.z.object({
+    status: import_v35.z.literal("enabled"),
+    token: import_v35.z.string(),
+    function_ids: import_v35.z.array(import_v35.z.unknown()).min(1),
+    skip_logging: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.object({ status: import_zod.z.literal("disabled") }),
-  import_zod.z.null(),
-  import_zod.z.null()
+  import_v35.z.object({ status: import_v35.z.literal("disabled") }),
+  import_v35.z.null(),
+  import_v35.z.null()
 ]);
-var AsyncScoringControl = import_zod.z.union([
-  import_zod.z.object({ kind: import_zod.z.literal("score_update"), token: import_zod.z.string() }),
-  import_zod.z.object({ kind: import_zod.z.literal("state_override"), state: AsyncScoringState }),
-  import_zod.z.object({ kind: import_zod.z.literal("state_force_reselect") }),
-  import_zod.z.object({ kind: import_zod.z.literal("state_enabled_force_rescore") })
+var AsyncScoringControl = import_v35.z.union([
+  import_v35.z.object({ kind: import_v35.z.literal("score_update"), token: import_v35.z.string() }),
+  import_v35.z.object({ kind: import_v35.z.literal("state_override"), state: AsyncScoringState }),
+  import_v35.z.object({ kind: import_v35.z.literal("state_force_reselect") }),
+  import_v35.z.object({ kind: import_v35.z.literal("state_enabled_force_rescore") })
 ]);
-var BraintrustAttachmentReference = import_zod.z.object({
-  type: import_zod.z.literal("braintrust_attachment"),
-  filename: import_zod.z.string().min(1),
-  content_type: import_zod.z.string().min(1),
-  key: import_zod.z.string().min(1)
+var BraintrustAttachmentReference = import_v35.z.object({
+  type: import_v35.z.literal("braintrust_attachment"),
+  filename: import_v35.z.string().min(1),
+  content_type: import_v35.z.string().min(1),
+  key: import_v35.z.string().min(1)
 });
-var ExternalAttachmentReference = import_zod.z.object({
-  type: import_zod.z.literal("external_attachment"),
-  filename: import_zod.z.string().min(1),
-  content_type: import_zod.z.string().min(1),
-  url: import_zod.z.string().min(1)
+var ExternalAttachmentReference = import_v35.z.object({
+  type: import_v35.z.literal("external_attachment"),
+  filename: import_v35.z.string().min(1),
+  content_type: import_v35.z.string().min(1),
+  url: import_v35.z.string().min(1)
 });
-var AttachmentReference = import_zod.z.discriminatedUnion("type", [
+var AttachmentReference = import_v35.z.discriminatedUnion("type", [
   BraintrustAttachmentReference,
   ExternalAttachmentReference
 ]);
-var UploadStatus = import_zod.z.enum(["uploading", "done", "error"]);
-var AttachmentStatus = import_zod.z.object({
+var UploadStatus = import_v35.z.enum(["uploading", "done", "error"]);
+var AttachmentStatus = import_v35.z.object({
   upload_status: UploadStatus,
-  error_message: import_zod.z.string().optional()
+  error_message: import_v35.z.string().optional()
 });
-var BraintrustModelParams = import_zod.z.object({ use_cache: import_zod.z.boolean() }).partial();
-var CallEvent = import_zod.z.union([
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    data: import_zod.z.string(),
-    event: import_zod.z.literal("text_delta")
+var BraintrustModelParams = import_v35.z.object({ use_cache: import_v35.z.boolean() }).partial();
+var CallEvent = import_v35.z.union([
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    data: import_v35.z.string(),
+    event: import_v35.z.literal("text_delta")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    data: import_zod.z.string(),
-    event: import_zod.z.literal("reasoning_delta")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    data: import_v35.z.string(),
+    event: import_v35.z.literal("reasoning_delta")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    data: import_zod.z.string(),
-    event: import_zod.z.literal("json_delta")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    data: import_v35.z.string(),
+    event: import_v35.z.literal("json_delta")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    data: import_zod.z.string(),
-    event: import_zod.z.literal("progress")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    data: import_v35.z.string(),
+    event: import_v35.z.literal("progress")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    data: import_zod.z.string(),
-    event: import_zod.z.literal("error")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    data: import_v35.z.string(),
+    event: import_v35.z.literal("error")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    data: import_zod.z.string(),
-    event: import_zod.z.literal("console")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    data: import_v35.z.string(),
+    event: import_v35.z.literal("console")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    event: import_zod.z.literal("start"),
-    data: import_zod.z.literal("")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    event: import_v35.z.literal("start"),
+    data: import_v35.z.literal("")
   }),
-  import_zod.z.object({
-    id: import_zod.z.string().optional(),
-    event: import_zod.z.literal("done"),
-    data: import_zod.z.literal("")
+  import_v35.z.object({
+    id: import_v35.z.string().optional(),
+    event: import_v35.z.literal("done"),
+    data: import_v35.z.literal("")
   })
 ]);
-var ChatCompletionContentPartTextWithTitle = import_zod.z.object({
-  text: import_zod.z.string().default(""),
-  type: import_zod.z.literal("text"),
-  cache_control: import_zod.z.object({ type: import_zod.z.literal("ephemeral") }).optional()
+var ChatCompletionContentPartTextWithTitle = import_v35.z.object({
+  text: import_v35.z.string().default(""),
+  type: import_v35.z.literal("text"),
+  cache_control: import_v35.z.object({ type: import_v35.z.literal("ephemeral") }).optional()
 });
-var ChatCompletionContentPartImageWithTitle = import_zod.z.object({
-  image_url: import_zod.z.object({
-    url: import_zod.z.string(),
-    detail: import_zod.z.union([import_zod.z.literal("auto"), import_zod.z.literal("low"), import_zod.z.literal("high")]).optional()
+var ChatCompletionContentPartImageWithTitle = import_v35.z.object({
+  image_url: import_v35.z.object({
+    url: import_v35.z.string(),
+    detail: import_v35.z.union([import_v35.z.literal("auto"), import_v35.z.literal("low"), import_v35.z.literal("high")]).optional()
   }),
-  type: import_zod.z.literal("image_url")
+  type: import_v35.z.literal("image_url")
 });
-var ChatCompletionContentPart = import_zod.z.union([
+var ChatCompletionContentPart = import_v35.z.union([
   ChatCompletionContentPartTextWithTitle,
   ChatCompletionContentPartImageWithTitle
 ]);
-var ChatCompletionContentPartText = import_zod.z.object({
-  text: import_zod.z.string().default(""),
-  type: import_zod.z.literal("text"),
-  cache_control: import_zod.z.object({ type: import_zod.z.literal("ephemeral") }).optional()
+var ChatCompletionContentPartText = import_v35.z.object({
+  text: import_v35.z.string().default(""),
+  type: import_v35.z.literal("text"),
+  cache_control: import_v35.z.object({ type: import_v35.z.literal("ephemeral") }).optional()
 });
-var ChatCompletionMessageToolCall = import_zod.z.object({
-  id: import_zod.z.string(),
-  function: import_zod.z.object({ arguments: import_zod.z.string(), name: import_zod.z.string() }),
-  type: import_zod.z.literal("function")
+var ChatCompletionMessageToolCall = import_v35.z.object({
+  id: import_v35.z.string(),
+  function: import_v35.z.object({ arguments: import_v35.z.string(), name: import_v35.z.string() }),
+  type: import_v35.z.literal("function")
 });
-var ChatCompletionMessageReasoning = import_zod.z.object({ id: import_zod.z.string(), content: import_zod.z.string() }).partial();
-var ChatCompletionMessageParam = import_zod.z.union([
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
-    role: import_zod.z.literal("system"),
-    name: import_zod.z.string().optional()
+var ChatCompletionMessageReasoning = import_v35.z.object({ id: import_v35.z.string(), content: import_v35.z.string() }).partial();
+var ChatCompletionMessageParam = import_v35.z.union([
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText)]),
+    role: import_v35.z.literal("system"),
+    name: import_v35.z.string().optional()
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPart)]),
-    role: import_zod.z.literal("user"),
-    name: import_zod.z.string().optional()
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPart)]),
+    role: import_v35.z.literal("user"),
+    name: import_v35.z.string().optional()
   }),
-  import_zod.z.object({
-    role: import_zod.z.literal("assistant"),
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText), import_zod.z.null()]).optional(),
-    function_call: import_zod.z.object({ arguments: import_zod.z.string(), name: import_zod.z.string() }).optional(),
-    name: import_zod.z.string().optional(),
-    tool_calls: import_zod.z.array(ChatCompletionMessageToolCall).optional(),
-    reasoning: import_zod.z.array(ChatCompletionMessageReasoning).optional()
+  import_v35.z.object({
+    role: import_v35.z.literal("assistant"),
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText), import_v35.z.null()]).optional(),
+    function_call: import_v35.z.object({ arguments: import_v35.z.string(), name: import_v35.z.string() }).optional(),
+    name: import_v35.z.string().optional(),
+    tool_calls: import_v35.z.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: import_v35.z.array(ChatCompletionMessageReasoning).optional()
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
-    role: import_zod.z.literal("tool"),
-    tool_call_id: import_zod.z.string().default("")
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText)]),
+    role: import_v35.z.literal("tool"),
+    tool_call_id: import_v35.z.string().default("")
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    name: import_zod.z.string(),
-    role: import_zod.z.literal("function")
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    name: import_v35.z.string(),
+    role: import_v35.z.literal("function")
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
-    role: import_zod.z.literal("developer"),
-    name: import_zod.z.string().optional()
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText)]),
+    role: import_v35.z.literal("developer"),
+    name: import_v35.z.string().optional()
   }),
-  import_zod.z.object({
-    role: import_zod.z.literal("model"),
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  import_v35.z.object({
+    role: import_v35.z.literal("model"),
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
   })
 ]);
-var ChatCompletionOpenAIMessageParam = import_zod.z.union([
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
-    role: import_zod.z.literal("system"),
-    name: import_zod.z.string().optional()
+var ChatCompletionOpenAIMessageParam = import_v35.z.union([
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText)]),
+    role: import_v35.z.literal("system"),
+    name: import_v35.z.string().optional()
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPart)]),
-    role: import_zod.z.literal("user"),
-    name: import_zod.z.string().optional()
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPart)]),
+    role: import_v35.z.literal("user"),
+    name: import_v35.z.string().optional()
   }),
-  import_zod.z.object({
-    role: import_zod.z.literal("assistant"),
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText), import_zod.z.null()]).optional(),
-    function_call: import_zod.z.object({ arguments: import_zod.z.string(), name: import_zod.z.string() }).optional(),
-    name: import_zod.z.string().optional(),
-    tool_calls: import_zod.z.array(ChatCompletionMessageToolCall).optional(),
-    reasoning: import_zod.z.array(ChatCompletionMessageReasoning).optional()
+  import_v35.z.object({
+    role: import_v35.z.literal("assistant"),
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText), import_v35.z.null()]).optional(),
+    function_call: import_v35.z.object({ arguments: import_v35.z.string(), name: import_v35.z.string() }).optional(),
+    name: import_v35.z.string().optional(),
+    tool_calls: import_v35.z.array(ChatCompletionMessageToolCall).optional(),
+    reasoning: import_v35.z.array(ChatCompletionMessageReasoning).optional()
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
-    role: import_zod.z.literal("tool"),
-    tool_call_id: import_zod.z.string().default("")
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText)]),
+    role: import_v35.z.literal("tool"),
+    tool_call_id: import_v35.z.string().default("")
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    name: import_zod.z.string(),
-    role: import_zod.z.literal("function")
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    name: import_v35.z.string(),
+    role: import_v35.z.literal("function")
   }),
-  import_zod.z.object({
-    content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(ChatCompletionContentPartText)]),
-    role: import_zod.z.literal("developer"),
-    name: import_zod.z.string().optional()
+  import_v35.z.object({
+    content: import_v35.z.union([import_v35.z.string(), import_v35.z.array(ChatCompletionContentPartText)]),
+    role: import_v35.z.literal("developer"),
+    name: import_v35.z.string().optional()
   })
 ]);
-var ChatCompletionTool = import_zod.z.object({
-  function: import_zod.z.object({
-    name: import_zod.z.string(),
-    description: import_zod.z.string().optional(),
-    parameters: import_zod.z.object({}).partial().passthrough().optional()
+var ChatCompletionTool = import_v35.z.object({
+  function: import_v35.z.object({
+    name: import_v35.z.string(),
+    description: import_v35.z.string().optional(),
+    parameters: import_v35.z.object({}).partial().passthrough().optional()
   }),
-  type: import_zod.z.literal("function")
+  type: import_v35.z.literal("function")
 });
-var CodeBundle = import_zod.z.object({
-  runtime_context: import_zod.z.object({
-    runtime: import_zod.z.enum(["node", "python"]),
-    version: import_zod.z.string()
+var CodeBundle = import_v35.z.object({
+  runtime_context: import_v35.z.object({
+    runtime: import_v35.z.enum(["node", "python"]),
+    version: import_v35.z.string()
   }),
-  location: import_zod.z.union([
-    import_zod.z.object({
-      type: import_zod.z.literal("experiment"),
-      eval_name: import_zod.z.string(),
-      position: import_zod.z.union([
-        import_zod.z.object({ type: import_zod.z.literal("task") }),
-        import_zod.z.object({ type: import_zod.z.literal("scorer"), index: import_zod.z.number().int().gte(0) })
+  location: import_v35.z.union([
+    import_v35.z.object({
+      type: import_v35.z.literal("experiment"),
+      eval_name: import_v35.z.string(),
+      position: import_v35.z.union([
+        import_v35.z.object({ type: import_v35.z.literal("task") }),
+        import_v35.z.object({ type: import_v35.z.literal("scorer"), index: import_v35.z.number().int().gte(0) })
       ])
     }),
-    import_zod.z.object({ type: import_zod.z.literal("function"), index: import_zod.z.number().int().gte(0) })
+    import_v35.z.object({ type: import_v35.z.literal("function"), index: import_v35.z.number().int().gte(0) })
   ]),
-  bundle_id: import_zod.z.string(),
-  preview: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  bundle_id: import_v35.z.string(),
+  preview: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var Dataset = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+var Dataset = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional()
 });
-var ObjectReferenceNullish = import_zod.z.union([
-  import_zod.z.object({
-    object_type: import_zod.z.enum([
+var ObjectReferenceNullish = import_v35.z.union([
+  import_v35.z.object({
+    object_type: import_v35.z.enum([
       "project_logs",
       "experiment",
       "dataset",
@@ -1779,399 +2797,399 @@ var ObjectReferenceNullish = import_zod.z.union([
       "function",
       "prompt_session"
     ]),
-    object_id: import_zod.z.string().uuid(),
-    id: import_zod.z.string(),
-    _xact_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+    object_id: import_v35.z.string().uuid(),
+    id: import_v35.z.string(),
+    _xact_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var DatasetEvent = import_zod.z.object({
-  id: import_zod.z.string(),
-  _xact_id: import_zod.z.string(),
-  created: import_zod.z.string().datetime({ offset: true }),
-  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  project_id: import_zod.z.string().uuid(),
-  dataset_id: import_zod.z.string().uuid(),
-  input: import_zod.z.unknown().optional(),
-  expected: import_zod.z.unknown().optional(),
-  metadata: import_zod.z.union([
-    import_zod.z.object({ model: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]) }).partial().passthrough(),
-    import_zod.z.null()
+var DatasetEvent = import_v35.z.object({
+  id: import_v35.z.string(),
+  _xact_id: import_v35.z.string(),
+  created: import_v35.z.string().datetime({ offset: true }),
+  _pagination_key: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  project_id: import_v35.z.string().uuid(),
+  dataset_id: import_v35.z.string().uuid(),
+  input: import_v35.z.unknown().optional(),
+  expected: import_v35.z.unknown().optional(),
+  metadata: import_v35.z.union([
+    import_v35.z.object({ model: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]) }).partial().passthrough(),
+    import_v35.z.null()
   ]).optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  span_id: import_zod.z.string(),
-  root_span_id: import_zod.z.string(),
-  is_root: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  span_id: import_v35.z.string(),
+  root_span_id: import_v35.z.string(),
+  is_root: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional()
 });
-var EnvVar = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  object_type: import_zod.z.enum(["organization", "project", "function"]),
-  object_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  used: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var EnvVar = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  object_type: import_v35.z.enum(["organization", "project", "function"]),
+  object_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  used: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var RepoInfo = import_zod.z.union([
-  import_zod.z.object({
-    commit: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    branch: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    tag: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    dirty: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
-    author_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    author_email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    commit_message: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    commit_time: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    git_diff: import_zod.z.union([import_zod.z.string(), import_zod.z.null()])
+var RepoInfo = import_v35.z.union([
+  import_v35.z.object({
+    commit: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    branch: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    tag: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    dirty: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]),
+    author_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    author_email: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    commit_message: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    commit_time: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    git_diff: import_v35.z.union([import_v35.z.string(), import_v35.z.null()])
   }).partial(),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var Experiment = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+var Experiment = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   repo_info: RepoInfo.optional(),
-  commit: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  base_exp_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  dataset_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  dataset_version: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  public: import_zod.z.boolean(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional()
+  commit: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  base_exp_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  dataset_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  dataset_version: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  public: import_v35.z.boolean(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional(),
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional()
 });
-var SpanType = import_zod.z.union([
-  import_zod.z.enum(["llm", "score", "function", "eval", "task", "tool"]),
-  import_zod.z.null()
+var SpanType = import_v35.z.union([
+  import_v35.z.enum(["llm", "score", "function", "eval", "task", "tool"]),
+  import_v35.z.null()
 ]);
-var SpanAttributes = import_zod.z.union([
-  import_zod.z.object({ name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]), type: SpanType }).partial().passthrough(),
-  import_zod.z.null()
+var SpanAttributes = import_v35.z.union([
+  import_v35.z.object({ name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]), type: SpanType }).partial().passthrough(),
+  import_v35.z.null()
 ]);
-var ExperimentEvent = import_zod.z.object({
-  id: import_zod.z.string(),
-  _xact_id: import_zod.z.string(),
-  created: import_zod.z.string().datetime({ offset: true }),
-  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  project_id: import_zod.z.string().uuid(),
-  experiment_id: import_zod.z.string().uuid(),
-  input: import_zod.z.unknown().optional(),
-  output: import_zod.z.unknown().optional(),
-  expected: import_zod.z.unknown().optional(),
-  error: import_zod.z.unknown().optional(),
-  scores: import_zod.z.union([import_zod.z.record(import_zod.z.union([import_zod.z.number(), import_zod.z.null()])), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([
-    import_zod.z.object({ model: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]) }).partial().passthrough(),
-    import_zod.z.null()
+var ExperimentEvent = import_v35.z.object({
+  id: import_v35.z.string(),
+  _xact_id: import_v35.z.string(),
+  created: import_v35.z.string().datetime({ offset: true }),
+  _pagination_key: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  project_id: import_v35.z.string().uuid(),
+  experiment_id: import_v35.z.string().uuid(),
+  input: import_v35.z.unknown().optional(),
+  output: import_v35.z.unknown().optional(),
+  expected: import_v35.z.unknown().optional(),
+  error: import_v35.z.unknown().optional(),
+  scores: import_v35.z.union([import_v35.z.record(import_v35.z.union([import_v35.z.number(), import_v35.z.null()])), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([
+    import_v35.z.object({ model: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]) }).partial().passthrough(),
+    import_v35.z.null()
   ]).optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  metrics: import_zod.z.union([import_zod.z.record(import_zod.z.number()), import_zod.z.null()]).optional(),
-  context: import_zod.z.union([
-    import_zod.z.object({
-      caller_functionname: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      caller_filename: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      caller_lineno: import_zod.z.union([import_zod.z.number(), import_zod.z.null()])
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  metrics: import_v35.z.union([import_v35.z.record(import_v35.z.number()), import_v35.z.null()]).optional(),
+  context: import_v35.z.union([
+    import_v35.z.object({
+      caller_functionname: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      caller_filename: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      caller_lineno: import_v35.z.union([import_v35.z.number(), import_v35.z.null()])
     }).partial().passthrough(),
-    import_zod.z.null()
+    import_v35.z.null()
   ]).optional(),
-  span_id: import_zod.z.string(),
-  span_parents: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  root_span_id: import_zod.z.string(),
+  span_id: import_v35.z.string(),
+  span_parents: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  root_span_id: import_v35.z.string(),
   span_attributes: SpanAttributes.optional(),
-  is_root: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  is_root: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
   origin: ObjectReferenceNullish.optional()
 });
-var ExtendedSavedFunctionId = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("function"), id: import_zod.z.string() }),
-  import_zod.z.object({ type: import_zod.z.literal("global"), name: import_zod.z.string() }),
-  import_zod.z.object({
-    type: import_zod.z.literal("slug"),
-    project_id: import_zod.z.string(),
-    slug: import_zod.z.string()
+var ExtendedSavedFunctionId = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("function"), id: import_v35.z.string() }),
+  import_v35.z.object({ type: import_v35.z.literal("global"), name: import_v35.z.string() }),
+  import_v35.z.object({
+    type: import_v35.z.literal("slug"),
+    project_id: import_v35.z.string(),
+    slug: import_v35.z.string()
   })
 ]);
-var PromptBlockDataNullish = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("completion"), content: import_zod.z.string() }),
-  import_zod.z.object({
-    type: import_zod.z.literal("chat"),
-    messages: import_zod.z.array(ChatCompletionMessageParam),
-    tools: import_zod.z.string().optional()
+var PromptBlockDataNullish = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("completion"), content: import_v35.z.string() }),
+  import_v35.z.object({
+    type: import_v35.z.literal("chat"),
+    messages: import_v35.z.array(ChatCompletionMessageParam),
+    tools: import_v35.z.string().optional()
   }),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var ModelParams = import_zod.z.union([
-  import_zod.z.object({
-    use_cache: import_zod.z.boolean(),
-    temperature: import_zod.z.number(),
-    top_p: import_zod.z.number(),
-    max_tokens: import_zod.z.number(),
-    max_completion_tokens: import_zod.z.number(),
-    frequency_penalty: import_zod.z.number(),
-    presence_penalty: import_zod.z.number(),
+var ModelParams = import_v35.z.union([
+  import_v35.z.object({
+    use_cache: import_v35.z.boolean(),
+    temperature: import_v35.z.number(),
+    top_p: import_v35.z.number(),
+    max_tokens: import_v35.z.number(),
+    max_completion_tokens: import_v35.z.number(),
+    frequency_penalty: import_v35.z.number(),
+    presence_penalty: import_v35.z.number(),
     response_format: ResponseFormatNullish,
-    tool_choice: import_zod.z.union([
-      import_zod.z.literal("auto"),
-      import_zod.z.literal("none"),
-      import_zod.z.literal("required"),
-      import_zod.z.object({
-        type: import_zod.z.literal("function"),
-        function: import_zod.z.object({ name: import_zod.z.string() })
+    tool_choice: import_v35.z.union([
+      import_v35.z.literal("auto"),
+      import_v35.z.literal("none"),
+      import_v35.z.literal("required"),
+      import_v35.z.object({
+        type: import_v35.z.literal("function"),
+        function: import_v35.z.object({ name: import_v35.z.string() })
       })
     ]),
-    function_call: import_zod.z.union([
-      import_zod.z.literal("auto"),
-      import_zod.z.literal("none"),
-      import_zod.z.object({ name: import_zod.z.string() })
+    function_call: import_v35.z.union([
+      import_v35.z.literal("auto"),
+      import_v35.z.literal("none"),
+      import_v35.z.object({ name: import_v35.z.string() })
     ]),
-    n: import_zod.z.number(),
-    stop: import_zod.z.array(import_zod.z.string()),
-    reasoning_effort: import_zod.z.enum(["minimal", "low", "medium", "high"]),
-    verbosity: import_zod.z.enum(["low", "medium", "high"])
+    n: import_v35.z.number(),
+    stop: import_v35.z.array(import_v35.z.string()),
+    reasoning_effort: import_v35.z.enum(["minimal", "low", "medium", "high"]),
+    verbosity: import_v35.z.enum(["low", "medium", "high"])
   }).partial().passthrough(),
-  import_zod.z.object({
-    use_cache: import_zod.z.boolean().optional(),
-    max_tokens: import_zod.z.number(),
-    temperature: import_zod.z.number(),
-    top_p: import_zod.z.number().optional(),
-    top_k: import_zod.z.number().optional(),
-    stop_sequences: import_zod.z.array(import_zod.z.string()).optional(),
-    max_tokens_to_sample: import_zod.z.number().optional()
+  import_v35.z.object({
+    use_cache: import_v35.z.boolean().optional(),
+    max_tokens: import_v35.z.number(),
+    temperature: import_v35.z.number(),
+    top_p: import_v35.z.number().optional(),
+    top_k: import_v35.z.number().optional(),
+    stop_sequences: import_v35.z.array(import_v35.z.string()).optional(),
+    max_tokens_to_sample: import_v35.z.number().optional()
   }).passthrough(),
-  import_zod.z.object({
-    use_cache: import_zod.z.boolean(),
-    temperature: import_zod.z.number(),
-    maxOutputTokens: import_zod.z.number(),
-    topP: import_zod.z.number(),
-    topK: import_zod.z.number()
+  import_v35.z.object({
+    use_cache: import_v35.z.boolean(),
+    temperature: import_v35.z.number(),
+    maxOutputTokens: import_v35.z.number(),
+    topP: import_v35.z.number(),
+    topK: import_v35.z.number()
   }).partial().passthrough(),
-  import_zod.z.object({
-    use_cache: import_zod.z.boolean(),
-    temperature: import_zod.z.number(),
-    topK: import_zod.z.number()
+  import_v35.z.object({
+    use_cache: import_v35.z.boolean(),
+    temperature: import_v35.z.number(),
+    topK: import_v35.z.number()
   }).partial().passthrough(),
-  import_zod.z.object({ use_cache: import_zod.z.boolean() }).partial().passthrough()
+  import_v35.z.object({ use_cache: import_v35.z.boolean() }).partial().passthrough()
 ]);
-var PromptOptionsNullish = import_zod.z.union([
-  import_zod.z.object({ model: import_zod.z.string(), params: ModelParams, position: import_zod.z.string() }).partial(),
-  import_zod.z.null()
+var PromptOptionsNullish = import_v35.z.union([
+  import_v35.z.object({ model: import_v35.z.string(), params: ModelParams, position: import_v35.z.string() }).partial(),
+  import_v35.z.null()
 ]);
-var PromptParserNullish = import_zod.z.union([
-  import_zod.z.object({
-    type: import_zod.z.literal("llm_classifier"),
-    use_cot: import_zod.z.boolean(),
-    choice_scores: import_zod.z.record(import_zod.z.number().gte(0).lte(1))
+var PromptParserNullish = import_v35.z.union([
+  import_v35.z.object({
+    type: import_v35.z.literal("llm_classifier"),
+    use_cot: import_v35.z.boolean(),
+    choice_scores: import_v35.z.record(import_v35.z.number().gte(0).lte(1))
   }),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var SavedFunctionId = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("function"), id: import_zod.z.string() }),
-  import_zod.z.object({ type: import_zod.z.literal("global"), name: import_zod.z.string() })
+var SavedFunctionId = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("function"), id: import_v35.z.string() }),
+  import_v35.z.object({ type: import_v35.z.literal("global"), name: import_v35.z.string() })
 ]);
-var PromptDataNullish = import_zod.z.union([
-  import_zod.z.object({
+var PromptDataNullish = import_v35.z.union([
+  import_v35.z.object({
     prompt: PromptBlockDataNullish,
     options: PromptOptionsNullish,
     parser: PromptParserNullish,
-    tool_functions: import_zod.z.union([import_zod.z.array(SavedFunctionId), import_zod.z.null()]),
-    origin: import_zod.z.union([
-      import_zod.z.object({
-        prompt_id: import_zod.z.string(),
-        project_id: import_zod.z.string(),
-        prompt_version: import_zod.z.string()
+    tool_functions: import_v35.z.union([import_v35.z.array(SavedFunctionId), import_v35.z.null()]),
+    origin: import_v35.z.union([
+      import_v35.z.object({
+        prompt_id: import_v35.z.string(),
+        project_id: import_v35.z.string(),
+        prompt_version: import_v35.z.string()
       }).partial(),
-      import_zod.z.null()
+      import_v35.z.null()
     ])
   }).partial(),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var FunctionTypeEnumNullish = import_zod.z.union([
-  import_zod.z.enum(["llm", "scorer", "task", "tool"]),
-  import_zod.z.null()
+var FunctionTypeEnumNullish = import_v35.z.union([
+  import_v35.z.enum(["llm", "scorer", "task", "tool"]),
+  import_v35.z.null()
 ]);
-var FunctionIdRef = import_zod.z.object({}).partial().passthrough();
-var PromptBlockData = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("completion"), content: import_zod.z.string() }),
-  import_zod.z.object({
-    type: import_zod.z.literal("chat"),
-    messages: import_zod.z.array(ChatCompletionMessageParam),
-    tools: import_zod.z.string().optional()
+var FunctionIdRef = import_v35.z.object({}).partial().passthrough();
+var PromptBlockData = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("completion"), content: import_v35.z.string() }),
+  import_v35.z.object({
+    type: import_v35.z.literal("chat"),
+    messages: import_v35.z.array(ChatCompletionMessageParam),
+    tools: import_v35.z.string().optional()
   })
 ]);
-var GraphNode = import_zod.z.union([
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("function"),
+var GraphNode = import_v35.z.union([
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("function"),
     function: FunctionIdRef
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("input")
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("input")
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("output")
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("output")
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("literal"),
-    value: import_zod.z.unknown().optional()
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("literal"),
+    value: import_v35.z.unknown().optional()
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("btql"),
-    expr: import_zod.z.string()
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("btql"),
+    expr: import_v35.z.string()
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("gate"),
-    condition: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("gate"),
+    condition: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("aggregator")
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("aggregator")
   }),
-  import_zod.z.object({
-    description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    position: import_zod.z.union([import_zod.z.object({ x: import_zod.z.number(), y: import_zod.z.number() }), import_zod.z.null()]).optional(),
-    type: import_zod.z.literal("prompt_template"),
+  import_v35.z.object({
+    description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    position: import_v35.z.union([import_v35.z.object({ x: import_v35.z.number(), y: import_v35.z.number() }), import_v35.z.null()]).optional(),
+    type: import_v35.z.literal("prompt_template"),
     prompt: PromptBlockData
   })
 ]);
-var GraphEdge = import_zod.z.object({
-  source: import_zod.z.object({ node: import_zod.z.string().max(1024), variable: import_zod.z.string() }),
-  target: import_zod.z.object({ node: import_zod.z.string().max(1024), variable: import_zod.z.string() }),
-  purpose: import_zod.z.enum(["control", "data", "messages"])
+var GraphEdge = import_v35.z.object({
+  source: import_v35.z.object({ node: import_v35.z.string().max(1024), variable: import_v35.z.string() }),
+  target: import_v35.z.object({ node: import_v35.z.string().max(1024), variable: import_v35.z.string() }),
+  purpose: import_v35.z.enum(["control", "data", "messages"])
 });
-var GraphData = import_zod.z.object({
-  type: import_zod.z.literal("graph"),
-  nodes: import_zod.z.record(GraphNode),
-  edges: import_zod.z.record(GraphEdge)
+var GraphData = import_v35.z.object({
+  type: import_v35.z.literal("graph"),
+  nodes: import_v35.z.record(GraphNode),
+  edges: import_v35.z.record(GraphEdge)
 });
-var FunctionData = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("prompt") }),
-  import_zod.z.object({
-    type: import_zod.z.literal("code"),
-    data: import_zod.z.union([
-      import_zod.z.object({ type: import_zod.z.literal("bundle") }).and(CodeBundle),
-      import_zod.z.object({
-        type: import_zod.z.literal("inline"),
-        runtime_context: import_zod.z.object({
-          runtime: import_zod.z.enum(["node", "python"]),
-          version: import_zod.z.string()
+var FunctionData = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("prompt") }),
+  import_v35.z.object({
+    type: import_v35.z.literal("code"),
+    data: import_v35.z.union([
+      import_v35.z.object({ type: import_v35.z.literal("bundle") }).and(CodeBundle),
+      import_v35.z.object({
+        type: import_v35.z.literal("inline"),
+        runtime_context: import_v35.z.object({
+          runtime: import_v35.z.enum(["node", "python"]),
+          version: import_v35.z.string()
         }),
-        code: import_zod.z.string()
+        code: import_v35.z.string()
       })
     ])
   }),
   GraphData,
-  import_zod.z.object({
-    type: import_zod.z.literal("remote_eval"),
-    endpoint: import_zod.z.string(),
-    eval_name: import_zod.z.string(),
-    parameters: import_zod.z.object({}).partial().passthrough()
+  import_v35.z.object({
+    type: import_v35.z.literal("remote_eval"),
+    endpoint: import_v35.z.string(),
+    eval_name: import_v35.z.string(),
+    parameters: import_v35.z.object({}).partial().passthrough()
   }),
-  import_zod.z.object({ type: import_zod.z.literal("global"), name: import_zod.z.string() })
+  import_v35.z.object({ type: import_v35.z.literal("global"), name: import_v35.z.string() })
 ]);
-var Function2 = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  _xact_id: import_zod.z.string(),
-  project_id: import_zod.z.string().uuid(),
-  log_id: import_zod.z.literal("p"),
-  org_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  slug: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+var Function2 = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  _xact_id: import_v35.z.string(),
+  project_id: import_v35.z.string().uuid(),
+  log_id: import_v35.z.literal("p"),
+  org_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  slug: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   prompt_data: PromptDataNullish.optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional(),
   function_type: FunctionTypeEnumNullish.optional(),
   function_data: FunctionData,
-  origin: import_zod.z.union([
-    import_zod.z.object({
-      object_type: AclObjectType.and(import_zod.z.string()),
-      object_id: import_zod.z.string().uuid(),
-      internal: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+  origin: import_v35.z.union([
+    import_v35.z.object({
+      object_type: AclObjectType.and(import_v35.z.string()),
+      object_id: import_v35.z.string().uuid(),
+      internal: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional()
     }),
-    import_zod.z.null()
+    import_v35.z.null()
   ]).optional(),
-  function_schema: import_zod.z.union([
-    import_zod.z.object({ parameters: import_zod.z.unknown(), returns: import_zod.z.unknown() }).partial(),
-    import_zod.z.null()
+  function_schema: import_v35.z.union([
+    import_v35.z.object({ parameters: import_v35.z.unknown(), returns: import_v35.z.unknown() }).partial(),
+    import_v35.z.null()
   ]).optional()
 });
-var FunctionFormat = import_zod.z.enum(["llm", "code", "global", "graph"]);
-var PromptData = import_zod.z.object({
+var FunctionFormat = import_v35.z.enum(["llm", "code", "global", "graph"]);
+var PromptData = import_v35.z.object({
   prompt: PromptBlockDataNullish,
   options: PromptOptionsNullish,
   parser: PromptParserNullish,
-  tool_functions: import_zod.z.union([import_zod.z.array(SavedFunctionId), import_zod.z.null()]),
-  origin: import_zod.z.union([
-    import_zod.z.object({
-      prompt_id: import_zod.z.string(),
-      project_id: import_zod.z.string(),
-      prompt_version: import_zod.z.string()
+  tool_functions: import_v35.z.union([import_v35.z.array(SavedFunctionId), import_v35.z.null()]),
+  origin: import_v35.z.union([
+    import_v35.z.object({
+      prompt_id: import_v35.z.string(),
+      project_id: import_v35.z.string(),
+      prompt_version: import_v35.z.string()
     }).partial(),
-    import_zod.z.null()
+    import_v35.z.null()
   ])
 }).partial();
-var FunctionTypeEnum = import_zod.z.enum(["llm", "scorer", "task", "tool"]);
-var FunctionId = import_zod.z.union([
-  import_zod.z.object({ function_id: import_zod.z.string(), version: import_zod.z.string().optional() }),
-  import_zod.z.object({
-    project_name: import_zod.z.string(),
-    slug: import_zod.z.string(),
-    version: import_zod.z.string().optional()
+var FunctionTypeEnum = import_v35.z.enum(["llm", "scorer", "task", "tool"]);
+var FunctionId = import_v35.z.union([
+  import_v35.z.object({ function_id: import_v35.z.string(), version: import_v35.z.string().optional() }),
+  import_v35.z.object({
+    project_name: import_v35.z.string(),
+    slug: import_v35.z.string(),
+    version: import_v35.z.string().optional()
   }),
-  import_zod.z.object({ global_function: import_zod.z.string() }),
-  import_zod.z.object({
-    prompt_session_id: import_zod.z.string(),
-    prompt_session_function_id: import_zod.z.string(),
-    version: import_zod.z.string().optional()
+  import_v35.z.object({ global_function: import_v35.z.string() }),
+  import_v35.z.object({
+    prompt_session_id: import_v35.z.string(),
+    prompt_session_function_id: import_v35.z.string(),
+    version: import_v35.z.string().optional()
   }),
-  import_zod.z.object({
-    inline_context: import_zod.z.object({
-      runtime: import_zod.z.enum(["node", "python"]),
-      version: import_zod.z.string()
+  import_v35.z.object({
+    inline_context: import_v35.z.object({
+      runtime: import_v35.z.enum(["node", "python"]),
+      version: import_v35.z.string()
     }),
-    code: import_zod.z.string(),
-    name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+    code: import_v35.z.string(),
+    name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.object({
+  import_v35.z.object({
     inline_prompt: PromptData.optional(),
-    inline_function: import_zod.z.object({}).partial().passthrough(),
+    inline_function: import_v35.z.object({}).partial().passthrough(),
     function_type: FunctionTypeEnum.optional(),
-    name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+    name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.object({
+  import_v35.z.object({
     inline_prompt: PromptData,
     function_type: FunctionTypeEnum.optional(),
-    name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+    name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
   })
 ]);
-var FunctionObjectType = import_zod.z.enum([
+var FunctionObjectType = import_v35.z.enum([
   "prompt",
   "tool",
   "scorer",
   "task",
   "agent"
 ]);
-var FunctionOutputType = import_zod.z.enum(["completion", "score", "any"]);
-var GitMetadataSettings = import_zod.z.object({
-  collect: import_zod.z.enum(["all", "none", "some"]),
-  fields: import_zod.z.array(
-    import_zod.z.enum([
+var FunctionOutputType = import_v35.z.enum(["completion", "score", "any"]);
+var GitMetadataSettings = import_v35.z.object({
+  collect: import_v35.z.enum(["all", "none", "some"]),
+  fields: import_v35.z.array(
+    import_v35.z.enum([
       "commit",
       "branch",
       "tag",
@@ -2184,49 +3202,49 @@ var GitMetadataSettings = import_zod.z.object({
     ])
   ).optional()
 });
-var Group = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  org_id: import_zod.z.string().uuid(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  member_users: import_zod.z.union([import_zod.z.array(import_zod.z.string().uuid()), import_zod.z.null()]).optional(),
-  member_groups: import_zod.z.union([import_zod.z.array(import_zod.z.string().uuid()), import_zod.z.null()]).optional()
+var Group = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  org_id: import_v35.z.string().uuid(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  member_users: import_v35.z.union([import_v35.z.array(import_v35.z.string().uuid()), import_v35.z.null()]).optional(),
+  member_groups: import_v35.z.union([import_v35.z.array(import_v35.z.string().uuid()), import_v35.z.null()]).optional()
 });
-var IfExists = import_zod.z.enum(["error", "ignore", "replace"]);
-var InvokeParent = import_zod.z.union([
-  import_zod.z.object({
-    object_type: import_zod.z.enum(["project_logs", "experiment", "playground_logs"]),
-    object_id: import_zod.z.string(),
-    row_ids: import_zod.z.union([
-      import_zod.z.object({
-        id: import_zod.z.string(),
-        span_id: import_zod.z.string(),
-        root_span_id: import_zod.z.string()
+var IfExists = import_v35.z.enum(["error", "ignore", "replace"]);
+var InvokeParent = import_v35.z.union([
+  import_v35.z.object({
+    object_type: import_v35.z.enum(["project_logs", "experiment", "playground_logs"]),
+    object_id: import_v35.z.string(),
+    row_ids: import_v35.z.union([
+      import_v35.z.object({
+        id: import_v35.z.string(),
+        span_id: import_v35.z.string(),
+        root_span_id: import_v35.z.string()
       }),
-      import_zod.z.null()
+      import_v35.z.null()
     ]).optional(),
-    propagated_event: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+    propagated_event: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.string()
+  import_v35.z.string()
 ]);
-var StreamingMode = import_zod.z.union([import_zod.z.enum(["auto", "parallel"]), import_zod.z.null()]);
+var StreamingMode = import_v35.z.union([import_v35.z.enum(["auto", "parallel"]), import_v35.z.null()]);
 var InvokeFunction = FunctionId.and(
-  import_zod.z.object({
-    input: import_zod.z.unknown(),
-    expected: import_zod.z.unknown(),
-    metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]),
-    tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]),
-    messages: import_zod.z.array(ChatCompletionMessageParam),
+  import_v35.z.object({
+    input: import_v35.z.unknown(),
+    expected: import_v35.z.unknown(),
+    metadata: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]),
+    tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]),
+    messages: import_v35.z.array(ChatCompletionMessageParam),
     parent: InvokeParent,
-    stream: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
+    stream: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]),
     mode: StreamingMode,
-    strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()])
+    strict: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()])
   }).partial()
 );
-var MessageRole = import_zod.z.enum([
+var MessageRole = import_v35.z.enum([
   "system",
   "user",
   "assistant",
@@ -2235,8 +3253,8 @@ var MessageRole = import_zod.z.enum([
   "model",
   "developer"
 ]);
-var ObjectReference = import_zod.z.object({
-  object_type: import_zod.z.enum([
+var ObjectReference = import_v35.z.object({
+  object_type: import_v35.z.enum([
     "project_logs",
     "experiment",
     "dataset",
@@ -2244,146 +3262,146 @@ var ObjectReference = import_zod.z.object({
     "function",
     "prompt_session"
   ]),
-  object_id: import_zod.z.string().uuid(),
-  id: import_zod.z.string(),
-  _xact_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  object_id: import_v35.z.string().uuid(),
+  id: import_v35.z.string(),
+  _xact_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var OnlineScoreConfig = import_zod.z.union([
-  import_zod.z.object({
-    sampling_rate: import_zod.z.number().gte(0).lte(1),
-    scorers: import_zod.z.array(SavedFunctionId),
-    btql_filter: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-    apply_to_root_span: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
-    apply_to_span_names: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-    skip_logging: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+var OnlineScoreConfig = import_v35.z.union([
+  import_v35.z.object({
+    sampling_rate: import_v35.z.number().gte(0).lte(1),
+    scorers: import_v35.z.array(SavedFunctionId),
+    btql_filter: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+    apply_to_root_span: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
+    apply_to_span_names: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+    skip_logging: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional()
   }),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var Organization = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  api_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  is_universal_api: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
-  proxy_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  realtime_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var Organization = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  api_url: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  is_universal_api: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
+  proxy_url: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  realtime_url: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var ProjectSettings = import_zod.z.union([
-  import_zod.z.object({
-    comparison_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    baseline_experiment_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    spanFieldOrder: import_zod.z.union([
-      import_zod.z.array(
-        import_zod.z.object({
-          object_type: import_zod.z.string(),
-          column_id: import_zod.z.string(),
-          position: import_zod.z.string(),
-          layout: import_zod.z.union([import_zod.z.literal("full"), import_zod.z.literal("two_column"), import_zod.z.null()]).optional()
+var ProjectSettings = import_v35.z.union([
+  import_v35.z.object({
+    comparison_key: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    baseline_experiment_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    spanFieldOrder: import_v35.z.union([
+      import_v35.z.array(
+        import_v35.z.object({
+          object_type: import_v35.z.string(),
+          column_id: import_v35.z.string(),
+          position: import_v35.z.string(),
+          layout: import_v35.z.union([import_v35.z.literal("full"), import_v35.z.literal("two_column"), import_v35.z.null()]).optional()
         })
       ),
-      import_zod.z.null()
+      import_v35.z.null()
     ]),
-    remote_eval_sources: import_zod.z.union([
-      import_zod.z.array(
-        import_zod.z.object({
-          url: import_zod.z.string(),
-          name: import_zod.z.string(),
-          description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+    remote_eval_sources: import_v35.z.union([
+      import_v35.z.array(
+        import_v35.z.object({
+          url: import_v35.z.string(),
+          name: import_v35.z.string(),
+          description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
         })
       ),
-      import_zod.z.null()
+      import_v35.z.null()
     ])
   }).partial(),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var Project = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  org_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+var Project = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  org_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   settings: ProjectSettings.optional()
 });
-var RetentionObjectType = import_zod.z.enum([
+var RetentionObjectType = import_v35.z.enum([
   "project_logs",
   "experiment",
   "dataset"
 ]);
-var ProjectAutomation = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  config: import_zod.z.union([
-    import_zod.z.object({
-      event_type: import_zod.z.literal("logs"),
-      btql_filter: import_zod.z.string(),
-      interval_seconds: import_zod.z.number().gte(1).lte(2592e3),
-      action: import_zod.z.object({ type: import_zod.z.literal("webhook"), url: import_zod.z.string() })
+var ProjectAutomation = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  config: import_v35.z.union([
+    import_v35.z.object({
+      event_type: import_v35.z.literal("logs"),
+      btql_filter: import_v35.z.string(),
+      interval_seconds: import_v35.z.number().gte(1).lte(2592e3),
+      action: import_v35.z.object({ type: import_v35.z.literal("webhook"), url: import_v35.z.string() })
     }),
-    import_zod.z.object({
-      event_type: import_zod.z.literal("btql_export"),
-      export_definition: import_zod.z.union([
-        import_zod.z.object({ type: import_zod.z.literal("log_traces") }),
-        import_zod.z.object({ type: import_zod.z.literal("log_spans") }),
-        import_zod.z.object({ type: import_zod.z.literal("btql_query"), btql_query: import_zod.z.string() })
+    import_v35.z.object({
+      event_type: import_v35.z.literal("btql_export"),
+      export_definition: import_v35.z.union([
+        import_v35.z.object({ type: import_v35.z.literal("log_traces") }),
+        import_v35.z.object({ type: import_v35.z.literal("log_spans") }),
+        import_v35.z.object({ type: import_v35.z.literal("btql_query"), btql_query: import_v35.z.string() })
       ]),
-      export_path: import_zod.z.string(),
-      format: import_zod.z.enum(["jsonl", "parquet"]),
-      interval_seconds: import_zod.z.number().gte(1).lte(2592e3),
-      credentials: import_zod.z.object({
-        type: import_zod.z.literal("aws_iam"),
-        role_arn: import_zod.z.string(),
-        external_id: import_zod.z.string()
+      export_path: import_v35.z.string(),
+      format: import_v35.z.enum(["jsonl", "parquet"]),
+      interval_seconds: import_v35.z.number().gte(1).lte(2592e3),
+      credentials: import_v35.z.object({
+        type: import_v35.z.literal("aws_iam"),
+        role_arn: import_v35.z.string(),
+        external_id: import_v35.z.string()
       }),
-      batch_size: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional()
+      batch_size: import_v35.z.union([import_v35.z.number(), import_v35.z.null()]).optional()
     }),
-    import_zod.z.object({
-      event_type: import_zod.z.literal("retention"),
+    import_v35.z.object({
+      event_type: import_v35.z.literal("retention"),
       object_type: RetentionObjectType,
-      retention_days: import_zod.z.number().gte(0)
+      retention_days: import_v35.z.number().gte(0)
     })
   ])
 });
-var ProjectLogsEvent = import_zod.z.object({
-  id: import_zod.z.string(),
-  _xact_id: import_zod.z.string(),
-  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.string().datetime({ offset: true }),
-  org_id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  log_id: import_zod.z.literal("g"),
-  input: import_zod.z.unknown().optional(),
-  output: import_zod.z.unknown().optional(),
-  expected: import_zod.z.unknown().optional(),
-  error: import_zod.z.unknown().optional(),
-  scores: import_zod.z.union([import_zod.z.record(import_zod.z.union([import_zod.z.number(), import_zod.z.null()])), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([
-    import_zod.z.object({ model: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]) }).partial().passthrough(),
-    import_zod.z.null()
+var ProjectLogsEvent = import_v35.z.object({
+  id: import_v35.z.string(),
+  _xact_id: import_v35.z.string(),
+  _pagination_key: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.string().datetime({ offset: true }),
+  org_id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  log_id: import_v35.z.literal("g"),
+  input: import_v35.z.unknown().optional(),
+  output: import_v35.z.unknown().optional(),
+  expected: import_v35.z.unknown().optional(),
+  error: import_v35.z.unknown().optional(),
+  scores: import_v35.z.union([import_v35.z.record(import_v35.z.union([import_v35.z.number(), import_v35.z.null()])), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([
+    import_v35.z.object({ model: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]) }).partial().passthrough(),
+    import_v35.z.null()
   ]).optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  metrics: import_zod.z.union([import_zod.z.record(import_zod.z.number()), import_zod.z.null()]).optional(),
-  context: import_zod.z.union([
-    import_zod.z.object({
-      caller_functionname: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      caller_filename: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      caller_lineno: import_zod.z.union([import_zod.z.number(), import_zod.z.null()])
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  metrics: import_v35.z.union([import_v35.z.record(import_v35.z.number()), import_v35.z.null()]).optional(),
+  context: import_v35.z.union([
+    import_v35.z.object({
+      caller_functionname: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      caller_filename: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      caller_lineno: import_v35.z.union([import_v35.z.number(), import_v35.z.null()])
     }).partial().passthrough(),
-    import_zod.z.null()
+    import_v35.z.null()
   ]).optional(),
-  span_id: import_zod.z.string(),
-  span_parents: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  root_span_id: import_zod.z.string(),
-  is_root: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
+  span_id: import_v35.z.string(),
+  span_parents: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  root_span_id: import_v35.z.string(),
+  is_root: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
   span_attributes: SpanAttributes.optional(),
   origin: ObjectReferenceNullish.optional()
 });
-var ProjectScoreType = import_zod.z.enum([
+var ProjectScoreType = import_v35.z.enum([
   "slider",
   "categorical",
   "weighted",
@@ -2392,172 +3410,172 @@ var ProjectScoreType = import_zod.z.enum([
   "online",
   "free-form"
 ]);
-var ProjectScoreCategory = import_zod.z.object({
-  name: import_zod.z.string(),
-  value: import_zod.z.number()
+var ProjectScoreCategory = import_v35.z.object({
+  name: import_v35.z.string(),
+  value: import_v35.z.number()
 });
-var ProjectScoreCategories = import_zod.z.union([
-  import_zod.z.array(ProjectScoreCategory),
-  import_zod.z.record(import_zod.z.number()),
-  import_zod.z.array(import_zod.z.string()),
-  import_zod.z.null()
+var ProjectScoreCategories = import_v35.z.union([
+  import_v35.z.array(ProjectScoreCategory),
+  import_v35.z.record(import_v35.z.number()),
+  import_v35.z.array(import_v35.z.string()),
+  import_v35.z.null()
 ]);
-var ProjectScoreConfig = import_zod.z.union([
-  import_zod.z.object({
-    multi_select: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
-    destination: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
+var ProjectScoreConfig = import_v35.z.union([
+  import_v35.z.object({
+    multi_select: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]),
+    destination: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
     online: OnlineScoreConfig
   }).partial(),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var ProjectScore = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  user_id: import_zod.z.string().uuid(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+var ProjectScore = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  user_id: import_v35.z.string().uuid(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   score_type: ProjectScoreType,
   categories: ProjectScoreCategories.optional(),
   config: ProjectScoreConfig.optional(),
-  position: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  position: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var ProjectTag = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  user_id: import_zod.z.string().uuid(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  color: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  position: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var ProjectTag = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  user_id: import_v35.z.string().uuid(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  color: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  position: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var Prompt = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  _xact_id: import_zod.z.string(),
-  project_id: import_zod.z.string().uuid(),
-  log_id: import_zod.z.literal("p"),
-  org_id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  slug: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+var Prompt = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  _xact_id: import_v35.z.string(),
+  project_id: import_v35.z.string().uuid(),
+  log_id: import_v35.z.literal("p"),
+  org_id: import_v35.z.string().uuid(),
+  name: import_v35.z.string(),
+  slug: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   prompt_data: PromptDataNullish.optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional(),
-  metadata: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional(),
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional(),
+  metadata: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional(),
   function_type: FunctionTypeEnumNullish.optional()
 });
-var PromptOptions = import_zod.z.object({ model: import_zod.z.string(), params: ModelParams, position: import_zod.z.string() }).partial();
-var PromptSessionEvent = import_zod.z.object({
-  id: import_zod.z.string(),
-  _xact_id: import_zod.z.string(),
-  created: import_zod.z.string().datetime({ offset: true }),
-  _pagination_key: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  project_id: import_zod.z.string().uuid(),
-  prompt_session_id: import_zod.z.string().uuid(),
-  prompt_session_data: import_zod.z.unknown().optional(),
-  prompt_data: import_zod.z.unknown().optional(),
-  function_data: import_zod.z.unknown().optional(),
+var PromptOptions = import_v35.z.object({ model: import_v35.z.string(), params: ModelParams, position: import_v35.z.string() }).partial();
+var PromptSessionEvent = import_v35.z.object({
+  id: import_v35.z.string(),
+  _xact_id: import_v35.z.string(),
+  created: import_v35.z.string().datetime({ offset: true }),
+  _pagination_key: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  project_id: import_v35.z.string().uuid(),
+  prompt_session_id: import_v35.z.string().uuid(),
+  prompt_session_data: import_v35.z.unknown().optional(),
+  prompt_data: import_v35.z.unknown().optional(),
+  function_data: import_v35.z.unknown().optional(),
   function_type: FunctionTypeEnumNullish.optional(),
-  object_data: import_zod.z.unknown().optional(),
-  completion: import_zod.z.unknown().optional(),
-  tags: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]).optional()
+  object_data: import_v35.z.unknown().optional(),
+  completion: import_v35.z.unknown().optional(),
+  tags: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]).optional()
 });
-var ResponseFormat = import_zod.z.union([
-  import_zod.z.object({ type: import_zod.z.literal("json_object") }),
-  import_zod.z.object({
-    type: import_zod.z.literal("json_schema"),
+var ResponseFormat = import_v35.z.union([
+  import_v35.z.object({ type: import_v35.z.literal("json_object") }),
+  import_v35.z.object({
+    type: import_v35.z.literal("json_schema"),
     json_schema: ResponseFormatJsonSchema
   }),
-  import_zod.z.object({ type: import_zod.z.literal("text") })
+  import_v35.z.object({ type: import_v35.z.literal("text") })
 ]);
-var Role = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  org_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  member_permissions: import_zod.z.union([
-    import_zod.z.array(
-      import_zod.z.object({
+var Role = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  org_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  member_permissions: import_v35.z.union([
+    import_v35.z.array(
+      import_v35.z.object({
         permission: Permission,
         restrict_object_type: AclObjectType.optional()
       })
     ),
-    import_zod.z.null()
+    import_v35.z.null()
   ]).optional(),
-  member_roles: import_zod.z.union([import_zod.z.array(import_zod.z.string().uuid()), import_zod.z.null()]).optional()
+  member_roles: import_v35.z.union([import_v35.z.array(import_v35.z.string().uuid()), import_v35.z.null()]).optional()
 });
-var RunEval = import_zod.z.object({
-  project_id: import_zod.z.string(),
-  data: import_zod.z.union([
-    import_zod.z.object({
-      dataset_id: import_zod.z.string(),
-      _internal_btql: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+var RunEval = import_v35.z.object({
+  project_id: import_v35.z.string(),
+  data: import_v35.z.union([
+    import_v35.z.object({
+      dataset_id: import_v35.z.string(),
+      _internal_btql: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional()
     }),
-    import_zod.z.object({
-      project_name: import_zod.z.string(),
-      dataset_name: import_zod.z.string(),
-      _internal_btql: import_zod.z.union([import_zod.z.object({}).partial().passthrough(), import_zod.z.null()]).optional()
+    import_v35.z.object({
+      project_name: import_v35.z.string(),
+      dataset_name: import_v35.z.string(),
+      _internal_btql: import_v35.z.union([import_v35.z.object({}).partial().passthrough(), import_v35.z.null()]).optional()
     }),
-    import_zod.z.object({ data: import_zod.z.array(import_zod.z.unknown()) })
+    import_v35.z.object({ data: import_v35.z.array(import_v35.z.unknown()) })
   ]),
-  task: FunctionId.and(import_zod.z.unknown()),
-  scores: import_zod.z.array(FunctionId),
-  experiment_name: import_zod.z.string().optional(),
-  metadata: import_zod.z.object({}).partial().passthrough().optional(),
-  parent: InvokeParent.and(import_zod.z.unknown()).optional(),
-  stream: import_zod.z.boolean().optional(),
-  trial_count: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional(),
-  is_public: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
-  timeout: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional(),
-  max_concurrency: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]).optional().default(10),
-  base_experiment_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  base_experiment_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  task: FunctionId.and(import_v35.z.unknown()),
+  scores: import_v35.z.array(FunctionId),
+  experiment_name: import_v35.z.string().optional(),
+  metadata: import_v35.z.object({}).partial().passthrough().optional(),
+  parent: InvokeParent.and(import_v35.z.unknown()).optional(),
+  stream: import_v35.z.boolean().optional(),
+  trial_count: import_v35.z.union([import_v35.z.number(), import_v35.z.null()]).optional(),
+  is_public: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
+  timeout: import_v35.z.union([import_v35.z.number(), import_v35.z.null()]).optional(),
+  max_concurrency: import_v35.z.union([import_v35.z.number(), import_v35.z.null()]).optional().default(10),
+  base_experiment_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  base_experiment_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   git_metadata_settings: GitMetadataSettings.and(
-    import_zod.z.union([import_zod.z.object({}).partial(), import_zod.z.null()])
+    import_v35.z.union([import_v35.z.object({}).partial(), import_v35.z.null()])
   ).optional(),
-  repo_info: RepoInfo.and(import_zod.z.unknown()).optional(),
-  strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional(),
-  stop_token: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  extra_messages: import_zod.z.string().optional(),
-  tags: import_zod.z.array(import_zod.z.string()).optional()
+  repo_info: RepoInfo.and(import_v35.z.unknown()).optional(),
+  strict: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional(),
+  stop_token: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  extra_messages: import_v35.z.string().optional(),
+  tags: import_v35.z.array(import_v35.z.string()).optional()
 });
-var ServiceToken = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  preview_name: import_zod.z.string(),
-  service_account_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  service_account_email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  service_account_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  org_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var ServiceToken = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  preview_name: import_v35.z.string(),
+  service_account_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  service_account_email: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  service_account_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  org_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var SpanIFrame = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  project_id: import_zod.z.string().uuid(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  name: import_zod.z.string(),
-  description: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  url: import_zod.z.string(),
-  post_message: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+var SpanIFrame = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  project_id: import_v35.z.string().uuid(),
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  name: import_v35.z.string(),
+  description: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  url: import_v35.z.string(),
+  post_message: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional()
 });
-var SSEConsoleEventData = import_zod.z.object({
-  stream: import_zod.z.enum(["stderr", "stdout"]),
-  message: import_zod.z.string()
+var SSEConsoleEventData = import_v35.z.object({
+  stream: import_v35.z.enum(["stderr", "stdout"]),
+  message: import_v35.z.string()
 });
-var SSEProgressEventData = import_zod.z.object({
-  id: import_zod.z.string(),
+var SSEProgressEventData = import_v35.z.object({
+  id: import_v35.z.string(),
   object_type: FunctionObjectType,
-  origin: ObjectReferenceNullish.and(import_zod.z.unknown()).optional(),
+  origin: ObjectReferenceNullish.and(import_v35.z.unknown()).optional(),
   format: FunctionFormat,
   output_type: FunctionOutputType,
-  name: import_zod.z.string(),
-  event: import_zod.z.enum([
+  name: import_v35.z.string(),
+  event: import_v35.z.enum([
     "reasoning_delta",
     "text_delta",
     "json_delta",
@@ -2567,110 +3585,110 @@ var SSEProgressEventData = import_zod.z.object({
     "done",
     "progress"
   ]),
-  data: import_zod.z.string()
+  data: import_v35.z.string()
 });
-var ToolFunctionDefinition = import_zod.z.object({
-  type: import_zod.z.literal("function"),
-  function: import_zod.z.object({
-    name: import_zod.z.string(),
-    description: import_zod.z.string().optional(),
-    parameters: import_zod.z.object({}).partial().passthrough().optional(),
-    strict: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]).optional()
+var ToolFunctionDefinition = import_v35.z.object({
+  type: import_v35.z.literal("function"),
+  function: import_v35.z.object({
+    name: import_v35.z.string(),
+    description: import_v35.z.string().optional(),
+    parameters: import_v35.z.object({}).partial().passthrough().optional(),
+    strict: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]).optional()
   })
 });
-var User = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  given_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  family_name: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  email: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  avatar_url: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+var User = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  given_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  family_name: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  email: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  avatar_url: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
-var ViewDataSearch = import_zod.z.union([
-  import_zod.z.object({
-    filter: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()]),
-    tag: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()]),
-    match: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()]),
-    sort: import_zod.z.union([import_zod.z.array(import_zod.z.unknown()), import_zod.z.null()])
+var ViewDataSearch = import_v35.z.union([
+  import_v35.z.object({
+    filter: import_v35.z.union([import_v35.z.array(import_v35.z.unknown()), import_v35.z.null()]),
+    tag: import_v35.z.union([import_v35.z.array(import_v35.z.unknown()), import_v35.z.null()]),
+    match: import_v35.z.union([import_v35.z.array(import_v35.z.unknown()), import_v35.z.null()]),
+    sort: import_v35.z.union([import_v35.z.array(import_v35.z.unknown()), import_v35.z.null()])
   }).partial(),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var ViewData = import_zod.z.union([
-  import_zod.z.object({ search: ViewDataSearch }).partial(),
-  import_zod.z.null()
+var ViewData = import_v35.z.union([
+  import_v35.z.object({ search: ViewDataSearch }).partial(),
+  import_v35.z.null()
 ]);
-var ViewOptions = import_zod.z.union([
-  import_zod.z.object({
-    viewType: import_zod.z.literal("monitor"),
-    options: import_zod.z.object({
-      spanType: import_zod.z.union([import_zod.z.enum(["range", "frame"]), import_zod.z.null()]),
-      rangeValue: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      frameStart: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      frameEnd: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      tzUTC: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
-      chartVisibility: import_zod.z.union([import_zod.z.record(import_zod.z.boolean()), import_zod.z.null()]),
-      projectId: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-      type: import_zod.z.union([import_zod.z.enum(["project", "experiment"]), import_zod.z.null()]),
-      groupBy: import_zod.z.union([import_zod.z.string(), import_zod.z.null()])
+var ViewOptions = import_v35.z.union([
+  import_v35.z.object({
+    viewType: import_v35.z.literal("monitor"),
+    options: import_v35.z.object({
+      spanType: import_v35.z.union([import_v35.z.enum(["range", "frame"]), import_v35.z.null()]),
+      rangeValue: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      frameStart: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      frameEnd: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      tzUTC: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]),
+      chartVisibility: import_v35.z.union([import_v35.z.record(import_v35.z.boolean()), import_v35.z.null()]),
+      projectId: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+      type: import_v35.z.union([import_v35.z.enum(["project", "experiment"]), import_v35.z.null()]),
+      groupBy: import_v35.z.union([import_v35.z.string(), import_v35.z.null()])
     }).partial()
   }),
-  import_zod.z.object({
-    columnVisibility: import_zod.z.union([import_zod.z.record(import_zod.z.boolean()), import_zod.z.null()]),
-    columnOrder: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.null()]),
-    columnSizing: import_zod.z.union([import_zod.z.record(import_zod.z.number()), import_zod.z.null()]),
-    grouping: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    rowHeight: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    tallGroupRows: import_zod.z.union([import_zod.z.boolean(), import_zod.z.null()]),
-    layout: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    chartHeight: import_zod.z.union([import_zod.z.number(), import_zod.z.null()]),
-    excludedMeasures: import_zod.z.union([
-      import_zod.z.array(
-        import_zod.z.object({
-          type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
-          value: import_zod.z.string()
+  import_v35.z.object({
+    columnVisibility: import_v35.z.union([import_v35.z.record(import_v35.z.boolean()), import_v35.z.null()]),
+    columnOrder: import_v35.z.union([import_v35.z.array(import_v35.z.string()), import_v35.z.null()]),
+    columnSizing: import_v35.z.union([import_v35.z.record(import_v35.z.number()), import_v35.z.null()]),
+    grouping: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    rowHeight: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    tallGroupRows: import_v35.z.union([import_v35.z.boolean(), import_v35.z.null()]),
+    layout: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    chartHeight: import_v35.z.union([import_v35.z.number(), import_v35.z.null()]),
+    excludedMeasures: import_v35.z.union([
+      import_v35.z.array(
+        import_v35.z.object({
+          type: import_v35.z.enum(["none", "score", "metric", "metadata"]),
+          value: import_v35.z.string()
         })
       ),
-      import_zod.z.null()
+      import_v35.z.null()
     ]),
-    yMetric: import_zod.z.union([
-      import_zod.z.object({
-        type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
-        value: import_zod.z.string()
+    yMetric: import_v35.z.union([
+      import_v35.z.object({
+        type: import_v35.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_v35.z.string()
       }),
-      import_zod.z.null()
+      import_v35.z.null()
     ]),
-    xAxis: import_zod.z.union([
-      import_zod.z.object({
-        type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
-        value: import_zod.z.string()
+    xAxis: import_v35.z.union([
+      import_v35.z.object({
+        type: import_v35.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_v35.z.string()
       }),
-      import_zod.z.null()
+      import_v35.z.null()
     ]),
-    symbolGrouping: import_zod.z.union([
-      import_zod.z.object({
-        type: import_zod.z.enum(["none", "score", "metric", "metadata"]),
-        value: import_zod.z.string()
+    symbolGrouping: import_v35.z.union([
+      import_v35.z.object({
+        type: import_v35.z.enum(["none", "score", "metric", "metadata"]),
+        value: import_v35.z.string()
       }),
-      import_zod.z.null()
+      import_v35.z.null()
     ]),
-    xAxisAggregation: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]),
-    chartAnnotations: import_zod.z.union([
-      import_zod.z.array(import_zod.z.object({ id: import_zod.z.string(), text: import_zod.z.string() })),
-      import_zod.z.null()
+    xAxisAggregation: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]),
+    chartAnnotations: import_v35.z.union([
+      import_v35.z.array(import_v35.z.object({ id: import_v35.z.string(), text: import_v35.z.string() })),
+      import_v35.z.null()
     ]),
-    timeRangeFilter: import_zod.z.union([
-      import_zod.z.string(),
-      import_zod.z.object({ from: import_zod.z.string(), to: import_zod.z.string() }),
-      import_zod.z.null()
+    timeRangeFilter: import_v35.z.union([
+      import_v35.z.string(),
+      import_v35.z.object({ from: import_v35.z.string(), to: import_v35.z.string() }),
+      import_v35.z.null()
     ])
   }).partial(),
-  import_zod.z.null()
+  import_v35.z.null()
 ]);
-var View = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  object_type: AclObjectType.and(import_zod.z.string()),
-  object_id: import_zod.z.string().uuid(),
-  view_type: import_zod.z.enum([
+var View = import_v35.z.object({
+  id: import_v35.z.string().uuid(),
+  object_type: AclObjectType.and(import_v35.z.string()),
+  object_id: import_v35.z.string().uuid(),
+  view_type: import_v35.z.enum([
     "projects",
     "experiments",
     "experiment",
@@ -2685,54 +3703,54 @@ var View = import_zod.z.object({
     "agents",
     "monitor"
   ]),
-  name: import_zod.z.string(),
-  created: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
+  name: import_v35.z.string(),
+  created: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
   view_data: ViewData.optional(),
   options: ViewOptions.optional(),
-  user_id: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional(),
-  deleted_at: import_zod.z.union([import_zod.z.string(), import_zod.z.null()]).optional()
+  user_id: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional(),
+  deleted_at: import_v35.z.union([import_v35.z.string(), import_v35.z.null()]).optional()
 });
 
 // src/logger.ts
 var import_functions = require("@vercel/functions");
 var import_mustache2 = __toESM(require("mustache"));
-var import_zod3 = require("zod");
+var import_zod = require("zod");
 
 // src/functions/stream.ts
 var import_eventsource_parser = require("eventsource-parser");
-var import_zod2 = require("zod");
-var braintrustStreamChunkSchema = import_zod2.z.union([
-  import_zod2.z.object({
-    type: import_zod2.z.literal("text_delta"),
-    data: import_zod2.z.string()
+var import_v36 = require("zod/v3");
+var braintrustStreamChunkSchema = import_v36.z.union([
+  import_v36.z.object({
+    type: import_v36.z.literal("text_delta"),
+    data: import_v36.z.string()
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("reasoning_delta"),
-    data: import_zod2.z.string()
+  import_v36.z.object({
+    type: import_v36.z.literal("reasoning_delta"),
+    data: import_v36.z.string()
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("json_delta"),
-    data: import_zod2.z.string()
+  import_v36.z.object({
+    type: import_v36.z.literal("json_delta"),
+    data: import_v36.z.string()
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("error"),
-    data: import_zod2.z.string()
+  import_v36.z.object({
+    type: import_v36.z.literal("error"),
+    data: import_v36.z.string()
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("console"),
+  import_v36.z.object({
+    type: import_v36.z.literal("console"),
     data: SSEConsoleEventData
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("progress"),
+  import_v36.z.object({
+    type: import_v36.z.literal("progress"),
     data: SSEProgressEventData
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("start"),
-    data: import_zod2.z.string()
+  import_v36.z.object({
+    type: import_v36.z.literal("start"),
+    data: import_v36.z.string()
   }),
-  import_zod2.z.object({
-    type: import_zod2.z.literal("done"),
-    data: import_zod2.z.string()
+  import_v36.z.object({
+    type: import_v36.z.literal("done"),
+    data: import_v36.z.string()
   })
 ]);
 var BraintrustStream = class _BraintrustStream {
@@ -3268,7 +4286,7 @@ function runCatchFinally(f, catchF, finallyF) {
 function getCurrentUnixTimestamp() {
   return (/* @__PURE__ */ new Date()).getTime() / 1e3;
 }
-function isEmpty(a) {
+function isEmpty2(a) {
   return a === void 0 || a === null;
 }
 var LazyValue = class {
@@ -3341,13 +4359,12 @@ var InternalAbortError = class extends Error {
 };
 
 // src/mustache-utils.ts
-var import_core = require("@braintrust/core");
 var import_mustache = __toESM(require("mustache"));
 function lintTemplate(template, context2) {
   const variables = getMustacheVars(template);
   for (const variable of variables) {
     const arrPathsReplaced = variable[1].replaceAll(/\.\d+/g, ".0");
-    const fieldExists = (0, import_core.getObjValueByPath)(context2, arrPathsReplaced.split(".")) !== void 0;
+    const fieldExists = getObjValueByPath(context2, arrPathsReplaced.split(".")) !== void 0;
     if (!fieldExists) {
       throw new Error(`Variable '${variable[1]}' does not exist.`);
     }
@@ -3364,7 +4381,6 @@ function getMustacheVars(prompt) {
 }
 
 // src/logger.ts
-var import_core3 = require("@braintrust/core");
 var BRAINTRUST_ATTACHMENT = BraintrustAttachmentReference.shape.type.value;
 var EXTERNAL_ATTACHMENT = ExternalAttachmentReference.shape.type.value;
 var BRAINTRUST_PARAMS = Object.keys(BraintrustModelParams.shape);
@@ -3452,14 +4468,14 @@ var NoopSpan = class {
 };
 var NOOP_SPAN = new NoopSpan();
 var NOOP_SPAN_PERMALINK = "https://braintrust.dev/noop-span";
-var loginSchema = import_zod3.z.strictObject({
-  appUrl: import_zod3.z.string(),
-  appPublicUrl: import_zod3.z.string(),
-  orgName: import_zod3.z.string(),
-  apiUrl: import_zod3.z.string(),
-  proxyUrl: import_zod3.z.string(),
-  loginToken: import_zod3.z.string(),
-  orgId: import_zod3.z.string().nullish(),
+var loginSchema = import_zod.z.strictObject({
+  appUrl: import_zod.z.string(),
+  appPublicUrl: import_zod.z.string(),
+  orgName: import_zod.z.string(),
+  apiUrl: import_zod.z.string(),
+  proxyUrl: import_zod.z.string(),
+  loginToken: import_zod.z.string(),
+  orgId: import_zod.z.string().nullish(),
   gitMetadataSettings: GitMetadataSettings.nullish()
 });
 var stateNonce = 0;
@@ -3612,7 +4628,7 @@ var BraintrustState = class _BraintrustState {
     const newState = await loginToState({
       ...this.loginParams,
       ...Object.fromEntries(
-        Object.entries(loginParams).filter(([k, v]) => !isEmpty(v))
+        Object.entries(loginParams).filter(([k, v]) => !isEmpty2(v))
       )
     });
     this.copyLoginInfo(newState);
@@ -3748,7 +4764,7 @@ var HTTPConnection = class _HTTPConnection {
   }
   async get(path9, params = void 0, config3) {
     const { headers, ...rest } = config3 || {};
-    const url = new URL((0, import_core2._urljoin)(this.base_url, path9));
+    const url = new URL(_urljoin(this.base_url, path9));
     url.search = new URLSearchParams(
       params ? Object.entries(params).filter(([_, v]) => v !== void 0).flatMap(
         ([k, v]) => v !== void 0 ? typeof v === "string" ? [[k, v]] : v.map((x) => [k, x]) : []
@@ -3775,7 +4791,7 @@ var HTTPConnection = class _HTTPConnection {
     const this_base_url = this.base_url;
     const this_headers = this.headers;
     return await checkResponse(
-      await this_fetch((0, import_core2._urljoin)(this_base_url, path9), {
+      await this_fetch(_urljoin(this_base_url, path9), {
         method: "POST",
         headers: {
           Accept: "application/json",
@@ -3912,12 +4928,12 @@ var Attachment = class extends BaseAttachment {
       let signedUrl;
       let headers;
       try {
-        ({ signedUrl, headers } = import_zod3.z.object({
-          signedUrl: import_zod3.z.string().url(),
-          headers: import_zod3.z.record(import_zod3.z.string())
+        ({ signedUrl, headers } = import_zod.z.object({
+          signedUrl: import_zod.z.string().url(),
+          headers: import_zod.z.record(import_zod.z.string())
         }).parse(await metadataResponse.json()));
       } catch (error2) {
-        if (error2 instanceof import_zod3.ZodError) {
+        if (error2 instanceof import_zod.ZodError) {
           const errorStr = JSON.stringify(error2.flatten());
           throw new Error(`Invalid response from API server: ${errorStr}`);
         }
@@ -4002,8 +5018,8 @@ with a Blob/ArrayBuffer, or run the program on Node.js.`
     }
   }
 };
-var attachmentMetadataSchema = import_zod3.z.object({
-  downloadUrl: import_zod3.z.string(),
+var attachmentMetadataSchema = import_zod.z.object({
+  downloadUrl: import_zod.z.string(),
   status: AttachmentStatus
 });
 var ReadonlyAttachment = class {
@@ -4103,10 +5119,10 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
   source: inputSource
 }) {
   const source = inputSource ?? "external";
-  if (!import_core2.VALID_SOURCES.includes(source)) {
-    throw new Error(`source must be one of ${import_core2.VALID_SOURCES}`);
+  if (!VALID_SOURCES.includes(source)) {
+    throw new Error(`source must be one of ${VALID_SOURCES}`);
   }
-  if (isEmpty(scores) && isEmpty(expected) && isEmpty(tags) && isEmpty(comment)) {
+  if (isEmpty2(scores) && isEmpty2(expected) && isEmpty2(tags) && isEmpty2(comment)) {
     throw new Error(
       "At least one of scores, expected, tags, or comment must be specified"
     );
@@ -4119,9 +5135,9 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
   });
   let { metadata, ...updateEvent } = deepCopyEvent(validatedEvent);
   updateEvent = Object.fromEntries(
-    Object.entries(updateEvent).filter(([_, v]) => !isEmpty(v))
+    Object.entries(updateEvent).filter(([_, v]) => !isEmpty2(v))
   );
-  const parentIds = async () => new import_core2.SpanComponentsV3({
+  const parentIds = async () => new SpanComponentsV3({
     object_type: parentObjectType,
     object_id: await parentObjectId.get()
   }).objectIdFields();
@@ -4131,14 +5147,14 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
         id,
         ...updateEvent,
         ...await parentIds(),
-        [import_core2.AUDIT_SOURCE_FIELD]: source,
-        [import_core2.AUDIT_METADATA_FIELD]: metadata,
-        [import_core2.IS_MERGE_FIELD]: true
+        [AUDIT_SOURCE_FIELD]: source,
+        [AUDIT_METADATA_FIELD]: metadata,
+        [IS_MERGE_FIELD]: true
       };
     });
     state.bgLogger().log([record]);
   }
-  if (!isEmpty(comment)) {
+  if (!isEmpty2(comment)) {
     const record = new LazyValue(async () => {
       return {
         id: (0, import_uuid.v4)(),
@@ -4152,8 +5168,8 @@ function logFeedbackImpl(state, parentObjectType, parentObjectId, {
           text: comment
         },
         ...await parentIds(),
-        [import_core2.AUDIT_SOURCE_FIELD]: source,
-        [import_core2.AUDIT_METADATA_FIELD]: metadata
+        [AUDIT_SOURCE_FIELD]: source,
+        [AUDIT_METADATA_FIELD]: metadata
       };
     });
     state.bgLogger().log([record]);
@@ -4172,7 +5188,7 @@ function updateSpanImpl({
       ...event
     })
   );
-  const parentIds = async () => new import_core2.SpanComponentsV3({
+  const parentIds = async () => new SpanComponentsV3({
     object_type: parentObjectType,
     object_id: await parentObjectId.get()
   }).objectIdFields();
@@ -4180,7 +5196,7 @@ function updateSpanImpl({
     id,
     ...updateEvent,
     ...await parentIds(),
-    [import_core2.IS_MERGE_FIELD]: true
+    [IS_MERGE_FIELD]: true
   }));
   state.bgLogger().log([record]);
 }
@@ -4195,15 +5211,15 @@ function spanComponentsToObjectIdLambda(state, components) {
     );
   }
   switch (components.data.object_type) {
-    case import_core2.SpanObjectTypeV3.EXPERIMENT:
+    case 1 /* EXPERIMENT */:
       throw new Error(
         "Impossible: computeObjectMetadataArgs not supported for experiments"
       );
-    case import_core2.SpanObjectTypeV3.PLAYGROUND_LOGS:
+    case 3 /* PLAYGROUND_LOGS */:
       throw new Error(
         "Impossible: computeObjectMetadataArgs not supported for prompt sessions"
       );
-    case import_core2.SpanObjectTypeV3.PROJECT_LOGS:
+    case 2 /* PROJECT_LOGS */:
       return async () => (await computeLoggerMetadata(state, {
         ...components.data.compute_object_metadata_args
       })).project.id;
@@ -4254,8 +5270,8 @@ async function permalink(slug, opts) {
     return state.appUrl;
   };
   try {
-    const components = import_core2.SpanComponentsV3.fromStr(slug);
-    const object_type = (0, import_core2.spanObjectTypeV3ToString)(components.data.object_type);
+    const components = SpanComponentsV3.fromStr(slug);
+    const object_type = spanObjectTypeV3ToString(components.data.object_type);
     const [orgName, appUrl, object_id] = await Promise.all([
       getOrgName(),
       getAppUrl(),
@@ -4282,7 +5298,7 @@ function startSpanParentArgs(args) {
     if (args.parentSpanIds) {
       throw new Error("Cannot specify both parent and parentSpanIds");
     }
-    const parentComponents = import_core2.SpanComponentsV3.fromStr(args.parent);
+    const parentComponents = SpanComponentsV3.fromStr(args.parent);
     if (args.parentObjectType !== parentComponents.data.object_type) {
       throw new Error(
         `Mismatch between expected span parent object type ${args.parentObjectType} and provided type ${parentComponents.data.object_type}`
@@ -4355,7 +5371,7 @@ var Logger = class {
     return (async () => (await this.project).id)();
   }
   parentObjectType() {
-    return import_core2.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.
@@ -4449,7 +5465,7 @@ var Logger = class {
         parentSpanIds: args?.parentSpanIds,
         propagatedEvent: args?.propagatedEvent
       }),
-      defaultRootType: import_core2.SpanTypeAttribute.TASK
+      defaultRootType: "task" /* TASK */
     });
   }
   /**
@@ -4491,7 +5507,7 @@ var Logger = class {
    * See {@link Span.startSpan} for more details.
    */
   async export() {
-    return new import_core2.SpanComponentsV3({
+    return new SpanComponentsV3({
       object_type: this.parentObjectType(),
       ...this.computeMetadataArgs && !this.lazyId.hasSucceeded ? { compute_object_metadata_args: this.computeMetadataArgs } : { object_id: await this.lazyId.get() }
     }).toStr();
@@ -4516,7 +5532,7 @@ function castLogger(logger, asyncFlush) {
   return logger;
 }
 function constructLogs3Data(items) {
-  return `{"rows": ${(0, import_core2.constructJsonArray)(items)}, "api_version": 2}`;
+  return `{"rows": ${constructJsonArray(items)}, "api_version": 2}`;
 }
 function now() {
   return (/* @__PURE__ */ new Date()).getTime();
@@ -4642,7 +5658,7 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
     const allItemsStr = allItems.map(
       (bucket) => bucket.map((item) => JSON.stringify(item))
     );
-    const batchSets = (0, import_core2.batchItems)({
+    const batchSets = batchItems({
       items: allItemsStr,
       batchMaxNumItems: batchSize,
       batchMaxNumBytes: this.maxRequestSize / 2
@@ -4696,7 +5712,7 @@ var HTTPBackgroundLogger = class _HTTPBackgroundLogger {
         const items = await Promise.all(wrappedItems.map((x) => x.get()));
         const attachments = [];
         items.forEach((item) => extractAttachments(item, attachments));
-        let mergedItems = (0, import_core2.mergeRowBatch)(items);
+        let mergedItems = mergeRowBatch(items);
         if (this.maskingFunction) {
           mergedItems = mergedItems.map(
             (batch) => batch.map((item) => {
@@ -4952,7 +5968,7 @@ function init(projectOrOptions, optionalOptions) {
   const state = stateArg ?? _globalState;
   state.enforceQueueSizeLimit(false);
   if (open) {
-    if (isEmpty(experiment)) {
+    if (isEmpty2(experiment)) {
       throw new Error(`Cannot open an experiment without specifying its name`);
     }
     const lazyMetadata2 = new LazyValue(
@@ -5015,7 +6031,7 @@ function init(projectOrOptions, optionalOptions) {
           }
         };
         if (gitMetadataSettings) {
-          mergedGitMetadataSettings = (0, import_core2.mergeGitMetadataSettings)(
+          mergedGitMetadataSettings = mergeGitMetadataSettings(
             mergedGitMetadataSettings,
             gitMetadataSettings
           );
@@ -5155,7 +6171,7 @@ async function computeLoggerMetadata(state, {
 }) {
   await state.login({});
   const org_id = state.orgId;
-  if (isEmpty(project_id)) {
+  if (isEmpty2(project_id)) {
     const response = await state.appConn().post_json("api/project/register", {
       project_name: project_name || GLOBAL_PROJECT,
       org_id
@@ -5168,7 +6184,7 @@ async function computeLoggerMetadata(state, {
         fullInfo: response.project
       }
     };
-  } else if (isEmpty(project_name)) {
+  } else if (isEmpty2(project_name)) {
     const response = await state.appConn().get_json("api/project", {
       id: project_id
     });
@@ -5191,7 +6207,7 @@ async function login(options = {}) {
   const { forceLogin = false } = options || {};
   if (_globalState.loggedIn && !forceLogin) {
     let checkUpdatedParam2 = function(varname, arg, orig) {
-      if (!isEmpty(arg) && !isEmpty(orig) && arg !== orig) {
+      if (!isEmpty2(arg) && !isEmpty2(orig) && arg !== orig) {
         throw new Error(
           `Re-logging in with different ${varname} (${arg}) than original (${orig}). To force re-login, pass \`forceLogin: true\``
         );
@@ -5242,7 +6258,7 @@ async function loginToState(options = {}) {
     return state;
   } else {
     const resp = await checkResponse(
-      await fetch2((0, import_core2._urljoin)(state.appUrl, `/api/apikey/login`), {
+      await fetch2(_urljoin(state.appUrl, `/api/apikey/login`), {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -5297,6 +6313,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;
@@ -5357,35 +6375,35 @@ async function flush(options) {
 }
 function startSpanAndIsLogger(args) {
   const state = args?.state ?? _globalState;
-  const parentStr = args?.parent ?? state.currentParent.getStore();
-  const components = parentStr ? import_core2.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 === import_core2.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,
@@ -5489,7 +6507,7 @@ function validateAndSanitizeExperimentLogPartialArgs(event) {
 function deepCopyEvent(event) {
   const attachments = [];
   const IDENTIFIER = "_bt_internal_saved_attachment";
-  const savedAttachmentSchema = import_zod3.z.strictObject({ [IDENTIFIER]: import_zod3.z.number() });
+  const savedAttachmentSchema = import_zod.z.strictObject({ [IDENTIFIER]: import_zod.z.number() });
   const serialized = JSON.stringify(event, (_k, v) => {
     if (v instanceof SpanImpl || v instanceof NoopSpan) {
       return `<span>`;
@@ -5573,15 +6591,15 @@ async function resolveAttachmentsToBase64(event, state) {
   return event;
 }
 function validateAndSanitizeExperimentLogFullArgs(event, hasDataset) {
-  if ("input" in event && !isEmpty(event.input) && "inputs" in event && !isEmpty(event.inputs) || !("input" in event) && !("inputs" in event)) {
+  if ("input" in event && !isEmpty2(event.input) && "inputs" in event && !isEmpty2(event.inputs) || !("input" in event) && !("inputs" in event)) {
     throw new Error(
       "Exactly one of input or inputs (deprecated) must be specified. Prefer input."
     );
   }
-  if (isEmpty(event.output)) {
+  if (isEmpty2(event.output)) {
     throw new Error("output must be specified");
   }
-  if (isEmpty(event.scores)) {
+  if (isEmpty2(event.scores)) {
     throw new Error("scores must be specified");
   }
   if (hasDataset && event.datasetRecordId === void 0) {
@@ -5681,7 +6699,7 @@ var ObjectFetcher = class {
       const fetchedData = await this.fetchedData();
       let maxVersion = void 0;
       for (const record of fetchedData) {
-        const xactId = String(record[import_core2.TRANSACTION_ID_FIELD] ?? "0");
+        const xactId = String(record[TRANSACTION_ID_FIELD] ?? "0");
         if (maxVersion === void 0 || xactId > maxVersion) {
           maxVersion = xactId;
         }
@@ -5724,7 +6742,7 @@ var Experiment2 = class extends ObjectFetcher {
     })();
   }
   parentObjectType() {
-    return import_core2.SpanObjectTypeV3.EXPERIMENT;
+    return 1 /* EXPERIMENT */;
   }
   async getState() {
     await this.lazyMetadata.get();
@@ -5808,7 +6826,7 @@ var Experiment2 = class extends ObjectFetcher {
         parentSpanIds: void 0,
         propagatedEvent: args?.propagatedEvent
       }),
-      defaultRootType: import_core2.SpanTypeAttribute.EVAL
+      defaultRootType: "eval" /* EVAL */
     });
   }
   async fetchBaseExperiment() {
@@ -5932,7 +6950,7 @@ View complete results in Braintrust or run experiment.summarize() again.`
    * See {@link Span.startSpan} for more details.
    */
   async export() {
-    return new import_core2.SpanComponentsV3({
+    return new SpanComponentsV3({
       object_type: this.parentObjectType(),
       object_id: await this.id
     }).toStr();
@@ -6019,7 +7037,7 @@ var SpanImpl = class _SpanImpl {
     this.parentComputeObjectMetadataArgs = args.parentComputeObjectMetadataArgs;
     this.propagatedEvent = args.propagatedEvent;
     if (this.propagatedEvent) {
-      (0, import_core2.mergeDicts)(rawEvent, this.propagatedEvent);
+      mergeDicts(rawEvent, this.propagatedEvent);
     }
     const { id: eventId, ...event } = rawEvent;
     const callerLocation = isomorph_default.getCallerLocation();
@@ -6096,7 +7114,7 @@ var SpanImpl = class _SpanImpl {
       root_span_id: this._rootSpanId,
       span_parents: this._spanParents,
       ...serializableInternalData,
-      [import_core2.IS_MERGE_FIELD]: this.isMerge
+      [IS_MERGE_FIELD]: this.isMerge
     });
     if (partialRecord.metrics?.end) {
       this.loggedEndTime = partialRecord.metrics?.end;
@@ -6114,7 +7132,7 @@ var SpanImpl = class _SpanImpl {
           ])
         )
       ),
-      ...new import_core2.SpanComponentsV3({
+      ...new SpanComponentsV3({
         object_type: this.parentObjectType,
         object_id: await this.parentObjectId.get()
       }).objectIdFields()
@@ -6194,7 +7212,7 @@ var SpanImpl = class _SpanImpl {
     return endTime;
   }
   async export() {
-    return new import_core2.SpanComponentsV3({
+    return new SpanComponentsV3({
       object_type: this.parentObjectType,
       ...this.parentComputeObjectMetadataArgs && !this.parentObjectId.hasSucceeded ? { compute_object_metadata_args: this.parentComputeObjectMetadataArgs } : { object_id: await this.parentObjectId.get() },
       row_id: this.id,
@@ -6227,7 +7245,7 @@ var SpanImpl = class _SpanImpl {
     const baseUrl = `${appUrl}/app/${orgName}`;
     const args = this.parentComputeObjectMetadataArgs;
     switch (this.parentObjectType) {
-      case import_core2.SpanObjectTypeV3.PROJECT_LOGS: {
+      case 2 /* PROJECT_LOGS */: {
         const projectID = args?.project_id || this.parentObjectId.getSync().value;
         const projectName = args?.project_name;
         if (projectID) {
@@ -6238,7 +7256,7 @@ var SpanImpl = class _SpanImpl {
           return getErrPermlink("provide-project-name-or-id");
         }
       }
-      case import_core2.SpanObjectTypeV3.EXPERIMENT: {
+      case 1 /* EXPERIMENT */: {
         const expID = args?.experiment_id || this.parentObjectId?.getSync()?.value;
         if (!expID) {
           return getErrPermlink("provide-experiment-id");
@@ -6246,7 +7264,7 @@ var SpanImpl = class _SpanImpl {
           return `${baseUrl}/object?object_type=experiment&object_id=${expID}&id=${this._id}`;
         }
       }
-      case import_core2.SpanObjectTypeV3.PLAYGROUND_LOGS: {
+      case 3 /* PLAYGROUND_LOGS */: {
         return NOOP_SPAN_PERMALINK;
       }
       default: {
@@ -6272,8 +7290,8 @@ function splitLoggingData({
 }) {
   const sanitized = validateAndSanitizeExperimentLogPartialArgs(event ?? {});
   const sanitizedAndInternalData = {};
-  (0, import_core2.mergeDicts)(sanitizedAndInternalData, internalData || {});
-  (0, import_core2.mergeDicts)(sanitizedAndInternalData, sanitized);
+  mergeDicts(sanitizedAndInternalData, internalData || {});
+  mergeDicts(sanitizedAndInternalData, sanitized);
   const serializableInternalData = {};
   const lazyInternalData = {};
   for (const [key, value] of Object.entries(sanitizedAndInternalData)) {
@@ -6298,7 +7316,7 @@ function splitLoggingData({
 }
 var Dataset2 = class extends ObjectFetcher {
   constructor(state, lazyMetadata, pinnedVersion, legacy, _internal_btql) {
-    const isLegacyDataset = legacy ?? import_core2.DEFAULT_IS_LEGACY_DATASET;
+    const isLegacyDataset = legacy ?? DEFAULT_IS_LEGACY_DATASET;
     if (isLegacyDataset) {
       console.warn(
         `Records will be fetched from this dataset in the legacy format, with the "expected" field renamed to "output". Please update your code to use "expected", and use \`braintrust.initDataset()\` with \`{ useOutput: false }\`, which will become the default in a future version of Braintrust.`
@@ -6309,7 +7327,7 @@ var Dataset2 = class extends ObjectFetcher {
       pinnedVersion,
       (r) => (
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        (0, import_core2.ensureDatasetRecord)(
+        ensureDatasetRecord(
           enrichAttachments(r, this.state),
           isLegacyDataset
         )
@@ -6385,7 +7403,7 @@ var Dataset2 = class extends ObjectFetcher {
         //if we're merging/updating an event we will not add this ts
         metadata,
         ...!!isMerge ? {
-          [import_core2.IS_MERGE_FIELD]: true
+          [IS_MERGE_FIELD]: true
         } : {}
       };
       return args;
@@ -6494,8 +7512,8 @@ var Dataset2 = class extends ObjectFetcher {
     )}`;
     let dataSummary;
     if (summarizeData) {
-      const rawDataSummary = import_zod3.z.object({
-        total_records: import_zod3.z.number()
+      const rawDataSummary = import_zod.z.object({
+        total_records: import_zod.z.number()
       }).parse(
         await state.apiConn().get_json(
           "dataset-summary",
@@ -6541,12 +7559,12 @@ function renderMessage(render, message) {
   return {
     ...message,
     ..."content" in message ? {
-      content: isEmpty(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.map((c) => {
+      content: isEmpty2(message.content) ? void 0 : typeof message.content === "string" ? render(message.content) : message.content.map((c) => {
         switch (c.type) {
           case "text":
             return { ...c, text: render(c.text) };
           case "image_url":
-            if ((0, import_core2.isObject)(c.image_url.url)) {
+            if (isObject(c.image_url.url)) {
               throw new Error(
                 "Attachments must be replaced with URLs before calling `build()`"
               );
@@ -6565,7 +7583,7 @@ function renderMessage(render, message) {
       })
     } : {},
     ..."tool_calls" in message ? {
-      tool_calls: isEmpty(message.tool_calls) ? void 0 : message.tool_calls.map((t) => {
+      tool_calls: isEmpty2(message.tool_calls) ? void 0 : message.tool_calls.map((t) => {
         return {
           type: t.type,
           id: render(t.id),
@@ -6605,9 +7623,9 @@ function renderTemplatedObject(obj, args, options) {
         }
       }
     });
-  } else if ((0, import_core2.isArray)(obj)) {
+  } else if (isArray(obj)) {
     return obj.map((item) => renderTemplatedObject(item, args, options));
-  } else if ((0, import_core2.isObject)(obj)) {
+  } else if (isObject(obj)) {
     return Object.fromEntries(
       Object.entries(obj).map(([key, value]) => [
         key,
@@ -6618,11 +7636,11 @@ function renderTemplatedObject(obj, args, options) {
   return obj;
 }
 function renderPromptParams(params, args, options) {
-  const schemaParsed = import_zod3.z.object({
-    response_format: import_zod3.z.object({
-      type: import_zod3.z.literal("json_schema"),
+  const schemaParsed = import_zod.z.object({
+    response_format: import_zod.z.object({
+      type: import_zod.z.literal("json_schema"),
       json_schema: ResponseFormatJsonSchema.omit({ schema: true }).extend({
-        schema: import_zod3.z.unknown()
+        schema: import_zod.z.unknown()
       })
     })
   }).safeParse(params);
@@ -6668,7 +7686,7 @@ var Prompt2 = class _Prompt {
     return this.getParsedPromptData()?.prompt;
   }
   get version() {
-    return this.metadata[import_core2.TRANSACTION_ID_FIELD];
+    return this.metadata[TRANSACTION_ID_FIELD];
   }
   get options() {
     return this.getParsedPromptData()?.options || {};
@@ -6714,11 +7732,11 @@ var Prompt2 = class _Prompt {
           ([k, _v]) => !BRAINTRUST_PARAMS.includes(k)
         )
       ),
-      ...!isEmpty(this.options.model) ? {
+      ...!isEmpty2(this.options.model) ? {
         model: this.options.model
       } : {}
     };
-    if (!("model" in params) || isEmpty(params.model)) {
+    if (!("model" in params) || isEmpty2(params.model)) {
       throw new Error(
         "No model specified. Either specify it in the prompt or as a default"
       );
@@ -6740,7 +7758,7 @@ var Prompt2 = class _Prompt {
     if (!prompt) {
       throw new Error("Empty prompt");
     }
-    const dictArgParsed = import_zod3.z.record(import_zod3.z.unknown()).safeParse(buildArgs);
+    const dictArgParsed = import_zod.z.record(import_zod.z.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -6795,7 +7813,7 @@ var Prompt2 = class _Prompt {
         return JSON.stringify(v);
       }
     };
-    const dictArgParsed = import_zod3.z.record(import_zod3.z.unknown()).safeParse(buildArgs);
+    const dictArgParsed = import_zod.z.record(import_zod.z.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -6916,9 +7934,6 @@ var BarProgressReporter = class {
   }
 };
 
-// src/framework.ts
-var import_core5 = require("@braintrust/core");
-
 // ../../node_modules/.pnpm/async@3.2.5/node_modules/async/dist/async.mjs
 function initialParams(fn) {
   return function(...args) {
@@ -7961,13 +8976,12 @@ var import_chalk = __toESM(require("chalk"));
 var import_pluralize = __toESM(require("pluralize"));
 
 // src/eval-parameters.ts
-var import_zod5 = require("zod");
+var import_v38 = require("zod/v3");
 
 // src/framework2.ts
 var import_path = __toESM(require("path"));
 var import_slugify = __toESM(require("slugify"));
-var import_zod4 = require("zod");
-var import_core4 = require("@braintrust/core");
+var import_v37 = require("zod/v3");
 var ProjectBuilder = class {
   create(opts) {
     return new Project2(opts);
@@ -8201,23 +9215,23 @@ var CodePrompt = class {
     };
   }
 };
-var promptContentsSchema = import_zod4.z.union([
-  import_zod4.z.object({
-    prompt: import_zod4.z.string()
+var promptContentsSchema = import_v37.z.union([
+  import_v37.z.object({
+    prompt: import_v37.z.string()
   }),
-  import_zod4.z.object({
-    messages: import_zod4.z.array(ChatCompletionMessageParam)
+  import_v37.z.object({
+    messages: import_v37.z.array(ChatCompletionMessageParam)
   })
 ]);
 var promptDefinitionSchema = promptContentsSchema.and(
-  import_zod4.z.object({
-    model: import_zod4.z.string(),
+  import_v37.z.object({
+    model: import_v37.z.string(),
     params: ModelParams.optional()
   })
 );
 var promptDefinitionWithToolsSchema = promptDefinitionSchema.and(
-  import_zod4.z.object({
-    tools: import_zod4.z.array(ToolFunctionDefinition).optional()
+  import_v37.z.object({
+    tools: import_v37.z.array(ToolFunctionDefinition).optional()
   })
 );
 var PromptBuilder = class {
@@ -8240,7 +9254,7 @@ var PromptBuilder = class {
     const promptData = promptDefinitionToPromptData(opts, rawTools);
     const promptRow = {
       id: opts.id,
-      _xact_id: opts.version ? (0, import_core4.loadPrettyXact)(opts.version) : void 0,
+      _xact_id: opts.version ? loadPrettyXact(opts.version) : void 0,
       name: opts.name,
       slug,
       prompt_data: promptData,
@@ -8285,7 +9299,7 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/register", {
         project_name: projectName
       });
-      const result = import_zod4.z.object({
+      const result = import_v37.z.object({
         project: Project
       }).parse(response);
       const projectId = result.project.id;
@@ -8299,7 +9313,7 @@ var ProjectNameIdMap = class {
       const response = await _internalGetGlobalState().appConn().post_json("api/project/get", {
         id: projectId
       });
-      const result = import_zod4.z.array(Project).nonempty().parse(response);
+      const result = import_v37.z.array(Project).nonempty().parse(response);
       const projectName = result[0].name;
       this.idToName[projectId] = projectName;
       this.nameToId[projectName] = projectId;
@@ -8315,15 +9329,15 @@ var ProjectNameIdMap = class {
 };
 
 // src/eval-parameters.ts
-var evalParametersSchema = import_zod5.z.record(
-  import_zod5.z.string(),
-  import_zod5.z.union([
-    import_zod5.z.object({
-      type: import_zod5.z.literal("prompt"),
+var evalParametersSchema = import_v38.z.record(
+  import_v38.z.string(),
+  import_v38.z.union([
+    import_v38.z.object({
+      type: import_v38.z.literal("prompt"),
       default: promptDefinitionWithToolsSchema.optional(),
-      description: import_zod5.z.string().optional()
+      description: import_v38.z.string().optional()
     }),
-    import_zod5.z.instanceof(import_zod5.z.ZodType)
+    import_v38.z.instanceof(import_v38.z.ZodType)
     // For Zod schemas
   ])
 );
@@ -8409,7 +9423,7 @@ function _initializeSpanContext() {
   globalThis._spanContext = { currentSpan, withCurrent, startSpan, NOOP_SPAN };
 }
 async function Eval(name, evaluator, reporterOrOpts) {
-  const options = isEmpty(reporterOrOpts) ? {} : typeof reporterOrOpts === "string" ? { reporter: reporterOrOpts } : "name" in reporterOrOpts ? { reporter: reporterOrOpts } : reporterOrOpts;
+  const options = isEmpty2(reporterOrOpts) ? {} : typeof reporterOrOpts === "string" ? { reporter: reporterOrOpts } : "name" in reporterOrOpts ? { reporter: reporterOrOpts } : reporterOrOpts;
   let evalName = makeEvalName(name, evaluator.experimentName);
   if (globalThis._evals.evaluators[evalName]) {
     evalName = `${evalName}_${Object.keys(_evals).length}`;
@@ -8587,7 +9601,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       );
     }
     let name = dataResult.name;
-    if (isEmpty(name)) {
+    if (isEmpty2(name)) {
       const baseExperiment = await experiment.fetchBaseExperiment();
       if (!baseExperiment) {
         throw new Error("BaseExperiment() failed to fetch base experiment");
@@ -8629,7 +9643,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
       const baseEvent = {
         name: "eval",
         spanAttributes: {
-          type: import_core5.SpanTypeAttribute.EVAL
+          type: "eval" /* EVAL */
         },
         event: {
           input: datum.input,
@@ -8689,7 +9703,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
             },
             {
               name: "task",
-              spanAttributes: { type: import_core5.SpanTypeAttribute.TASK },
+              spanAttributes: { type: "task" /* TASK */ },
               event: { input: datum.input }
             }
           );
@@ -8715,7 +9729,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                   }
                   if (Array.isArray(scoreValue)) {
                     for (const s of scoreValue) {
-                      if (!(typeof s === "object" && !isEmpty(s))) {
+                      if (!(typeof s === "object" && !isEmpty2(s))) {
                         throw new Error(
                           `When returning an array of scores, each score must be a non-empty object. Got: ${JSON.stringify(
                             s
@@ -8724,7 +9738,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                       }
                     }
                   }
-                  const results3 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty(scoreValue) ? [scoreValue] : [
+                  const results3 = Array.isArray(scoreValue) ? scoreValue : typeof scoreValue === "object" && !isEmpty2(scoreValue) ? [scoreValue] : [
                     {
                       name: scorerNames[score_idx],
                       score: scoreValue
@@ -8735,17 +9749,17 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                     return rest;
                   };
                   const resultMetadata = results3.length === 1 ? results3[0].metadata : results3.reduce(
-                    (prev, s) => (0, import_core5.mergeDicts)(prev, {
+                    (prev, s) => mergeDicts(prev, {
                       [s.name]: s.metadata
                     }),
                     {}
                   );
                   const resultOutput = results3.length === 1 ? getOtherFields(results3[0]) : results3.reduce(
-                    (prev, s) => (0, import_core5.mergeDicts)(prev, { [s.name]: getOtherFields(s) }),
+                    (prev, s) => mergeDicts(prev, { [s.name]: getOtherFields(s) }),
                     {}
                   );
                   const scores2 = results3.reduce(
-                    (prev, s) => (0, import_core5.mergeDicts)(prev, { [s.name]: s.score }),
+                    (prev, s) => mergeDicts(prev, { [s.name]: s.score }),
                     {}
                   );
                   span.log({
@@ -8758,7 +9772,7 @@ async function runEvaluatorInternal(experiment, evaluator, progressReporter, fil
                 const results2 = await rootSpan.traced(runScorer, {
                   name: scorerNames[score_idx],
                   spanAttributes: {
-                    type: import_core5.SpanTypeAttribute.SCORE
+                    type: "score" /* SCORE */
                   },
                   event: { input: scoringArgs }
                 });
@@ -8963,7 +9977,7 @@ function formatExperimentSummary(summary) {
 ${comparisonLine}` + Object.values(summary.scores).map((score) => formatScoreSummary(score, longestScoreName)).join("\n") + (Object.keys(summary.scores).length ? "\n\n" : "") + Object.values(summary.metrics ?? {}).map((metric) => formatMetricSummary(metric, longestMetricName)).join("\n") + (Object.keys(summary.metrics ?? {}).length ? "\n\n" : "") + (summary.experimentUrl ? `See results for ${summary.experimentName} at ${summary.experimentUrl}` : "");
 }
 function formatScoreSummary(summary, longestScoreName) {
-  const diffString = isEmpty(summary.diff) ? "" : ` (${summary.diff > 0 ? "+" : ""}${(summary.diff * 100).toFixed(2)}%)`;
+  const diffString = isEmpty2(summary.diff) ? "" : ` (${summary.diff > 0 ? "+" : ""}${(summary.diff * 100).toFixed(2)}%)`;
   const scoreName = `'${summary.name}'`.padEnd(longestScoreName + 2);
   return `${(summary.score * 100).toFixed(
     2
@@ -9198,7 +10212,7 @@ function getCallerLocation() {
 }
 
 // src/node.ts
-var import_util3 = require("util");
+var import_util8 = require("util");
 var zlib = __toESM(require("zlib"));
 function configureNode() {
   isomorph_default.getRepoInfo = getRepoInfo;
@@ -9220,8 +10234,8 @@ function configureNode() {
   isomorph_default.utimes = fs.utimes;
   isomorph_default.unlink = fs.unlink;
   isomorph_default.homedir = os.homedir;
-  isomorph_default.gzip = (0, import_util3.promisify)(zlib.gzip);
-  isomorph_default.gunzip = (0, import_util3.promisify)(zlib.gunzip);
+  isomorph_default.gzip = (0, import_util8.promisify)(zlib.gzip);
+  isomorph_default.gunzip = (0, import_util8.promisify)(zlib.gunzip);
   isomorph_default.hash = (data) => crypto.createHash("sha256").update(data).digest("hex");
   _internalSetInitialState();
 }
@@ -9233,8 +10247,7 @@ var import_env2 = require("@next/env");
 var import_fs = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
 var import_zlib = require("zlib");
-var import_zod6 = require("zod");
-var import_core6 = require("@braintrust/core");
+var import_v39 = require("zod/v3");
 
 // src/functions/infer-source.ts
 var import_source_map = require("source-map");
@@ -9490,9 +10503,9 @@ async function getTsModule() {
 var import_slugify2 = __toESM(require("slugify"));
 var import_zod_to_json_schema = require("zod-to-json-schema");
 var import_pluralize2 = __toESM(require("pluralize"));
-var pathInfoSchema = import_zod6.z.strictObject({
-  url: import_zod6.z.string(),
-  bundleId: import_zod6.z.string()
+var pathInfoSchema = import_v39.z.strictObject({
+  url: import_v39.z.string(),
+  bundleId: import_v39.z.string()
 }).strip();
 async function uploadHandleBundles({
   buildResults,
@@ -9667,7 +10680,7 @@ async function uploadBundles({
       return false;
     }
   }
-  if (isEmpty(bundleFileName)) {
+  if (isEmpty2(bundleFileName)) {
     throw new Error("No bundle file found");
   }
   const bundleFile = import_path4.default.resolve(bundleFileName);
@@ -9759,7 +10772,7 @@ async function uploadBundles({
 function formatNameAndSlug(pieces) {
   const nonEmptyPieces = pieces.filter((piece) => piece.trim() !== "");
   return {
-    name: (0, import_core6.capitalize)(nonEmptyPieces.join(" ")),
+    name: capitalize(nonEmptyPieces.join(" ")),
     slug: (0, import_slugify2.default)(nonEmptyPieces.join("-"))
   };
 }
@@ -9832,12 +10845,11 @@ async function bundleCommand(args) {
 }
 
 // src/cli-util/pull.ts
-var import_zod7 = require("zod");
+var import_v310 = require("zod/v3");
 var import_promises = __toESM(require("fs/promises"));
-var import_util5 = __toESM(require("util"));
+var import_util11 = __toESM(require("util"));
 var import_slugify3 = __toESM(require("slugify"));
 var import_path5 = __toESM(require("path"));
-var import_core7 = require("@braintrust/core");
 var import_pluralize3 = __toESM(require("pluralize"));
 async function pullCommand(args) {
   await loadCLIEnv(args);
@@ -9847,9 +10859,9 @@ async function pullCommand(args) {
     ...args.project_name ? { project_name: args.project_name } : {},
     ...args.slug ? { slug: args.slug } : {},
     ...args.id ? { ids: [args.id] } : {},
-    ...args.version ? { version: (0, import_core7.loadPrettyXact)(args.version) } : {}
+    ...args.version ? { version: loadPrettyXact(args.version) } : {}
   });
-  const functionObjects = import_zod7.z.object({ objects: import_zod7.z.array(import_zod7.z.unknown()) }).parse(functions);
+  const functionObjects = import_v310.z.object({ objects: import_v310.z.array(import_v310.z.unknown()) }).parse(functions);
   const projectNameToFunctions = {};
   const projectNameIdMap = new ProjectNameIdMap();
   for (const rawFunc of functionObjects.objects) {
@@ -10012,7 +11024,7 @@ function makeFunctionDefinition({
   const objectType = "prompt";
   const prompt = func.prompt_data.prompt;
   const promptContents = prompt.type === "completion" ? `prompt: ${doubleQuote(prompt.content)}` : `messages: ${safeStringify(prompt.messages).trimStart()}`;
-  const rawToolsParsed = prompt.type === "chat" && prompt.tools && prompt.tools.length > 0 ? import_zod7.z.array(ToolFunctionDefinition).safeParse(JSON.parse(prompt.tools)) : void 0;
+  const rawToolsParsed = prompt.type === "chat" && prompt.tools && prompt.tools.length > 0 ? import_v310.z.array(ToolFunctionDefinition).safeParse(JSON.parse(prompt.tools)) : void 0;
   if (rawToolsParsed && !rawToolsParsed.success) {
     console.warn(
       warning(
@@ -10033,7 +11045,7 @@ function makeFunctionDefinition({
   id: ${doubleQuote(func.id)},
   name: ${doubleQuote(func.name)},
   slug: ${doubleQuote(func.slug)},
-  version: ${doubleQuote((0, import_core7.prettifyXact)(func._xact_id))}, ${printOptionalField("description", func.description)}${printOptionalField("model", model)}
+  version: ${doubleQuote(prettifyXact(func._xact_id))}, ${printOptionalField("description", func.description)}${printOptionalField("model", model)}
 ${indent(promptContents, 2)},
 ${indent(paramsString, 2)}
 ${indent(toolsString, 2)}
@@ -10053,7 +11065,7 @@ function indent(str, numSpaces) {
   return str.replace(/^/gm, " ".repeat(numSpaces));
 }
 function printOptionalField(fieldName, fieldValue) {
-  return !(0, import_core7.isEmpty)(fieldValue) ? `
+  return !isEmpty(fieldValue) ? `
   ${fieldName}: ${doubleQuote(fieldValue)},` : "";
 }
 var prettierImportAttempted = false;
@@ -10107,7 +11119,7 @@ function safeStringify(obj) {
     return JSON.stringify(obj, null, 2);
   } catch (error2) {
     try {
-      return import_util5.default.inspect(obj, {
+      return import_util11.default.inspect(obj, {
         depth: 5,
         maxStringLength: 1e3,
         breakLength: 80,
@@ -10124,7 +11136,7 @@ var import_express = __toESM(require("express"));
 var import_cors = __toESM(require("cors"));
 
 // dev/errorHandler.ts
-var import_zod8 = require("zod");
+var import_v311 = require("zod/v3");
 var errorHandler = (err, req, res, next) => {
   if ("status" in err) {
     res.status(err.status).json({
@@ -10135,7 +11147,7 @@ var errorHandler = (err, req, res, next) => {
     });
     return;
   }
-  if (err instanceof import_zod8.z.ZodError) {
+  if (err instanceof import_v311.z.ZodError) {
     res.status(400).json({
       error: {
         message: "Invalid request",
@@ -10159,7 +11171,8 @@ function authorizeRequest(req, res, next) {
   try {
     const ctx = {
       appOrigin: extractAllowedOrigin(req.headers[ORIGIN_HEADER]),
-      token: void 0
+      token: void 0,
+      state: void 0
     };
     if (req.headers.authorization || req.headers[BRAINTRUST_AUTH_TOKEN_HEADER]) {
       const tokenText = parseBraintrustAuthHeader(req.headers);
@@ -10174,11 +11187,37 @@ function authorizeRequest(req, res, next) {
     next(e);
   }
 }
-function checkAuthorized(req, res, next) {
-  if (!req.ctx?.token) {
-    return next((0, import_http_errors.default)(401, "Unauthorized"));
+var loginCache = new LRUCache({
+  max: 32
+  // TODO: Make this configurable
+});
+async function cachedLogin(options) {
+  const key = JSON.stringify(options);
+  const cached = loginCache.get(key);
+  if (cached) {
+    return cached;
   }
-  next();
+  const state = await loginToState(options);
+  loginCache.set(key, state);
+  return state;
+}
+function makeCheckAuthorized(allowedOrgName) {
+  return async (req, _res, next) => {
+    if (!req.ctx?.token) {
+      return next((0, import_http_errors.default)(401, "Unauthorized"));
+    }
+    try {
+      const state = await cachedLogin({
+        apiKey: req.ctx?.token,
+        orgName: allowedOrgName
+      });
+      req.ctx.state = state;
+      next();
+    } catch (e) {
+      console.error("Authorization error:", e);
+      return next((0, import_http_errors.default)(401, "Unauthorized"));
+    }
+  };
 }
 function parseBraintrustAuthHeader(headers) {
   const tokenString = parseHeader(headers, BRAINTRUST_AUTH_TOKEN_HEADER);
@@ -10263,58 +11302,55 @@ var baseAllowedHeaders = [
   "x-stainless-arch"
 ];
 
-// dev/server.ts
-var import_core8 = require("@braintrust/core");
-
 // dev/stream.ts
 function serializeSSEEvent(event) {
   return Object.entries(event).filter(([_key, value]) => value !== void 0).map(([key, value]) => `${key}: ${value}`).join("\n") + "\n\n";
 }
 
 // dev/types.ts
-var import_zod9 = require("zod");
-var evalBodySchema = import_zod9.z.object({
-  name: import_zod9.z.string(),
-  parameters: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).nullish(),
+var import_v312 = require("zod/v3");
+var evalBodySchema = import_v312.z.object({
+  name: import_v312.z.string(),
+  parameters: import_v312.z.record(import_v312.z.string(), import_v312.z.unknown()).nullish(),
   data: RunEval.shape.data,
-  scores: import_zod9.z.array(
-    import_zod9.z.object({
+  scores: import_v312.z.array(
+    import_v312.z.object({
       function_id: FunctionId,
-      name: import_zod9.z.string()
+      name: import_v312.z.string()
     })
   ).nullish(),
-  experiment_name: import_zod9.z.string().nullish(),
-  project_id: import_zod9.z.string().nullish(),
+  experiment_name: import_v312.z.string().nullish(),
+  project_id: import_v312.z.string().nullish(),
   parent: InvokeParent.optional(),
-  stream: import_zod9.z.boolean().optional()
+  stream: import_v312.z.boolean().optional()
 });
-var evalParametersSerializedSchema = import_zod9.z.record(
-  import_zod9.z.string(),
-  import_zod9.z.union([
-    import_zod9.z.object({
-      type: import_zod9.z.literal("prompt"),
+var evalParametersSerializedSchema = import_v312.z.record(
+  import_v312.z.string(),
+  import_v312.z.union([
+    import_v312.z.object({
+      type: import_v312.z.literal("prompt"),
       default: PromptData.optional(),
-      description: import_zod9.z.string().optional()
+      description: import_v312.z.string().optional()
     }),
-    import_zod9.z.object({
-      type: import_zod9.z.literal("data"),
-      schema: import_zod9.z.record(import_zod9.z.unknown()),
+    import_v312.z.object({
+      type: import_v312.z.literal("data"),
+      schema: import_v312.z.record(import_v312.z.unknown()),
       // JSON Schema
-      default: import_zod9.z.unknown().optional(),
-      description: import_zod9.z.string().optional()
+      default: import_v312.z.unknown().optional(),
+      description: import_v312.z.string().optional()
     })
   ])
 );
-var evaluatorDefinitionSchema = import_zod9.z.object({
+var evaluatorDefinitionSchema = import_v312.z.object({
   parameters: evalParametersSerializedSchema.optional()
 });
-var evaluatorDefinitionsSchema = import_zod9.z.record(
-  import_zod9.z.string(),
+var evaluatorDefinitionsSchema = import_v312.z.record(
+  import_v312.z.string(),
   evaluatorDefinitionSchema
 );
 
 // dev/server.ts
-var import_zod10 = require("zod");
+var import_v313 = require("zod/v3");
 var import_zod_to_json_schema2 = __toESM(require("zod-to-json-schema"));
 function runDevServer(evaluators, opts) {
   const allEvaluators = Object.fromEntries(
@@ -10330,6 +11366,7 @@ function runDevServer(evaluators, opts) {
     }
     next();
   });
+  const checkAuthorized = makeCheckAuthorized(opts.orgName);
   app.use(
     (0, import_cors.default)({
       origin: checkOrigin,
@@ -10337,8 +11374,8 @@ function runDevServer(evaluators, opts) {
       allowedHeaders: baseAllowedHeaders,
       credentials: true,
       exposedHeaders: [
-        import_core8.BT_CURSOR_HEADER,
-        import_core8.BT_FOUND_EXISTING_HEADER,
+        BT_CURSOR_HEADER,
+        BT_FOUND_EXISTING_HEADER,
         "x-bt-span-id",
         "x-bt-span-export"
       ],
@@ -10349,7 +11386,7 @@ function runDevServer(evaluators, opts) {
   app.get("/", (req, res) => {
     res.send("Hello, world!");
   });
-  app.get("/list", (req, res) => {
+  app.get("/list", checkAuthorized, (req, res) => {
     const evalDefs = Object.fromEntries(
       Object.entries(allEvaluators).map(([name, evaluator]) => [
         name,
@@ -10377,7 +11414,11 @@ function runDevServer(evaluators, opts) {
         scores,
         stream
       } = evalBodySchema.parse(req.body);
-      const state = await cachedLogin({ apiKey: req.ctx?.token });
+      if (!req.ctx?.state) {
+        res.status(500).json({ error: "Braintrust state not initialized in request" });
+        return;
+      }
+      const state = req.ctx.state;
       const evaluator = allEvaluators[name];
       if (!evaluator) {
         res.status(404).json({ error: `Evaluator '${name}' not found` });
@@ -10394,7 +11435,7 @@ function runDevServer(evaluators, opts) {
           validateParameters(parameters ?? {}, evaluator.parameters);
         } catch (e) {
           console.error("Error validating parameters", e);
-          if (e instanceof import_zod10.z.ZodError || e instanceof Error) {
+          if (e instanceof import_v313.z.ZodError || e instanceof Error) {
             res.status(400).json({
               error: e.message
             });
@@ -10470,7 +11511,7 @@ function runDevServer(evaluators, opts) {
                 );
               }
             },
-            parent: (0, import_core8.parseParent)(parent),
+            parent: parseParent(parent),
             parameters: parameters ?? {}
           }
         );
@@ -10515,20 +11556,6 @@ function runDevServer(evaluators, opts) {
 var asyncHandler = (fn) => (req, res, next) => {
   Promise.resolve(fn(req, res, next)).catch(next);
 };
-var loginCache = new LRUCache({
-  max: 32
-  // TODO: Make this configurable
-});
-async function cachedLogin(options) {
-  const key = JSON.stringify(options);
-  const cached = loginCache.get(key);
-  if (cached) {
-    return cached;
-  }
-  const state = await loginToState(options);
-  loginCache.set(key, state);
-  return state;
-}
 async function getDataset(state, data) {
   if ("project_name" in data) {
     return initDataset({
@@ -10552,9 +11579,9 @@ async function getDataset(state, data) {
     return data.data;
   }
 }
-var datasetFetchSchema = import_zod10.z.object({
-  project_id: import_zod10.z.string(),
-  name: import_zod10.z.string()
+var datasetFetchSchema = import_v313.z.object({
+  project_id: import_v313.z.string(),
+  name: import_v313.z.string()
 });
 async function getDatasetById({
   state,
@@ -10563,7 +11590,7 @@ async function getDatasetById({
   const dataset = await state.appConn().post_json("api/dataset/get", {
     id: datasetId
   });
-  const parsed = import_zod10.z.array(datasetFetchSchema).parse(dataset);
+  const parsed = import_v313.z.array(datasetFetchSchema).parse(dataset);
   if (parsed.length === 0) {
     throw new Error(`Dataset '${datasetId}' not found`);
   }
@@ -10700,7 +11727,7 @@ function resolveReporter(reporter, reporters) {
       throw new Error(`Reporter ${reporter} not found`);
     }
     return reporters[reporter];
-  } else if (!isEmpty(reporter)) {
+  } else if (!isEmpty2(reporter)) {
     return reporter;
   } else if (Object.keys(reporters).length === 0) {
     return defaultReporter;
@@ -11087,7 +12114,7 @@ async function collectFiles(inputPath, mode) {
     }
     files.push(inputPath);
   } else {
-    const walked = await import_util6.default.promisify(fsWalk.walk)(inputPath, {
+    const walked = await import_util14.default.promisify(fsWalk.walk)(inputPath, {
       deepFilter: (entry) => {
         return checkMatch(entry.path, null, EXCLUDE);
       },
@@ -11280,7 +12307,8 @@ async function run(args) {
     );
     runDevServer(allEvaluators, {
       host: args.dev_host,
-      port: args.dev_port
+      port: args.dev_port,
+      orgName: args.dev_org_name
     });
     return;
   }
@@ -11396,7 +12424,7 @@ async function main() {
   });
   parser_run.add_argument("--dev", {
     action: "store_true",
-    help: "Run the evaluators in dev mode. This will start a dev server which you can connect to via the playground."
+    help: "Run the evaluators in dev mode. This will start a dev server which you can connect to via the playground's remote evals feature."
   });
   parser_run.add_argument("--dev-host", {
     help: "The host to bind the dev server to. Defaults to localhost. Set to 0.0.0.0 to bind to all interfaces.",
@@ -11408,6 +12436,10 @@ async function main() {
     type: Number,
     default: 8300
   });
+  parser_run.add_argument("--dev-org-name", {
+    help: "Only allow users that belong this to this org name to run remote evals.",
+    type: String
+  });
   parser_run.set_defaults({ func: run });
   const parser_push = subparser.add_parser("push", {
     help: "Bundle prompts, tools, scorers, and other resources into Braintrust"