@mastra/libsql 1.15.0-alpha.0 → 1.15.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,144 @@
 # @mastra/libsql
 
+## 1.15.0-alpha.1
+
+### Patch Changes
+
+- Added optional tenancy arguments to `getDataset`, `updateDataset`, and `deleteDataset`. ([#18750](https://github.com/mastra-ai/mastra/pull/18750))
+
+  You can now pass `organizationId` and `projectId` to scope dataset reads, updates, and deletes to a specific tenant. Reads and updates against a dataset in a different tenant throw `DATASET_NOT_FOUND` (surfaced as a 404 over HTTP). Deletes silently no-op on a tenancy mismatch — matching the existing "delete non-existent id is a no-op" semantics so cross-tenant existence is never leaked via error timing or status.
+
+  **Example**
+
+  ```ts
+  // Before
+  await client.getDataset('abc123');
+  await client.deleteDataset('abc123');
+  await client.updateDataset({ id: 'abc123', name: 'renamed' });
+
+  // After — scope to a tenant
+  await client.getDataset('abc123', { organizationId: 'org_a', projectId: 'proj_1' });
+  await client.deleteDataset('abc123', { organizationId: 'org_a' });
+  await client.updateDataset({ id: 'abc123', name: 'renamed', organizationId: 'org_a' });
+  ```
+
+- Pushed remaining dataset read filters and pagination down to storage. ([#18710](https://github.com/mastra-ai/mastra/pull/18710))
+
+  `DatasetsManager.list({ filters })` now accepts `targetType`, `targetIds` (overlap/union semantics), and `name` (substring, case-insensitive) in addition to the existing tenancy and candidate filters. Filtering is pushed down to the storage layer so callers no longer have to post-filter results.
+
+  Storage adapters must also be upgraded to the versions listed below to honor the new filters. If a caller is on this version of `@mastra/core` but on an older storage adapter, the new `targetType`/`targetIds`/`name` filter keys are silently ignored by the adapter — no runtime error, but the filter has no effect and every dataset in the tenancy is returned.
+
+  `Dataset.listItems({ version, search, page, perPage })` now applies `search` and pagination at the storage layer when `version` is provided alongside any of those. Previously they were silently dropped whenever `version` was set. The return shape is unchanged: passing only `version` still returns a bare `DatasetItem[]` snapshot; passing `search`, `page`, or `perPage` (with or without `version`) returns the paginated `{ items, pagination }` shape. The bare-array branch is marked `@deprecated`; prefer passing `page` / `perPage` to always receive the paginated shape.
+
+- Fixed a double-encoding bug where `createDataset` stored `targetIds` and `scorerIds` as JSON-encoded strings instead of arrays. This caused the new `listDatasets({ filters: { targetIds } })` overlap query to never match. ([#18710](https://github.com/mastra-ai/mastra/pull/18710))
+
+  Existing rows written before this fix are still double-encoded and will not be matched by the new `targetIds` filter. They self-heal on the next `updateDataset` call. Deployments with a long tail of pre-existing datasets should run a one-time backfill (re-encoding `targetIds` and `scorerIds` on affected rows) rather than rely on incidental writes; this can be tracked as a follow-up if needed.
+
+- Tenancy-scope experiments `getById` and `delete*` on `ExperimentsStorage`. ([#18770](https://github.com/mastra-ai/mastra/pull/18770))
+
+  `ExperimentsStorage.getExperimentById`, `getExperimentResultById`, `deleteExperiment`, and `deleteExperimentResults` used to key on the primary id alone, so any caller who knew the id could read or delete the row regardless of tenant. All four now accept an optional `filters: { organizationId?, projectId? }` argument that is enforced on every adapter (inmemory, libsql, pg, mysql, mongodb, spanner):
+  - On tenancy mismatch, `get*` returns `null` at the storage layer.
+  - On tenancy mismatch, `delete*` is a silent no-op.
+  - The tenancy predicate is folded into the destructive DML itself (scoped `WHERE` on the DELETE, an atomic gate + delete inside a transaction, or a scoped subquery for the results cascade). A concurrent tenant swap of the same id between a pre-check and the DELETE cannot let a scoped delete hit another tenant's row.
+
+  Both behaviors match how a missing id already responds, so existence does not leak through error timing or messages.
+
+  The same atomic-DML pattern is also applied to `DatasetsStorage.deleteDataset` across all 5 store adapters, closing a TOCTOU window between the pre-check and the parent DELETE that was introduced when tenancy filters were originally added.
+
+  `Dataset.getExperiment` and the shared experiment-ownership gate on `Dataset` now forward the dataset's tenancy scope to storage, so experiment reads and downstream mutations (list results, update result, delete experiment) reached through a dataset handle are automatically scoped to the owning tenant.
+
+  Legacy calls that omit `filters` are unchanged, so this is fully backwards-compatible.
+
+  ```ts
+  // Before: any caller who knew the id could read/delete across tenants.
+  await store.experiments.getExperimentById({ id: experimentId });
+  await store.experiments.deleteExperiment({ id: experimentId });
+
+  // After: pass the caller's scope; wrong tenant gets null / silent no-op.
+  await store.experiments.getExperimentById({
+    id: experimentId,
+    filters: { organizationId, projectId },
+  });
+  await store.experiments.deleteExperiment({
+    id: experimentId,
+    filters: { organizationId, projectId },
+  });
+  ```
+
+- Fixed a cross-tenant data-access issue on datasets by scoping `DatasetsManager.get` and `DatasetsManager.delete` to tenancy filters. ([#18750](https://github.com/mastra-ai/mastra/pull/18750))
+
+  Previously `get({ id })` and `delete({ id })` looked up a dataset by its primary key alone. Any caller who knew a dataset id could read or delete it regardless of which `organizationId` / `projectId` it belonged to. This is now closed at the storage layer via a scoped SQL predicate (option (a) — no fetch-then-assert).
+
+  **What changed**
+  - `DatasetsManager.get` and `DatasetsManager.delete` accept optional `organizationId` and `projectId`.
+  - The tenancy is stashed on the returned `Dataset` handle and forwarded to every downstream storage call (`getDetails`, `update`, `addItem`, item batch ops, `startExperimentAsync`).
+  - The abstract storage contract (`getDatasetById`, `deleteDataset`) gained an optional `filters?: DatasetTenancyFilters` arg.
+  - Item-mutation inputs (`AddDatasetItemInput`, `UpdateDatasetItemInput`, `BatchInsertItemsInput`, `BatchDeleteItemsInput`) and `UpdateDatasetInput` accept optional `filters` for the internal existence check.
+
+  **Behavior**
+  - Omitting tenancy preserves the existing behavior (no predicate added) — fully backwards compatible.
+  - On tenancy mismatch, `get` throws NOT_FOUND (returns null at the storage layer) and `delete` is a silent no-op — matching how a missing id already behaves, so existence does not leak through error timing or messages.
+
+  **Example**
+
+  ```ts
+  // Before
+  const ds = await mastra.datasets.get({ id });
+  await mastra.datasets.delete({ id });
+
+  // After — scope to a tenant
+  const ds = await mastra.datasets.get({ id, organizationId, projectId });
+  await mastra.datasets.delete({ id, organizationId, projectId });
+  ```
+
+- Add optional `batchId`, `datasetId`, and `datasetItemId` fields to persisted scores so saved baseline scores can be grouped as one scoring pass and joined back to the dataset items they came from. ([#18331](https://github.com/mastra-ai/mastra/pull/18331))
+  - `scoreTrace()` accepts top-level `batchId`, `datasetId`, and `datasetItemId` when persisting a score for a stored trace.
+  - `ScoreRowData` and score save payloads now include nullable `batchId`, `datasetId`, and `datasetItemId`.
+  - Built-in stores with explicit score schema or attribute mappings now persist these provenance fields on saved scores.
+  - D1, DSQL, MSSQL, and Upstash score stores now apply additive provenance migrations or deterministic score ordering for persisted score reads.
+
+  ```ts
+  await scoreTrace({
+    storage,
+    scorer,
+    target: { traceId },
+    batchId: 'baseline-batch-1',
+    datasetId,
+    datasetItemId,
+  });
+  ```
+
+- Added optional `organizationId` and `projectId` fields to scores for multi-tenant isolation. Scores can now be saved with tenancy metadata and the `listScoresBy*` methods accept a `filters` option to scope results by organization and project. ([#18331](https://github.com/mastra-ai/mastra/pull/18331))
+
+  ```ts
+  await storage.saveScore({ ...score, organizationId: 'org-a', projectId: 'proj-1' });
+
+  const result = await storage.listScoresByScorerId({
+    scorerId,
+    filters: { organizationId: 'org-a', projectId: 'proj-1' },
+  });
+  ```
+
+  `projectId` identifies the project scope, separate from `resourceId` which continues to mean the agent memory resource.
+
+- Scoped `getDatasetById` and `deleteDataset` to tenancy filters when the caller passes `organizationId` / `projectId`. ([#18750](https://github.com/mastra-ai/mastra/pull/18750))
+
+  The adapters now push the tenancy predicate into the SQL/query when the new optional `filters` argument is present. Legacy calls that omit tenancy are unchanged. On mismatch, `getDatasetById` returns `null` and `deleteDataset` is a silent no-op — the cascade delete (dataset items and versions) is gated by a scoped parent pre-check, so cross-tenant data is never touched.
+
+- Added optional `organizationId` and `projectId` query parameters to the dataset routes. ([#18750](https://github.com/mastra-ai/mastra/pull/18750))
+
+  `GET /datasets/:datasetId`, `PATCH /datasets/:datasetId`, and `DELETE /datasets/:datasetId` now accept optional tenancy query parameters. When provided, they are forwarded to `mastra.datasets.get` / `.delete` and the operation returns 404 if the dataset does not belong to the requested tenant. Requests that omit the query parameters keep their existing behavior.
+
+  **Example**
+
+  ```
+  GET /datasets/abc123?organizationId=org_a&projectId=proj_1
+  DELETE /datasets/abc123?organizationId=org_a
+  ```
+
+- Updated dependencies [[`9250acd`](https://github.com/mastra-ai/mastra/commit/9250acd1357f0f1f33d0dcca16f9655084c58eca), [`215f9b0`](https://github.com/mastra-ai/mastra/commit/215f9b0f3f3f6fc165edad360582dd4d3d7ea748), [`c64c2a8`](https://github.com/mastra-ai/mastra/commit/c64c2a8503a50252f9ca6b8e8c54cadee31b92a2), [`06e2680`](https://github.com/mastra-ai/mastra/commit/06e26806b51d2cbd858afdc66daa2b86ff3ba64a), [`1240f05`](https://github.com/mastra-ai/mastra/commit/1240f051c8e5371f1c014448bf37b1a1b9a05e47), [`215f9b0`](https://github.com/mastra-ai/mastra/commit/215f9b0f3f3f6fc165edad360582dd4d3d7ea748), [`24c10d3`](https://github.com/mastra-ai/mastra/commit/24c10d333e6649ac06075903aeeee13a933db3b3), [`24c10d3`](https://github.com/mastra-ai/mastra/commit/24c10d333e6649ac06075903aeeee13a933db3b3), [`24c10d3`](https://github.com/mastra-ai/mastra/commit/24c10d333e6649ac06075903aeeee13a933db3b3), [`24c10d3`](https://github.com/mastra-ai/mastra/commit/24c10d333e6649ac06075903aeeee13a933db3b3), [`215f9b0`](https://github.com/mastra-ai/mastra/commit/215f9b0f3f3f6fc165edad360582dd4d3d7ea748), [`215f9b0`](https://github.com/mastra-ai/mastra/commit/215f9b0f3f3f6fc165edad360582dd4d3d7ea748)]:
+  - @mastra/core@1.49.0-alpha.5
+
 ## 1.15.0-alpha.0
 
 ### Minor Changes

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-libsql
 description: Documentation for @mastra/libsql. Use when working with @mastra/libsql APIs, configuration, or implementation.
 metadata:
   package: "@mastra/libsql"
-  version: "1.15.0-alpha.0"
+  version: "1.15.0-alpha.1"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.15.0-alpha.0",
+  "version": "1.15.0-alpha.1",
   "package": "@mastra/libsql",
   "exports": {},
   "modules": {}

package/dist/index.cjs

@@ -3826,6 +3826,30 @@ var ChannelsLibSQL = class extends storage.ChannelsStorage {
     };
   }
 };
+
+// src/storage/domains/utils.ts
+function tenancyWhere(filters) {
+  const conditions = [];
+  const params = [];
+  if (filters?.organizationId !== void 0) {
+    conditions.push("organizationId = ?");
+    params.push(filters.organizationId);
+  }
+  if (filters?.projectId !== void 0) {
+    conditions.push("projectId = ?");
+    params.push(filters.projectId);
+  }
+  return { conditions, params };
+}
+function buildScopedWhere(idColumn, idValue, filters) {
+  const { conditions, params } = tenancyWhere(filters);
+  return {
+    sql: [`${idColumn} = ?`, ...conditions].join(" AND "),
+    args: [idValue, ...params]
+  };
+}
+
+// src/storage/domains/datasets/index.ts
 function jsonbArg(value) {
   return value === void 0 || value === null ? null : JSON.stringify(value);
 }
@@ -3906,6 +3930,18 @@ var DatasetsLibSQL = class extends storage.DatasetsStorage {
     await this.#db.deleteData({ tableName: storage.TABLE_DATASET_ITEMS });
     await this.#db.deleteData({ tableName: storage.TABLE_DATASETS });
   }
+  async experimentTablesExist() {
+    try {
+      const result = await this.#client.execute({
+        sql: `SELECT COUNT(*) AS c FROM sqlite_master WHERE type = 'table' AND name IN (?, ?)`,
+        args: [storage.TABLE_EXPERIMENTS, storage.TABLE_EXPERIMENT_RESULTS]
+      });
+      const row = result.rows?.[0];
+      return Number(row?.c ?? 0) === 2;
+    } catch {
+      return false;
+    }
+  }
   // --- Row transformers ---
   transformDatasetRow(row) {
     return {
@@ -3992,8 +4028,8 @@ var DatasetsLibSQL = class extends storage.DatasetsStorage {
           groundTruthSchema: input.groundTruthSchema ?? null,
           requestContextSchema: input.requestContextSchema ?? null,
           targetType: input.targetType ?? null,
-          targetIds: input.targetIds ? JSON.stringify(input.targetIds) : null,
-          scorerIds: input.scorerIds ? JSON.stringify(input.scorerIds) : null,
+          targetIds: input.targetIds ?? null,
+          scorerIds: input.scorerIds ?? null,
           version: 0,
           organizationId: input.organizationId ?? null,
           projectId: input.projectId ?? null,
@@ -4033,11 +4069,16 @@ var DatasetsLibSQL = class extends storage.DatasetsStorage {
       );
     }
   }
-  async getDatasetById({ id }) {
+  async getDatasetById({
+    id,
+    filters
+  }) {
     try {
+      const { conditions, params } = tenancyWhere(filters);
+      const whereSql = ["id = ?", ...conditions].join(" AND ");
       const result = await this.#client.execute({
-        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASETS)} FROM ${storage.TABLE_DATASETS} WHERE id = ?`,
-        args: [id]
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_DATASETS)} FROM ${storage.TABLE_DATASETS} WHERE ${whereSql}`,
+        args: [id, ...params]
       });
       return result.rows?.[0] ? this.transformDatasetRow(result.rows[0]) : null;
     } catch (error$1) {
@@ -4053,7 +4094,7 @@ var DatasetsLibSQL = class extends storage.DatasetsStorage {
   }
   async _doUpdateDataset(args) {
     try {
-      const existing = await this.getDatasetById({ id: args.id });
+      const existing = await this.getDatasetById({ id: args.id, filters: args.filters });
       if (!existing) {
         throw new error.MastraError({
           id: storage.createStorageErrorId("LIBSQL", "UPDATE_DATASET", "NOT_FOUND"),
@@ -4136,30 +4177,31 @@ var DatasetsLibSQL = class extends storage.DatasetsStorage {
       );
     }
   }
-  async deleteDataset({ id }) {
+  async deleteDataset({ id, filters }) {
     try {
-      try {
-        await this.#client.execute({
+      const { conditions, params } = tenancyWhere(filters);
+      const scopedWhere = ["id = ?", ...conditions].join(" AND ");
+      const exists = await this.#client.execute({
+        sql: `SELECT id FROM ${storage.TABLE_DATASETS} WHERE ${scopedWhere}`,
+        args: [id, ...params]
+      });
+      if (!exists.rows?.[0]) return;
+      const experimentTablesExist = await this.experimentTablesExist();
+      const statements = [];
+      if (experimentTablesExist) {
+        statements.push({
           sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId IN (SELECT id FROM ${storage.TABLE_EXPERIMENTS} WHERE datasetId = ?)`,
           args: [id]
         });
-      } catch {
-      }
-      try {
-        await this.#client.execute({
+        statements.push({
           sql: `UPDATE ${storage.TABLE_EXPERIMENTS} SET datasetId = NULL, datasetVersion = NULL WHERE datasetId = ?`,
           args: [id]
         });
-      } catch {
       }
-      await this.#client.batch(
-        [
-          { sql: `DELETE FROM ${storage.TABLE_DATASET_VERSIONS} WHERE datasetId = ?`, args: [id] },
-          { sql: `DELETE FROM ${storage.TABLE_DATASET_ITEMS} WHERE datasetId = ?`, args: [id] },
-          { sql: `DELETE FROM ${storage.TABLE_DATASETS} WHERE id = ?`, args: [id] }
-        ],
-        "write"
-      );
+      statements.push({ sql: `DELETE FROM ${storage.TABLE_DATASET_VERSIONS} WHERE datasetId = ?`, args: [id] });
+      statements.push({ sql: `DELETE FROM ${storage.TABLE_DATASET_ITEMS} WHERE datasetId = ?`, args: [id] });
+      statements.push({ sql: `DELETE FROM ${storage.TABLE_DATASETS} WHERE ${scopedWhere}`, args: [id, ...params] });
+      await this.#client.batch(statements, "write");
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -4192,6 +4234,21 @@ var DatasetsLibSQL = class extends storage.DatasetsStorage {
         filterConditions.push("candidateId = ?");
         filterParams.push(args.filters.candidateId);
       }
+      if (args.filters?.targetType !== void 0) {
+        filterConditions.push("targetType = ?");
+        filterParams.push(args.filters.targetType);
+      }
+      if (args.filters?.targetIds !== void 0 && args.filters.targetIds.length > 0) {
+        const placeholders = args.filters.targetIds.map(() => "?").join(",");
+        filterConditions.push(
+          `EXISTS (SELECT 1 FROM json_each(${storage.TABLE_DATASETS}.targetIds) WHERE value IN (${placeholders}))`
+        );
+        for (const id of args.filters.targetIds) filterParams.push(id);
+      }
+      if (args.filters?.name !== void 0 && args.filters.name.length > 0) {
+        filterConditions.push("LOWER(name) LIKE ?");
+        filterParams.push(`%${args.filters.name.toLowerCase()}%`);
+      }
       const whereClause = filterConditions.length > 0 ? `WHERE ${filterConditions.join(" AND ")}` : "";
       const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_DATASETS} ${whereClause}`,
@@ -5157,9 +5214,10 @@ var ExperimentsLibSQL = class extends storage.ExperimentsStorage {
   }
   async getExperimentById(args) {
     try {
+      const scoped = buildScopedWhere("id", args.id, args.filters);
       const result = await this.#client.execute({
-        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENTS)} FROM ${storage.TABLE_EXPERIMENTS} WHERE id = ?`,
-        args: [args.id]
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENTS)} FROM ${storage.TABLE_EXPERIMENTS} WHERE ${scoped.sql}`,
+        args: scoped.args
       });
       return result.rows?.[0] ? this.transformExperimentRow(result.rows[0]) : null;
     } catch (error$1) {
@@ -5251,14 +5309,17 @@ var ExperimentsLibSQL = class extends storage.ExperimentsStorage {
   }
   async deleteExperiment(args) {
     try {
-      await this.#client.execute({
-        sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId = ?`,
-        args: [args.id]
-      });
-      await this.#client.execute({
-        sql: `DELETE FROM ${storage.TABLE_EXPERIMENTS} WHERE id = ?`,
-        args: [args.id]
-      });
+      const parentScoped = buildScopedWhere("id", args.id, args.filters);
+      const { conditions, params } = tenancyWhere(args.filters);
+      const cascadeWhere = conditions.length ? `experimentId IN (SELECT id FROM ${storage.TABLE_EXPERIMENTS} WHERE ${["id = ?", ...conditions].join(" AND ")})` : `experimentId = ?`;
+      const cascadeArgs = conditions.length ? [args.id, ...params] : [args.id];
+      await this.#client.batch(
+        [
+          { sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE ${cascadeWhere}`, args: cascadeArgs },
+          { sql: `DELETE FROM ${storage.TABLE_EXPERIMENTS} WHERE ${parentScoped.sql}`, args: parentScoped.args }
+        ],
+        "write"
+      );
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -5396,9 +5457,10 @@ var ExperimentsLibSQL = class extends storage.ExperimentsStorage {
   }
   async getExperimentResultById(args) {
     try {
+      const scoped = buildScopedWhere("id", args.id, args.filters);
       const result = await this.#client.execute({
-        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENT_RESULTS)} FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE id = ?`,
-        args: [args.id]
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_EXPERIMENT_RESULTS)} FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE ${scoped.sql}`,
+        args: scoped.args
       });
       return result.rows?.[0] ? this.transformExperimentResultRow(result.rows[0]) : null;
     } catch (error$1) {
@@ -5478,6 +5540,14 @@ var ExperimentsLibSQL = class extends storage.ExperimentsStorage {
   }
   async deleteExperimentResults(args) {
     try {
+      const { conditions, params } = tenancyWhere(args.filters);
+      if (conditions.length) {
+        await this.#client.execute({
+          sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId IN (SELECT id FROM ${storage.TABLE_EXPERIMENTS} WHERE ${["id = ?", ...conditions].join(" AND ")})`,
+          args: [args.experimentId, ...params]
+        });
+        return;
+      }
       await this.#client.execute({
         sql: `DELETE FROM ${storage.TABLE_EXPERIMENT_RESULTS} WHERE experimentId = ?`,
         args: [args.experimentId]
@@ -11044,6 +11114,16 @@ var ScorerDefinitionsLibSQL = class extends storage.ScorerDefinitionsStorage {
     };
   }
 };
+function appendTenancyConditions(conditions, args, filters) {
+  if (filters?.organizationId !== void 0) {
+    conditions.push(`organizationId = ?`);
+    args.push(filters.organizationId);
+  }
+  if (filters?.projectId !== void 0) {
+    conditions.push(`projectId = ?`);
+    args.push(filters.projectId);
+  }
+}
 var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
   /**
    * Scorer results accumulate as evals run. Single table, anchored on `createdAt`.
@@ -11064,7 +11144,7 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
     await this.#db.alterTable({
       tableName: storage.TABLE_SCORERS,
       schema: storage.SCORERS_SCHEMA,
-      ifNotExists: ["spanId", "requestContext"]
+      ifNotExists: ["spanId", "requestContext", "organizationId", "projectId", "batchId", "datasetId", "datasetItemId"]
     });
   }
   async dangerouslyClearAll() {
@@ -11081,13 +11161,18 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
   }
   async listScoresByRunId({
     runId,
-    pagination
+    pagination,
+    filters
   }) {
     try {
       const { page, perPage: perPageInput } = pagination;
+      const conditions = [`runId = ?`];
+      const queryParams = [runId];
+      appendTenancyConditions(conditions, queryParams, filters);
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
       const countResult = await this.#client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE runId = ?`,
-        args: [runId]
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} ${whereClause}`,
+        args: queryParams
       });
       const total = Number(countResult.rows?.[0]?.count ?? 0);
       if (total === 0) {
@@ -11106,8 +11191,8 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT ${buildSelectColumns(storage.TABLE_SCORERS)} FROM ${storage.TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [runId, limitValue, start]
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_SCORERS)} FROM ${storage.TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
       return {
@@ -11135,7 +11220,8 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
     entityId,
     entityType,
     source,
-    pagination
+    pagination,
+    filters
   }) {
     try {
       const { page, perPage: perPageInput } = pagination;
@@ -11157,6 +11243,7 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
         conditions.push(`source = ?`);
         queryParams.push(source);
       }
+      appendTenancyConditions(conditions, queryParams, filters);
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const countResult = await this.#client.execute({
         sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} ${whereClause}`,
@@ -11264,13 +11351,18 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
   async listScoresByEntityId({
     entityId,
     entityType,
-    pagination
+    pagination,
+    filters
   }) {
     try {
       const { page, perPage: perPageInput } = pagination;
+      const conditions = [`entityId = ?`, `entityType = ?`];
+      const queryParams = [entityId, entityType];
+      appendTenancyConditions(conditions, queryParams, filters);
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
       const countResult = await this.#client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE entityId = ? AND entityType = ?`,
-        args: [entityId, entityType]
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} ${whereClause}`,
+        args: queryParams
       });
       const total = Number(countResult.rows?.[0]?.count ?? 0);
       if (total === 0) {
@@ -11289,8 +11381,8 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT ${buildSelectColumns(storage.TABLE_SCORERS)} FROM ${storage.TABLE_SCORERS} WHERE entityId = ? AND entityType = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [entityId, entityType, limitValue, start]
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_SCORERS)} FROM ${storage.TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
       return {
@@ -11316,22 +11408,27 @@ var ScoresLibSQL = class _ScoresLibSQL extends storage.ScoresStorage {
   async listScoresBySpan({
     traceId,
     spanId,
-    pagination
+    pagination,
+    filters
   }) {
     try {
       const { page, perPage: perPageInput } = pagination;
       const perPage = storage.normalizePerPage(perPageInput, 100);
       const { offset: start, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+      const conditions = [`traceId = ?`, `spanId = ?`];
+      const queryParams = [traceId, spanId];
+      appendTenancyConditions(conditions, queryParams, filters);
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
       const countSQLResult = await this.#client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE traceId = ? AND spanId = ?`,
-        args: [traceId, spanId]
+        sql: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} ${whereClause}`,
+        args: queryParams
       });
       const total = Number(countSQLResult.rows?.[0]?.count ?? 0);
       const limitValue = perPageInput === false ? total : perPage;
       const end = perPageInput === false ? total : start + perPage;
       const result = await this.#client.execute({
-        sql: `SELECT ${buildSelectColumns(storage.TABLE_SCORERS)} FROM ${storage.TABLE_SCORERS} WHERE traceId = ? AND spanId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [traceId, spanId, limitValue, start]
+        sql: `SELECT ${buildSelectColumns(storage.TABLE_SCORERS)} FROM ${storage.TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, start]
       });
       const scores = result.rows?.map((row) => this.transformScoreRow(row)) ?? [];
       return {