@mastra/astra 0.10.3-alpha.0 → 0.11.0-alpha.2

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/astra@0.10.3-alpha.0 build /home/runner/work/mastra/mastra/stores/astra
+> @mastra/astra@0.11.0-alpha.2 build /home/runner/work/mastra/mastra/stores/astra
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 5947ms
+TSC ⚡️ Build success in 7859ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/astra/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/astra/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 8679ms
+DTS ⚡️ Build success in 9584ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
 CJS dist/index.cjs 14.42 KB
-CJS ⚡️ Build success in 486ms
+CJS ⚡️ Build success in 514ms
 ESM dist/index.js 14.16 KB
-ESM ⚡️ Build success in 486ms
+ESM ⚡️ Build success in 515ms

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @mastra/astra
 
+## 0.11.0-alpha.2
+
+### Minor Changes
+
+- 8a3bfd2: Update peerdeps to latest core
+
+### Patch Changes
+
+- Updated dependencies [792c4c0]
+- Updated dependencies [502fe05]
+- Updated dependencies [4efcfa0]
+  - @mastra/core@0.10.7-alpha.3
+
+## 0.10.3-alpha.1
+
+### Patch Changes
+
+- 144eb0b: [MASTRA-3669] Metadata Filter Types
+- Updated dependencies [15e9d26]
+- Updated dependencies [07d6d88]
+- Updated dependencies [5d74aab]
+- Updated dependencies [144eb0b]
+  - @mastra/core@0.10.7-alpha.2
+
 ## 0.10.3-alpha.0
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -1,11 +1,14 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
+import type { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import { MastraVector } from '@mastra/core/vector';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { UpdateVectorParams } from '@mastra/core/vector';
@@ -20,6 +23,8 @@ declare const ASTRA_PROMPT = "When querying Astra, you can ONLY use the operator
 export { ASTRA_PROMPT }
 export { ASTRA_PROMPT as ASTRA_PROMPT_alias_1 }
 
+declare type AstraBlacklisted = BlacklistedRootOperators | '$nor' | '$size';
+
 declare interface AstraDbOptions {
     token: string;
     endpoint: string;
@@ -33,14 +38,22 @@ export { AstraDbOptions as AstraDbOptions_alias_1 }
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export declare class AstraFilterTranslator extends BaseFilterTranslator {
+export declare class AstraFilterTranslator extends BaseFilterTranslator<AstraVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: AstraVectorFilter): AstraVectorFilter;
     private translateNode;
     private translateOperatorValue;
 }
 
-declare class AstraVector extends MastraVector {
+declare type AstraLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+declare type AstraOperatorValueMap = Omit<OperatorValueMap, '$elemMatch' | '$regex' | '$options'> & {
+    $size: number;
+};
+
+declare type AstraQueryVectorParams = QueryVectorParams<AstraVectorFilter>;
+
+declare class AstraVector extends MastraVector<AstraVectorFilter> {
     #private;
     constructor({ token, endpoint, keyspace }: AstraDbOptions);
     /**
@@ -62,7 +75,7 @@ declare class AstraVector extends MastraVector {
      * @returns {Promise<string[]>} A promise that resolves to an array of IDs of the upserted vectors.
      */
     upsert({ indexName, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]>;
-    transformFilter(filter?: VectorFilter): VectorFilter;
+    transformFilter(filter?: AstraVectorFilter): AstraVectorFilter;
     /**
      * Queries the specified collection using a vector and optional filter.
      *
@@ -73,7 +86,7 @@ declare class AstraVector extends MastraVector {
      * @param {boolean} [includeVectors=false] - Whether to include the vectors in the response.
      * @returns {Promise<QueryResult[]>} A promise that resolves to an array of query results.
      */
-    query({ indexName, queryVector, topK, filter, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
+    query({ indexName, queryVector, topK, filter, includeVector, }: AstraQueryVectorParams): Promise<QueryResult[]>;
     /**
      * Lists all collections in the database.
      *
@@ -117,4 +130,6 @@ declare class AstraVector extends MastraVector {
 export { AstraVector }
 export { AstraVector as AstraVector_alias_1 }
 
+export declare type AstraVectorFilter = VectorFilter<keyof AstraOperatorValueMap, AstraOperatorValueMap, AstraLogicalOperatorValueMap, AstraBlacklisted>;
+
 export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -1,11 +1,14 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
+import type { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import { MastraVector } from '@mastra/core/vector';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { UpdateVectorParams } from '@mastra/core/vector';
@@ -20,6 +23,8 @@ declare const ASTRA_PROMPT = "When querying Astra, you can ONLY use the operator
 export { ASTRA_PROMPT }
 export { ASTRA_PROMPT as ASTRA_PROMPT_alias_1 }
 
+declare type AstraBlacklisted = BlacklistedRootOperators | '$nor' | '$size';
+
 declare interface AstraDbOptions {
     token: string;
     endpoint: string;
@@ -33,14 +38,22 @@ export { AstraDbOptions as AstraDbOptions_alias_1 }
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export declare class AstraFilterTranslator extends BaseFilterTranslator {
+export declare class AstraFilterTranslator extends BaseFilterTranslator<AstraVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: AstraVectorFilter): AstraVectorFilter;
     private translateNode;
     private translateOperatorValue;
 }
 
-declare class AstraVector extends MastraVector {
+declare type AstraLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+declare type AstraOperatorValueMap = Omit<OperatorValueMap, '$elemMatch' | '$regex' | '$options'> & {
+    $size: number;
+};
+
+declare type AstraQueryVectorParams = QueryVectorParams<AstraVectorFilter>;
+
+declare class AstraVector extends MastraVector<AstraVectorFilter> {
     #private;
     constructor({ token, endpoint, keyspace }: AstraDbOptions);
     /**
@@ -62,7 +75,7 @@ declare class AstraVector extends MastraVector {
      * @returns {Promise<string[]>} A promise that resolves to an array of IDs of the upserted vectors.
      */
     upsert({ indexName, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]>;
-    transformFilter(filter?: VectorFilter): VectorFilter;
+    transformFilter(filter?: AstraVectorFilter): AstraVectorFilter;
     /**
      * Queries the specified collection using a vector and optional filter.
      *
@@ -73,7 +86,7 @@ declare class AstraVector extends MastraVector {
      * @param {boolean} [includeVectors=false] - Whether to include the vectors in the response.
      * @returns {Promise<QueryResult[]>} A promise that resolves to an array of query results.
      */
-    query({ indexName, queryVector, topK, filter, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
+    query({ indexName, queryVector, topK, filter, includeVector, }: AstraQueryVectorParams): Promise<QueryResult[]>;
     /**
      * Lists all collections in the database.
      *
@@ -117,4 +130,6 @@ declare class AstraVector extends MastraVector {
 export { AstraVector }
 export { AstraVector as AstraVector_alias_1 }
 
+export declare type AstraVectorFilter = VectorFilter<keyof AstraOperatorValueMap, AstraOperatorValueMap, AstraLogicalOperatorValueMap, AstraBlacklisted>;
+
 export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/astra",
-  "version": "0.10.3-alpha.0",
+  "version": "0.11.0-alpha.2",
   "description": "Astra DB provider for Mastra - includes vector store capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -25,15 +25,15 @@
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
-    "eslint": "^9.28.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
     "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.7-alpha.1"
+    "@mastra/core": "0.10.7-alpha.3"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.4-0 <0.11.0"
+    "@mastra/core": ">=0.10.7-0 <0.11.0-0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { AstraVectorFilter } from './filter';
 import { AstraFilterTranslator } from './filter';
 
 describe('AstraFilterTranslator', () => {
@@ -12,12 +13,12 @@ describe('AstraFilterTranslator', () => {
   // Basic Filter Operations
   describe('basic operations', () => {
     it('handles simple equality', () => {
-      const filter = { field: 'value' };
+      const filter: AstraVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles comparison operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         age: { $gt: 25 },
         score: { $lte: 100 },
       };
@@ -25,7 +26,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles valid multiple operators on same field', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         price: { $gt: 100, $lt: 200 },
         quantity: { $gte: 10, $lte: 20 },
       };
@@ -33,7 +34,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles null values correctly', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         field: null,
         other: { $eq: null },
       };
@@ -41,7 +42,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('throws on unsupported combinations', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         field: { $gt: 100, $lt: 200 },
       };
       expect(translator.translate(filter)).toEqual(filter);
@@ -51,14 +52,14 @@ describe('AstraFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('handles array operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         tags: { $all: ['tag1', 'tag2'] },
         categories: { $in: ['A', 'B'] },
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
     it('handles empty array values', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         tags: { $in: [] },
         categories: { $all: [] },
       };
@@ -66,7 +67,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles nested array operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $and: [{ tags: { $all: ['tag1', 'tag2'] } }, { 'nested.array': { $in: [1, 2, 3] } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
@@ -76,14 +77,14 @@ describe('AstraFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $or: [{ status: 'active' }, { age: { $gt: 25 } }],
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $and: [
           { status: 'active' },
           { $or: [{ category: { $in: ['A', 'B'] } }, { $and: [{ price: { $gt: 100 } }, { stock: { $lt: 50 } }] }] },
@@ -93,7 +94,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles empty conditions in logical operators', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         $and: [],
         $or: [{}],
         field: 'value',
@@ -147,7 +148,7 @@ describe('AstraFilterTranslator', () => {
 
       expect(() =>
         translator.translate({
-          $or: [{ $in: ['value1', 'value2'] }],
+          $or: [{ $in: ['value1', 'value2'] as any }],
         }),
       ).toThrow(/Logical operators must contain field conditions/);
     });
@@ -158,7 +159,7 @@ describe('AstraFilterTranslator', () => {
           field: {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            },
+            } as any,
           },
         }),
       ).toThrow();
@@ -169,7 +170,7 @@ describe('AstraFilterTranslator', () => {
             $in: [
               {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
-              },
+              } as any,
             ],
           },
         }),
@@ -182,7 +183,7 @@ describe('AstraFilterTranslator', () => {
           field: {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            },
+            } as any,
           },
         }),
       ).toThrow();
@@ -200,7 +201,7 @@ describe('AstraFilterTranslator', () => {
 
     it('throws error for $not if not an object', () => {
       expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: [{ field: 'value' }] })).toThrow();
+      expect(() => translator.translate({ $not: [{ field: 'value' }] } as any)).toThrow();
     });
 
     it('throws error for $not if empty', () => {
@@ -211,7 +212,7 @@ describe('AstraFilterTranslator', () => {
   // Nested Objects and Fields
   describe('nested objects and fields', () => {
     it('handles nested objects', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         'user.profile.age': { $gt: 25 },
         'user.status': 'active',
       };
@@ -219,7 +220,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('handles deeply nested field paths', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         'user.profile.address.city': { $eq: 'New York' },
         'deep.nested.field': { $gt: 100 },
       };
@@ -227,38 +228,28 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('preserves nested empty objects', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         status: 'active',
         metadata: {},
-        user: {
-          profile: {},
-          settings: { theme: null },
-        },
+        'user.profile': {},
+        'usersettings.theme': null,
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles mix of operators and empty objects', () => {
-      const filter = {
+      const filter: AstraVectorFilter = {
         tags: { $in: ['a', 'b'] },
         metadata: {},
-        nested: {
-          field: { $eq: 'value' },
-          empty: {},
-        },
+        'nested.field': { $eq: 'value' },
+        'nested.empty': {},
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
 
     it('handles deeply nested operators', () => {
-      const filter = {
-        user: {
-          profile: {
-            preferences: {
-              theme: { $in: ['dark', 'light'] },
-            },
-          },
-        },
+      const filter: AstraVectorFilter = {
+        'user.profile.preferences.theme': { $in: ['dark', 'light'] },
       };
       expect(translator.translate(filter)).toEqual(filter);
     });
@@ -268,13 +259,13 @@ describe('AstraFilterTranslator', () => {
   describe('special cases', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual({});
-      expect(translator.translate(null as any)).toEqual(null);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(null);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('normalizes dates', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: AstraVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({
         timestamp: { $gt: date.toISOString() },
       });
@@ -293,7 +284,7 @@ describe('AstraFilterTranslator', () => {
 
   describe('operator validation', () => {
     it('ensure all operator filters are supported', () => {
-      const supportedFilters = [
+      const supportedFilters: AstraVectorFilter[] = [
         // Basic comparison operators
         { field: { $eq: 'value' } },
         { field: { $ne: 'value' } },
@@ -313,11 +304,9 @@ describe('AstraFilterTranslator', () => {
         { $and: [{ field1: 'value1' }, { field2: 'value2' }] },
         { $or: [{ field1: 'value1' }, { field2: 'value2' }] },
 
-        { $and: { field: 'value' } },
-        { $or: { field: 'value' } },
         { $not: { field: 'value' } },
 
-        { $or: [{ $and: { field1: 'value1' } }, { $not: { field2: 'value2' } }] },
+        { $or: [{ $and: [{ field1: 'value1' }] }, { $not: { field2: 'value2' } }] },
 
         { field: { $not: { $eq: 'value' } } },
         { field: { $not: { $in: ['value1', 'value2'] } } },
@@ -333,16 +322,16 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('throws on unsupported operators', () => {
-      expect(() => translator.translate({ field: { $regex: 'value' } })).toThrow('Unsupported operator: $regex');
-      const filter = { field: /pattern/i };
+      expect(() => translator.translate({ field: { $regex: 'value' } as any })).toThrow('Unsupported operator: $regex');
+      const filter: any = { field: /pattern/i };
       expect(() => translator.translate(filter)).toThrow();
-      expect(() => translator.translate({ $nor: [{ field: 'value' }] })).toThrow('Unsupported operator: $nor');
-      expect(() => translator.translate({ field: { $elemMatch: { $gt: 5 } } })).toThrow(
+      expect(() => translator.translate({ $nor: [{ field: 'value' }] } as any)).toThrow('Unsupported operator: $nor');
+      expect(() => translator.translate({ field: { $elemMatch: { $gt: 5 } } } as any)).toThrow(
         'Unsupported operator: $elemMatch',
       );
     });
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $exists: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
@@ -350,7 +339,7 @@ describe('AstraFilterTranslator', () => {
     });
 
     it('allows logical operators at top level', () => {
-      const validFilters = [
+      const validFilters: AstraVectorFilter[] = [
         { $and: [{ field: 'value' }] },
         { $or: [{ field: 'value' }] },
         { $not: { field: 'value' } },

package/src/vector/filter.ts

@@ -1,12 +1,34 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
+import type {
+  VectorFilter,
+  OperatorSupport,
+  QueryOperator,
+  OperatorValueMap,
+  LogicalOperatorValueMap,
+  BlacklistedRootOperators,
+} from '@mastra/core/vector/filter';
+
+type AstraOperatorValueMap = Omit<OperatorValueMap, '$elemMatch' | '$regex' | '$options'> & {
+  $size: number; // Astra-specific
+};
+
+type AstraLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+type AstraBlacklisted = BlacklistedRootOperators | '$nor' | '$size';
+
+export type AstraVectorFilter = VectorFilter<
+  keyof AstraOperatorValueMap,
+  AstraOperatorValueMap,
+  AstraLogicalOperatorValueMap,
+  AstraBlacklisted
+>;
 
 /**
  * Translator for Astra DB filter queries.
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class AstraFilterTranslator extends BaseFilterTranslator {
+export class AstraFilterTranslator extends BaseFilterTranslator<AstraVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -17,14 +39,14 @@ export class AstraFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: AstraVectorFilter): AstraVectorFilter {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
 
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: AstraVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isRegex(node)) {
       throw new Error('Regex is not supported in Astra DB');

package/src/vector/index.test.ts

@@ -297,7 +297,7 @@ describe.skip('AstraVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName2,
           queryVector: [1, 0, 0, 0],
-          filter: { tags: { $all: 'not-an-array' } },
+          filter: { tags: { $all: 'not-an-array' as any } },
         }),
       ).rejects.toThrow();
     });
@@ -307,15 +307,7 @@ describe.skip('AstraVector Integration Tests', () => {
         vectorDB.query({
           indexName: testIndexName2,
           queryVector: [1, 0, 0, 0],
-          filter: { tags: { $in: null } },
-        }),
-      ).rejects.toThrow();
-
-      await expect(
-        vectorDB.query({
-          indexName: testIndexName2,
-          queryVector: [1, 0, 0, 0],
-          filter: { tags: { $all: 'not-an-array' } },
+          filter: { tags: { $in: null as any } },
         }),
       ).rejects.toThrow();
     });
@@ -327,7 +319,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $in: val } },
+            filter: { field: { $in: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -340,7 +332,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $nin: val } },
+            filter: { field: { $nin: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -353,7 +345,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $all: val } },
+            filter: { field: { $all: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -366,7 +358,7 @@ describe.skip('AstraVector Integration Tests', () => {
           vectorDB.query({
             indexName: testIndexName2,
             queryVector: [1, 0, 0, 0],
-            filter: { field: { $exists: val } },
+            filter: { field: { $exists: val as any } },
           }),
         ).rejects.toThrow();
       }
@@ -395,9 +387,9 @@ describe.skip('AstraVector Integration Tests', () => {
           indexName: testIndexName2,
           queryVector: [1, 0, 0, 0],
           filter: {
-            field1: { $in: 'not-array' },
-            field2: { $exists: 'not-boolean' },
-            field3: { $gt: 'not-number' },
+            field1: { $in: 'not-array' as any },
+            field2: { $exists: 'not-boolean' as any },
+            field3: { $gt: 'not-number' as any },
           },
         }),
       ).rejects.toThrow();

package/src/vector/index.ts

@@ -13,8 +13,7 @@ import type {
   DeleteVectorParams,
   UpdateVectorParams,
 } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
-
+import type { AstraVectorFilter } from './filter';
 import { AstraFilterTranslator } from './filter';
 
 // Mastra and Astra DB agree on cosine and euclidean, but Astra DB uses dot_product instead of dotproduct.
@@ -30,7 +29,9 @@ export interface AstraDbOptions {
   keyspace?: string;
 }
 
-export class AstraVector extends MastraVector {
+type AstraQueryVectorParams = QueryVectorParams<AstraVectorFilter>;
+
+export class AstraVector extends MastraVector<AstraVectorFilter> {
   readonly #db: Db;
 
   constructor({ token, endpoint, keyspace }: AstraDbOptions) {
@@ -114,7 +115,7 @@ export class AstraVector extends MastraVector {
     return vectorIds;
   }
 
-  transformFilter(filter?: VectorFilter) {
+  transformFilter(filter?: AstraVectorFilter) {
     const translator = new AstraFilterTranslator();
     return translator.translate(filter);
   }
@@ -135,7 +136,7 @@ export class AstraVector extends MastraVector {
     topK = 10,
     filter,
     includeVector = false,
-  }: QueryVectorParams): Promise<QueryResult[]> {
+  }: AstraQueryVectorParams): Promise<QueryResult[]> {
     const collection = this.#db.collection(indexName);
 
     const translatedFilter = this.transformFilter(filter);