From 3fd258efc5e7a457a7e240c5fc9ac6897d2016c4 Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Wed, 22 Apr 2026 17:30:43 -0700
Subject: [PATCH 1/8] forward props

---
 js/src/logger.test.ts | 104 ++++++++++++++++++++++++++++++++++++++++++
 js/src/logger.ts      |  31 +++++++++++++
 2 files changed, 135 insertions(+)

diff --git a/js/src/logger.test.ts b/js/src/logger.test.ts
index fc4f14f7b..caf3f7dc7 100644
--- a/js/src/logger.test.ts
+++ b/js/src/logger.test.ts
@@ -4,6 +4,7 @@ import { vi, expect, test, describe, beforeEach, afterEach } from "vitest";
 import {
   _exportsForTestingOnly,
   init,
+  initDataset,
   initLogger,
   Prompt,
   BraintrustState,
@@ -453,6 +454,109 @@ test("init accepts dataset with id and version", () => {
   expect(datasetWithVersion.version).toBe("v2");
 });
 
+test("init forwards dataset _internal_btql to experiment register", async () => {
+  const datasetFilter = {
+    filter: {
+      btql: "expected IS NOT NULL",
+    },
+  };
+
+  let experimentRegisterBody: unknown;
+  const state = BraintrustState.deserialize(
+    {
+      appUrl: "https://example.com",
+      appPublicUrl: "https://example.com",
+      loginToken: "test-token",
+      orgId: "11111111-1111-4111-8111-111111111111",
+      orgName: "test-org",
+      apiUrl: "https://example.com",
+      proxyUrl: "https://example.com",
+    },
+    {
+      fetch: vi.fn(async (input, init) => {
+        const url = typeof input === "string" ? input : input.toString();
+        if (url.endsWith("/api/dataset/register")) {
+          return new Response(
+            JSON.stringify({
+              project: {
+                id: "11111111-1111-4111-8111-111111111111",
+                name: "test-project",
+              },
+              dataset: {
+                id: "22222222-2222-4222-8222-222222222222",
+                name: "test-dataset",
+              },
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        if (url.endsWith("/api/experiment/register")) {
+          experimentRegisterBody =
+            typeof init?.body === "string" ? JSON.parse(init.body) : undefined;
+
+          return new Response(
+            JSON.stringify({
+              project: {
+                id: "11111111-1111-4111-8111-111111111111",
+                name: "test-project",
+              },
+              experiment: {
+                id: "33333333-3333-4333-8333-333333333333",
+                name: "test-experiment",
+                created: "2026-01-01T00:00:00.000Z",
+              },
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        if (url.endsWith("/btql")) {
+          return new Response(
+            JSON.stringify({
+              data: [
+                {
+                  _xact_id: "v1",
+                },
+              ],
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        throw new Error(`Unexpected url: ${url}`);
+      }),
+    },
+  );
+
+  _exportsForTestingOnly.useTestBackgroundLogger();
+
+  const dataset = initDataset({
+    project: "test-project",
+    dataset: "test-dataset",
+    state,
+    _internal_btql: datasetFilter,
+  });
+  const experiment = init({
+    project: "test-project",
+    experiment: "test-experiment",
+    dataset,
+    state,
+  });
+
+  await experiment.id;
+
+  expect(experimentRegisterBody).toEqual(
+    expect.objectContaining({
+      internal_metadata: {
+        dataset_filter: datasetFilter,
+      },
+    }),
+  );
+
+  _exportsForTestingOnly.clearTestBackgroundLogger();
+});
+
 describe("loader version precedence", () => {
   let state: BraintrustState;
   let getJson: ReturnType<typeof vi.spyOn>;
diff --git a/js/src/logger.ts b/js/src/logger.ts
index c90eb403c..221d28c14 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3406,6 +3406,7 @@ export type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
   experiment?: string;
   description?: string;
   dataset?: AnyDataset | DatasetRef;
+  _internal_btql?: Record<string, unknown>;
   parameters?: ParametersRef | RemoteEvalParameters<boolean, boolean>;
   update?: boolean;
   baseExperiment?: string;
@@ -3424,6 +3425,25 @@ export type FullInitOptions<IsOpen extends boolean> = {
   project?: string;
 } & InitOptions<IsOpen>;
 
+function getExperimentDatasetFilter({
+  dataset,
+  _internal_btql,
+}: {
+  dataset?: AnyDataset | DatasetRef;
+  _internal_btql?: Record<string, unknown>;
+}): Record<string, unknown> | undefined {
+  if (_internal_btql !== undefined) {
+    return _internal_btql;
+  }
+
+  if (!(dataset instanceof Dataset)) {
+    return undefined;
+  }
+
+  const datasetFilter = Reflect.get(dataset, "_internal_btql");
+  return isObject(datasetFilter) ? datasetFilter : undefined;
+}
+
 type InitializedExperiment<IsOpen extends boolean | undefined> =
   IsOpen extends true ? ReadonlyExperiment : Experiment;
 
@@ -3490,6 +3510,7 @@ export function init<IsOpen extends boolean = false>(
     experiment,
     description,
     dataset,
+    _internal_btql,
     parameters,
     baseExperiment,
     isPublic,
@@ -3638,6 +3659,16 @@ export function init<IsOpen extends boolean = false>(
         }
       }
 
+      const datasetFilter = getExperimentDatasetFilter({
+        dataset,
+        _internal_btql,
+      });
+      if (datasetFilter !== undefined) {
+        args["internal_metadata"] = {
+          dataset_filter: datasetFilter,
+        };
+      }
+
       if (parameters !== undefined) {
         if (RemoteEvalParameters.isParameters(parameters)) {
           args["parameters_id"] = parameters.id;

From ea50fc2e3793e54b941fa352828c21a62e01192e Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Wed, 22 Apr 2026 18:03:17 -0700
Subject: [PATCH 2/8] add changeset

---
 .changeset/yellow-crabs-attend.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 .changeset/yellow-crabs-attend.md

diff --git a/.changeset/yellow-crabs-attend.md b/.changeset/yellow-crabs-attend.md
new file mode 100644
index 000000000..c36539820
--- /dev/null
+++ b/.changeset/yellow-crabs-attend.md
@@ -0,0 +1,5 @@
+---
+"braintrust": minor
+---
+
+(feat) Add experiment dataset filters to experiment metadata

From a895a809cca5c3e60adc37b7ea2050a0b7b493fa Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Thu, 23 Apr 2026 11:55:53 -0700
Subject: [PATCH 3/8] normalize filters

---
 js/src/logger.test.ts | 121 ++++++++++++++++++++++++++++++++++++++++--
 js/src/logger.ts      |  87 ++++++++++++++++++++++++++----
 2 files changed, 195 insertions(+), 13 deletions(-)

diff --git a/js/src/logger.test.ts b/js/src/logger.test.ts
index caf3f7dc7..43a17f530 100644
--- a/js/src/logger.test.ts
+++ b/js/src/logger.test.ts
@@ -456,9 +456,15 @@ test("init accepts dataset with id and version", () => {
 
 test("init forwards dataset _internal_btql to experiment register", async () => {
   const datasetFilter = {
-    filter: {
-      btql: "expected IS NOT NULL",
-    },
+    filters: [
+      {
+        op: "isnotnull",
+        expr: {
+          op: "ident",
+          name: ["expected"],
+        },
+      },
+    ],
   };
 
   let experimentRegisterBody: unknown;
@@ -557,6 +563,115 @@ test("init forwards dataset _internal_btql to experiment register", async () =>
   _exportsForTestingOnly.clearTestBackgroundLogger();
 });
 
+test("dataset fetch normalizes _internal_btql filters before querying btql", async () => {
+  const datasetFilter = {
+    filters: [
+      {
+        op: "isnotnull",
+        expr: {
+          op: "ident",
+          name: ["expected"],
+        },
+      },
+      {
+        op: "eq",
+        left: {
+          op: "ident",
+          name: ["metadata", "model"],
+        },
+        right: {
+          op: "literal",
+          value: "gpt-5-mini",
+        },
+      },
+    ],
+    limit: 5,
+  };
+
+  let btqlBody: unknown;
+  const state = BraintrustState.deserialize(
+    {
+      appUrl: "https://example.com",
+      appPublicUrl: "https://example.com",
+      loginToken: "test-token",
+      orgId: "11111111-1111-4111-8111-111111111111",
+      orgName: "test-org",
+      apiUrl: "https://example.com",
+      proxyUrl: "https://example.com",
+    },
+    {
+      fetch: vi.fn(async (input, init) => {
+        const url = typeof input === "string" ? input : input.toString();
+        if (url.endsWith("/api/dataset/register")) {
+          return new Response(
+            JSON.stringify({
+              project: {
+                id: "11111111-1111-4111-8111-111111111111",
+                name: "test-project",
+              },
+              dataset: {
+                id: "22222222-2222-4222-8222-222222222222",
+                name: "test-dataset",
+              },
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        if (url.endsWith("/btql")) {
+          btqlBody =
+            typeof init?.body === "string" ? JSON.parse(init.body) : undefined;
+
+          return new Response(
+            JSON.stringify({
+              data: [],
+            }),
+            { status: 200, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        throw new Error(`Unexpected url: ${url}`);
+      }),
+    },
+  );
+
+  _exportsForTestingOnly.useTestBackgroundLogger();
+
+  const dataset = initDataset({
+    project: "test-project",
+    dataset: "test-dataset",
+    state,
+    _internal_btql: datasetFilter,
+  });
+
+  const rows: unknown[] = [];
+  for await (const row of dataset) {
+    rows.push(row);
+  }
+
+  expect(rows).toEqual([]);
+  expect(btqlBody).toEqual(
+    expect.objectContaining({
+      query: expect.objectContaining({
+        limit: 5,
+        filter: {
+          op: "and",
+          children: datasetFilter.filters,
+        },
+      }),
+    }),
+  );
+  expect(btqlBody).not.toEqual(
+    expect.objectContaining({
+      query: expect.objectContaining({
+        filters: expect.anything(),
+      }),
+    }),
+  );
+
+  _exportsForTestingOnly.clearTestBackgroundLogger();
+});
+
 describe("loader version precedence", () => {
   let state: BraintrustState;
   let getJson: ReturnType<typeof vi.spyOn>;
diff --git a/js/src/logger.ts b/js/src/logger.ts
index 221d28c14..737ace083 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3402,11 +3402,23 @@ export interface ParametersRef {
   version?: string;
 }
 
+/**
+ * Internal BTQL payload used to subset dataset-backed evals.
+ *
+ * The standard BTQL shape uses `filter`. A `filters` array may also be
+ * provided to preserve separate clause boundaries; the SDK will normalize it
+ * into `filter` before resolving the dataset query.
+ */
+export type InternalBtqlQuery = Record<string, unknown> & {
+  filter?: Record<string, unknown>;
+  filters?: Record<string, unknown>[];
+};
+
 export type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
   experiment?: string;
   description?: string;
   dataset?: AnyDataset | DatasetRef;
-  _internal_btql?: Record<string, unknown>;
+  _internal_btql?: InternalBtqlQuery;
   parameters?: ParametersRef | RemoteEvalParameters<boolean, boolean>;
   update?: boolean;
   baseExperiment?: string;
@@ -3430,8 +3442,8 @@ function getExperimentDatasetFilter({
   _internal_btql,
 }: {
   dataset?: AnyDataset | DatasetRef;
-  _internal_btql?: Record<string, unknown>;
-}): Record<string, unknown> | undefined {
+  _internal_btql?: InternalBtqlQuery;
+}): InternalBtqlQuery | undefined {
   if (_internal_btql !== undefined) {
     return _internal_btql;
   }
@@ -3444,6 +3456,62 @@ function getExperimentDatasetFilter({
   return isObject(datasetFilter) ? datasetFilter : undefined;
 }
 
+function isInternalBtqlFilterClause(
+  value: unknown,
+): value is NonNullable<InternalBtqlQuery["filters"]>[number] {
+  return isObject(value) && typeof value["op"] === "string";
+}
+
+function normalizeInternalBtql(
+  internalBtql?: InternalBtqlQuery,
+): InternalBtqlQuery | undefined {
+  if (internalBtql === undefined) {
+    return undefined;
+  }
+
+  const filters = internalBtql["filters"];
+  if (filters === undefined) {
+    return internalBtql;
+  }
+
+  const normalizedInternalBtql = Object.fromEntries(
+    Object.entries(internalBtql).filter(([key]) => key !== "filters"),
+  );
+  if ("filter" in normalizedInternalBtql) {
+    return normalizedInternalBtql;
+  }
+
+  if (!Array.isArray(filters) || !filters.every(isInternalBtqlFilterClause)) {
+    return internalBtql;
+  }
+
+  if (filters.length === 1) {
+    return {
+      ...normalizedInternalBtql,
+      filter: filters[0],
+    };
+  }
+
+  if (filters.length > 1) {
+    return {
+      ...normalizedInternalBtql,
+      filter: {
+        op: "and",
+        children: filters,
+      },
+    };
+  }
+
+  return normalizedInternalBtql;
+}
+
+function getInternalBtqlLimit(
+  internalBtql?: InternalBtqlQuery,
+): number | undefined {
+  const limit = internalBtql?.["limit"];
+  return typeof limit === "number" ? limit : undefined;
+}
+
 type InitializedExperiment<IsOpen extends boolean | undefined> =
   IsOpen extends true ? ReadonlyExperiment : Experiment;
 
@@ -3829,7 +3897,7 @@ export type InitDatasetOptions<IsLegacyDataset extends boolean> =
     projectId?: string;
     metadata?: Record<string, unknown>;
     state?: BraintrustState;
-    _internal_btql?: Record<string, unknown>;
+    _internal_btql?: InternalBtqlQuery;
   } & UseOutputOption<IsLegacyDataset>;
 
 export type FullInitDatasetOptions<IsLegacyDataset extends boolean> = {
@@ -5726,7 +5794,7 @@ export class ObjectFetcher<RecordType> implements AsyncIterable<
     private pinnedVersion: string | undefined,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     private mutateRecord?: (r: any) => WithTransactionId<RecordType>,
-    private _internal_btql?: Record<string, unknown>,
+    private _internal_btql?: InternalBtqlQuery,
   ) {}
 
   public get id(): Promise<string> {
@@ -5743,13 +5811,12 @@ export class ObjectFetcher<RecordType> implements AsyncIterable<
     const state = await this.getState();
     const objectId = await this.id;
     const batchLimit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
-    const internalLimit = (
-      this._internal_btql as { limit?: number } | undefined
-    )?.limit;
+    const normalizedInternalBtql = normalizeInternalBtql(this._internal_btql);
+    const internalLimit = getInternalBtqlLimit(normalizedInternalBtql);
     const limit =
       batchSize !== undefined ? batchSize : (internalLimit ?? batchLimit);
     const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
-      Object.entries(this._internal_btql ?? {}).filter(
+      Object.entries(normalizedInternalBtql ?? {}).filter(
         ([key]) =>
           key !== "cursor" &&
           key !== "limit" &&
@@ -6877,7 +6944,7 @@ export class Dataset<
     lazyMetadata: LazyValue<ProjectDatasetMetadata>,
     pinnedVersion?: string,
     legacy?: IsLegacyDataset,
-    _internal_btql?: Record<string, unknown>,
+    _internal_btql?: InternalBtqlQuery,
   ) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const isLegacyDataset = (legacy ??

From 5c4692b353d6c0976b7edcf450fcb5dca37f291f Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Thu, 23 Apr 2026 12:53:50 -0700
Subject: [PATCH 4/8] fix type

---
 js/src/logger.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/js/src/logger.ts b/js/src/logger.ts
index 737ace083..d3b952bda 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3409,10 +3409,7 @@ export interface ParametersRef {
  * provided to preserve separate clause boundaries; the SDK will normalize it
  * into `filter` before resolving the dataset query.
  */
-export type InternalBtqlQuery = Record<string, unknown> & {
-  filter?: Record<string, unknown>;
-  filters?: Record<string, unknown>[];
-};
+export type InternalBtqlQuery = Record<string, unknown>;
 
 export type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
   experiment?: string;

From 72fbbf3024c5aedd492f6c18c8ee9a3f70d54ff8 Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Thu, 23 Apr 2026 12:58:26 -0700
Subject: [PATCH 5/8] better internal type

---
 js/src/logger.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/js/src/logger.ts b/js/src/logger.ts
index d3b952bda..069d2785a 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3410,6 +3410,7 @@ export interface ParametersRef {
  * into `filter` before resolving the dataset query.
  */
 export type InternalBtqlQuery = Record<string, unknown>;
+type InternalBtqlFilterClause = Record<string, unknown> & { op: string };
 
 export type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
   experiment?: string;
@@ -3455,7 +3456,7 @@ function getExperimentDatasetFilter({
 
 function isInternalBtqlFilterClause(
   value: unknown,
-): value is NonNullable<InternalBtqlQuery["filters"]>[number] {
+): value is InternalBtqlFilterClause {
   return isObject(value) && typeof value["op"] === "string";
 }
 

From 76bafa79ac279b87c6bc330860ad91bb45e3aa50 Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Thu, 23 Apr 2026 13:19:17 -0700
Subject: [PATCH 6/8] cleanup normalization

---
 js/src/logger.test.ts | 15 ++++---------
 js/src/logger.ts      | 49 ++++++++++++++++++-------------------------
 2 files changed, 24 insertions(+), 40 deletions(-)

diff --git a/js/src/logger.test.ts b/js/src/logger.test.ts
index 43a17f530..af0e557a5 100644
--- a/js/src/logger.test.ts
+++ b/js/src/logger.test.ts
@@ -456,7 +456,7 @@ test("init accepts dataset with id and version", () => {
 
 test("init forwards dataset _internal_btql to experiment register", async () => {
   const datasetFilter = {
-    filters: [
+    filter: [
       {
         op: "isnotnull",
         expr: {
@@ -563,9 +563,9 @@ test("init forwards dataset _internal_btql to experiment register", async () =>
   _exportsForTestingOnly.clearTestBackgroundLogger();
 });
 
-test("dataset fetch normalizes _internal_btql filters before querying btql", async () => {
+test("dataset fetch normalizes _internal_btql filter arrays before querying btql", async () => {
   const datasetFilter = {
-    filters: [
+    filter: [
       {
         op: "isnotnull",
         expr: {
@@ -656,18 +656,11 @@ test("dataset fetch normalizes _internal_btql filters before querying btql", asy
         limit: 5,
         filter: {
           op: "and",
-          children: datasetFilter.filters,
+          children: datasetFilter.filter,
         },
       }),
     }),
   );
-  expect(btqlBody).not.toEqual(
-    expect.objectContaining({
-      query: expect.objectContaining({
-        filters: expect.anything(),
-      }),
-    }),
-  );
 
   _exportsForTestingOnly.clearTestBackgroundLogger();
 });
diff --git a/js/src/logger.ts b/js/src/logger.ts
index 069d2785a..54dcdaf52 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3405,9 +3405,10 @@ export interface ParametersRef {
 /**
  * Internal BTQL payload used to subset dataset-backed evals.
  *
- * The standard BTQL shape uses `filter`. A `filters` array may also be
- * provided to preserve separate clause boundaries; the SDK will normalize it
- * into `filter` before resolving the dataset query.
+ * The standard BTQL shape uses `filter`. To preserve separate clause
+ * boundaries, `filter` may also be provided as an array; the SDK will
+ * normalize that array into a single `filter` expression before resolving the
+ * dataset query.
  */
 export type InternalBtqlQuery = Record<string, unknown>;
 type InternalBtqlFilterClause = Record<string, unknown> & { op: string };
@@ -3467,40 +3468,30 @@ function normalizeInternalBtql(
     return undefined;
   }
 
-  const filters = internalBtql["filters"];
-  if (filters === undefined) {
+  const filter = internalBtql["filter"];
+  if (!Array.isArray(filter)) {
     return internalBtql;
   }
 
-  const normalizedInternalBtql = Object.fromEntries(
-    Object.entries(internalBtql).filter(([key]) => key !== "filters"),
-  );
-  if ("filter" in normalizedInternalBtql) {
-    return normalizedInternalBtql;
-  }
-
-  if (!Array.isArray(filters) || !filters.every(isInternalBtqlFilterClause)) {
+  if (!filter.every(isInternalBtqlFilterClause)) {
     return internalBtql;
   }
 
-  if (filters.length === 1) {
-    return {
-      ...normalizedInternalBtql,
-      filter: filters[0],
-    };
-  }
-
-  if (filters.length > 1) {
-    return {
-      ...normalizedInternalBtql,
-      filter: {
-        op: "and",
-        children: filters,
-      },
-    };
+  if (filter.length === 0) {
+    const { filter: _filter, ...normalizedInternalBtql } = internalBtql;
+    return normalizedInternalBtql;
   }
 
-  return normalizedInternalBtql;
+  return {
+    ...internalBtql,
+    filter:
+      filter.length === 1
+        ? filter[0]
+        : {
+            op: "and",
+            children: filter,
+          },
+  };
 }
 
 function getInternalBtqlLimit(

From 08be1b29ac9d8c22510339635ce6f96e073af17d Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Thu, 23 Apr 2026 15:07:03 -0700
Subject: [PATCH 7/8] actually dont normalize in sdk

---
 js/src/logger.test.ts |  7 ++-----
 js/src/logger.ts      | 47 +++----------------------------------------
 2 files changed, 5 insertions(+), 49 deletions(-)

diff --git a/js/src/logger.test.ts b/js/src/logger.test.ts
index af0e557a5..be8ea6930 100644
--- a/js/src/logger.test.ts
+++ b/js/src/logger.test.ts
@@ -563,7 +563,7 @@ test("init forwards dataset _internal_btql to experiment register", async () =>
   _exportsForTestingOnly.clearTestBackgroundLogger();
 });
 
-test("dataset fetch normalizes _internal_btql filter arrays before querying btql", async () => {
+test("dataset fetch forwards _internal_btql filter arrays to btql", async () => {
   const datasetFilter = {
     filter: [
       {
@@ -654,10 +654,7 @@ test("dataset fetch normalizes _internal_btql filter arrays before querying btql
     expect.objectContaining({
       query: expect.objectContaining({
         limit: 5,
-        filter: {
-          op: "and",
-          children: datasetFilter.filter,
-        },
+        filter: datasetFilter.filter,
       }),
     }),
   );
diff --git a/js/src/logger.ts b/js/src/logger.ts
index 54dcdaf52..030984808 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3406,12 +3406,11 @@ export interface ParametersRef {
  * Internal BTQL payload used to subset dataset-backed evals.
  *
  * The standard BTQL shape uses `filter`. To preserve separate clause
- * boundaries, `filter` may also be provided as an array; the SDK will
+ * boundaries, `filter` may also be provided as an array. The BTQL API will
  * normalize that array into a single `filter` expression before resolving the
  * dataset query.
  */
 export type InternalBtqlQuery = Record<string, unknown>;
-type InternalBtqlFilterClause = Record<string, unknown> & { op: string };
 
 export type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
   experiment?: string;
@@ -3455,45 +3454,6 @@ function getExperimentDatasetFilter({
   return isObject(datasetFilter) ? datasetFilter : undefined;
 }
 
-function isInternalBtqlFilterClause(
-  value: unknown,
-): value is InternalBtqlFilterClause {
-  return isObject(value) && typeof value["op"] === "string";
-}
-
-function normalizeInternalBtql(
-  internalBtql?: InternalBtqlQuery,
-): InternalBtqlQuery | undefined {
-  if (internalBtql === undefined) {
-    return undefined;
-  }
-
-  const filter = internalBtql["filter"];
-  if (!Array.isArray(filter)) {
-    return internalBtql;
-  }
-
-  if (!filter.every(isInternalBtqlFilterClause)) {
-    return internalBtql;
-  }
-
-  if (filter.length === 0) {
-    const { filter: _filter, ...normalizedInternalBtql } = internalBtql;
-    return normalizedInternalBtql;
-  }
-
-  return {
-    ...internalBtql,
-    filter:
-      filter.length === 1
-        ? filter[0]
-        : {
-            op: "and",
-            children: filter,
-          },
-  };
-}
-
 function getInternalBtqlLimit(
   internalBtql?: InternalBtqlQuery,
 ): number | undefined {
@@ -5800,12 +5760,11 @@ export class ObjectFetcher<RecordType> implements AsyncIterable<
     const state = await this.getState();
     const objectId = await this.id;
     const batchLimit = batchSize ?? DEFAULT_FETCH_BATCH_SIZE;
-    const normalizedInternalBtql = normalizeInternalBtql(this._internal_btql);
-    const internalLimit = getInternalBtqlLimit(normalizedInternalBtql);
+    const internalLimit = getInternalBtqlLimit(this._internal_btql);
     const limit =
       batchSize !== undefined ? batchSize : (internalLimit ?? batchLimit);
     const internalBtqlWithoutReservedQueryKeys = Object.fromEntries(
-      Object.entries(normalizedInternalBtql ?? {}).filter(
+      Object.entries(this._internal_btql ?? {}).filter(
         ([key]) =>
           key !== "cursor" &&
           key !== "limit" &&

From 8cb5b64f443532523493f6494cafb91716c44158 Mon Sep 17 00:00:00 2001
From: max-braintrust <max@braintrustdata.com>
Date: Thu, 23 Apr 2026 15:37:44 -0700
Subject: [PATCH 8/8] remove type

---
 js/src/logger.ts | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

diff --git a/js/src/logger.ts b/js/src/logger.ts
index 5914f7f6f..090c3065d 100644
--- a/js/src/logger.ts
+++ b/js/src/logger.ts
@@ -3402,21 +3402,11 @@ export interface ParametersRef {
   version?: string;
 }
 
-/**
- * Internal BTQL payload used to subset dataset-backed evals.
- *
- * The standard BTQL shape uses `filter`. To preserve separate clause
- * boundaries, `filter` may also be provided as an array. The BTQL API will
- * normalize that array into a single `filter` expression before resolving the
- * dataset query.
- */
-export type InternalBtqlQuery = Record<string, unknown>;
-
 export type InitOptions<IsOpen extends boolean> = FullLoginOptions & {
   experiment?: string;
   description?: string;
   dataset?: AnyDataset | DatasetRef;
-  _internal_btql?: InternalBtqlQuery;
+  _internal_btql?: Record<string, unknown>;
   parameters?: ParametersRef | RemoteEvalParameters<boolean, boolean>;
   update?: boolean;
   baseExperiment?: string;
@@ -3440,8 +3430,8 @@ function getExperimentDatasetFilter({
   _internal_btql,
 }: {
   dataset?: AnyDataset | DatasetRef;
-  _internal_btql?: InternalBtqlQuery;
-}): InternalBtqlQuery | undefined {
+  _internal_btql?: Record<string, unknown>;
+}): Record<string, unknown> | undefined {
   if (_internal_btql !== undefined) {
     return _internal_btql;
   }
@@ -3455,7 +3445,7 @@ function getExperimentDatasetFilter({
 }
 
 function getInternalBtqlLimit(
-  internalBtql?: InternalBtqlQuery,
+  internalBtql?: Record<string, unknown>,
 ): number | undefined {
   const limit = internalBtql?.["limit"];
   return typeof limit === "number" ? limit : undefined;
@@ -3846,7 +3836,7 @@ export type InitDatasetOptions<IsLegacyDataset extends boolean> =
     projectId?: string;
     metadata?: Record<string, unknown>;
     state?: BraintrustState;
-    _internal_btql?: InternalBtqlQuery;
+    _internal_btql?: Record<string, unknown>;
   } & UseOutputOption<IsLegacyDataset>;
 
 export type FullInitDatasetOptions<IsLegacyDataset extends boolean> = {
@@ -5743,7 +5733,7 @@ export class ObjectFetcher<RecordType> implements AsyncIterable<
     private pinnedVersion: string | undefined,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     private mutateRecord?: (r: any) => WithTransactionId<RecordType>,
-    private _internal_btql?: InternalBtqlQuery,
+    private _internal_btql?: Record<string, unknown>,
   ) {}
 
   public get id(): Promise<string> {
@@ -6894,7 +6884,7 @@ export class Dataset<
     lazyMetadata: LazyValue<ProjectDatasetMetadata>,
     pinnedVersion?: string,
     legacy?: IsLegacyDataset,
-    _internal_btql?: InternalBtqlQuery,
+    _internal_btql?: Record<string, unknown>,
   ) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const isLegacyDataset = (legacy ??