@mastra/opensearch 0.10.4-alpha.0 → 0.10.4-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/opensearch@0.10.4-alpha.0 build /home/runner/work/mastra/mastra/stores/opensearch
+> @mastra/opensearch@0.10.4-alpha.1 build /home/runner/work/mastra/mastra/stores/opensearch
 > 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 9284ms
+TSC ⚡️ Build success in 11957ms
 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/opensearch/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/opensearch/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 10960ms
+DTS ⚡️ Build success in 11764ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 23.60 KB
-ESM ⚡️ Build success in 784ms
-CJS dist/index.cjs 23.81 KB
-CJS ⚡️ Build success in 784ms
+CJS dist/index.cjs 23.79 KB
+CJS ⚡️ Build success in 807ms
+ESM dist/index.js 23.58 KB
+ESM ⚡️ Build success in 814ms

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/opensearch
 
+## 0.10.4-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.4-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';
 import type { DeleteIndexParams } from '@mastra/core';
 import type { DeleteVectorParams } from '@mastra/core';
 import type { DescribeIndexParams } from '@mastra/core';
 import type { IndexStats } from '@mastra/core';
+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';
 import type { QueryVectorParams } from '@mastra/core';
 import type { UpdateVectorParams } from '@mastra/core';
@@ -18,14 +21,16 @@ import type { VectorFilter } from '@mastra/core/vector/filter';
  */
 export declare const OPENSEARCH_PROMPT = "When querying OpenSearch, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Do not explain how to construct the filter\u2014use the specified operators and fields to search the content and return relevant results.\nIf a user tries to use an unsupported operator, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default for field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n\nLogical Operators:\n- $and: Logical AND (implicit when using multiple conditions)\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nRegex Operator:\n- $regex: Match using a regular expression (ECMAScript syntax)\n  Example: { \"name\": { \"$regex\": \"^Sam.*son$\" } }\n  Note: Regex queries are supported for string fields only. Use valid ECMAScript patterns; invalid patterns will throw an error.\n\nRestrictions:\n- Nested fields are supported using dot notation (e.g., \"address.city\").\n- Multiple conditions on the same field are supported (e.g., { \"price\": { \"$gte\": 100, \"$lte\": 1000 } }).\n- Only logical operators ($and, $or, $not) can be used at the top level.\n- All other operators must be used within a field condition.\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n- Logical operators must contain field conditions, not direct operators.\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Array operators work on array fields only.\n- Empty arrays in conditions are handled gracefully.\n- Regex queries are case-sensitive by default; use patterns accordingly.\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\"] } },\n    { \"rating\": { \"$exists\": true, \"$gt\": 4 } },\n    { \"$or\": [\n      { \"stock\": { \"$gt\": 0 } },\n      { \"preorder\": true }\n    ]},\n    { \"name\": { \"$regex\": \"^Sam.*son$\" } }\n  ]\n}";
 
+declare type OpenSearchBlacklisted = BlacklistedRootOperators | '$nor';
+
 /**
  * Translator for OpenSearch filter queries.
  * Maintains OpenSearch-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export declare class OpenSearchFilterTranslator extends BaseFilterTranslator {
+export declare class OpenSearchFilterTranslator extends BaseFilterTranslator<OpenSearchVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: OpenSearchVectorFilter): OpenSearchVectorFilter;
     private translateNode;
     /**
      * Handles translation of nested objects with dot notation fields
@@ -58,7 +63,11 @@ export declare class OpenSearchFilterTranslator extends BaseFilterTranslator {
     private createRangeQuery;
 }
 
-declare class OpenSearchVector extends MastraVector {
+declare type OpenSearchLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+declare type OpenSearchOperatorValueMap = Omit<OperatorValueMap, '$options' | '$nor' | '$elemMatch'>;
+
+declare class OpenSearchVector extends MastraVector<OpenSearchVectorFilter> {
     private client;
     /**
      * Creates a new OpenSearchVector client.
@@ -117,7 +126,7 @@ declare class OpenSearchVector 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, filter, topK, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
+    query({ indexName, queryVector, filter, topK, includeVector, }: OpenSearchVectorParams): Promise<QueryResult[]>;
     /**
      * Validates the dimensions of the vectors.
      *
@@ -129,7 +138,7 @@ declare class OpenSearchVector extends MastraVector {
     /**
      * Transforms the filter to the OpenSearch DSL.
      *
-     * @param {VectorFilter} filter - The filter to transform.
+     * @param {OpenSearchVectorFilter} filter - The filter to transform.
      * @returns {Record<string, any>} The transformed filter.
      */
     private transformFilter;
@@ -156,4 +165,8 @@ declare class OpenSearchVector extends MastraVector {
 export { OpenSearchVector }
 export { OpenSearchVector as OpenSearchVector_alias_1 }
 
+export declare type OpenSearchVectorFilter = VectorFilter<keyof OpenSearchOperatorValueMap, OpenSearchOperatorValueMap, OpenSearchLogicalOperatorValueMap, OpenSearchBlacklisted>;
+
+declare type OpenSearchVectorParams = QueryVectorParams<OpenSearchVectorFilter>;
+
 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';
 import type { DeleteIndexParams } from '@mastra/core';
 import type { DeleteVectorParams } from '@mastra/core';
 import type { DescribeIndexParams } from '@mastra/core';
 import type { IndexStats } from '@mastra/core';
+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';
 import type { QueryVectorParams } from '@mastra/core';
 import type { UpdateVectorParams } from '@mastra/core';
@@ -18,14 +21,16 @@ import type { VectorFilter } from '@mastra/core/vector/filter';
  */
 export declare const OPENSEARCH_PROMPT = "When querying OpenSearch, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Do not explain how to construct the filter\u2014use the specified operators and fields to search the content and return relevant results.\nIf a user tries to use an unsupported operator, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default for field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n\nLogical Operators:\n- $and: Logical AND (implicit when using multiple conditions)\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nRegex Operator:\n- $regex: Match using a regular expression (ECMAScript syntax)\n  Example: { \"name\": { \"$regex\": \"^Sam.*son$\" } }\n  Note: Regex queries are supported for string fields only. Use valid ECMAScript patterns; invalid patterns will throw an error.\n\nRestrictions:\n- Nested fields are supported using dot notation (e.g., \"address.city\").\n- Multiple conditions on the same field are supported (e.g., { \"price\": { \"$gte\": 100, \"$lte\": 1000 } }).\n- Only logical operators ($and, $or, $not) can be used at the top level.\n- All other operators must be used within a field condition.\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n- Logical operators must contain field conditions, not direct operators.\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Array operators work on array fields only.\n- Empty arrays in conditions are handled gracefully.\n- Regex queries are case-sensitive by default; use patterns accordingly.\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\"] } },\n    { \"rating\": { \"$exists\": true, \"$gt\": 4 } },\n    { \"$or\": [\n      { \"stock\": { \"$gt\": 0 } },\n      { \"preorder\": true }\n    ]},\n    { \"name\": { \"$regex\": \"^Sam.*son$\" } }\n  ]\n}";
 
+declare type OpenSearchBlacklisted = BlacklistedRootOperators | '$nor';
+
 /**
  * Translator for OpenSearch filter queries.
  * Maintains OpenSearch-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export declare class OpenSearchFilterTranslator extends BaseFilterTranslator {
+export declare class OpenSearchFilterTranslator extends BaseFilterTranslator<OpenSearchVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: OpenSearchVectorFilter): OpenSearchVectorFilter;
     private translateNode;
     /**
      * Handles translation of nested objects with dot notation fields
@@ -58,7 +63,11 @@ export declare class OpenSearchFilterTranslator extends BaseFilterTranslator {
     private createRangeQuery;
 }
 
-declare class OpenSearchVector extends MastraVector {
+declare type OpenSearchLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+declare type OpenSearchOperatorValueMap = Omit<OperatorValueMap, '$options' | '$nor' | '$elemMatch'>;
+
+declare class OpenSearchVector extends MastraVector<OpenSearchVectorFilter> {
     private client;
     /**
      * Creates a new OpenSearchVector client.
@@ -117,7 +126,7 @@ declare class OpenSearchVector 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, filter, topK, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
+    query({ indexName, queryVector, filter, topK, includeVector, }: OpenSearchVectorParams): Promise<QueryResult[]>;
     /**
      * Validates the dimensions of the vectors.
      *
@@ -129,7 +138,7 @@ declare class OpenSearchVector extends MastraVector {
     /**
      * Transforms the filter to the OpenSearch DSL.
      *
-     * @param {VectorFilter} filter - The filter to transform.
+     * @param {OpenSearchVectorFilter} filter - The filter to transform.
      * @returns {Record<string, any>} The transformed filter.
      */
     private transformFilter;
@@ -156,4 +165,8 @@ declare class OpenSearchVector extends MastraVector {
 export { OpenSearchVector }
 export { OpenSearchVector as OpenSearchVector_alias_1 }
 
+export declare type OpenSearchVectorFilter = VectorFilter<keyof OpenSearchOperatorValueMap, OpenSearchOperatorValueMap, OpenSearchLogicalOperatorValueMap, OpenSearchBlacklisted>;
+
+declare type OpenSearchVectorParams = QueryVectorParams<OpenSearchVectorFilter>;
+
 export { }

package/dist/index.cjs

@@ -12,7 +12,6 @@ var OpenSearchFilterTranslator = class extends filter.BaseFilterTranslator {
       ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
       logical: ["$and", "$or", "$not"],
       array: ["$in", "$nin", "$all"],
-      element: ["$exists"],
       regex: ["$regex"],
       custom: []
     };
@@ -608,7 +607,7 @@ var OpenSearchVector = class extends vector.MastraVector {
   /**
    * Transforms the filter to the OpenSearch DSL.
    *
-   * @param {VectorFilter} filter - The filter to transform.
+   * @param {OpenSearchVectorFilter} filter - The filter to transform.
    * @returns {Record<string, any>} The transformed filter.
    */
   transformFilter(filter) {

package/dist/index.js

@@ -10,7 +10,6 @@ var OpenSearchFilterTranslator = class extends BaseFilterTranslator {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
       logical: ["$and", "$or", "$not"],
       array: ["$in", "$nin", "$all"],
-      element: ["$exists"],
       regex: ["$regex"],
       custom: []
     };
@@ -606,7 +605,7 @@ var OpenSearchVector = class extends MastraVector {
   /**
    * Transforms the filter to the OpenSearch DSL.
    *
-   * @param {VectorFilter} filter - The filter to transform.
+   * @param {OpenSearchVectorFilter} filter - The filter to transform.
    * @returns {Record<string, any>} The transformed filter.
    */
   transformFilter(filter) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/opensearch",
-  "version": "0.10.4-alpha.0",
+  "version": "0.10.4-alpha.1",
   "description": "OpenSearch vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -24,12 +24,12 @@
   "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.2"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 
+import type { OpenSearchVectorFilter } from './filter';
 import { OpenSearchFilterTranslator } from './filter';
 
 describe('OpenSearchFilterTranslator', () => {
@@ -13,19 +14,19 @@ describe('OpenSearchFilterTranslator', () => {
   describe('basic operations', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual(undefined);
-      expect(translator.translate(null as any)).toEqual(undefined);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(undefined);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('translates simple field equality to term query', () => {
-      const filter = { field: 'value' };
+      const filter: OpenSearchVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field.keyword': 'value' },
       });
     });
 
     it('translates multiple top-level fields to bool must', () => {
-      const filter = { field1: 'value1', field2: 'value2' };
+      const filter: OpenSearchVectorFilter = { field1: 'value1', field2: 'value2' };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ term: { 'metadata.field1.keyword': 'value1' } }, { term: { 'metadata.field2.keyword': 'value2' } }],
@@ -62,14 +63,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Comparison Operators
   describe('comparison operators', () => {
     it('translates $eq operator', () => {
-      const filter = { field: { $eq: 'value' } };
+      const filter: OpenSearchVectorFilter = { field: { $eq: 'value' } };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field.keyword': 'value' },
       });
     });
 
     it('translates $ne operator', () => {
-      const filter = { field: { $ne: 'value' } };
+      const filter: OpenSearchVectorFilter = { field: { $ne: 'value' } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ term: { 'metadata.field.keyword': 'value' } }],
@@ -79,7 +80,7 @@ describe('OpenSearchFilterTranslator', () => {
 
     it('handles date values', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: OpenSearchVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.timestamp': { gt: date.toISOString() } },
       });
@@ -89,7 +90,7 @@ describe('OpenSearchFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('translates $and operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [{ field1: 'value1' }, { field2: 'value2' }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -100,7 +101,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $or operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $or: [{ field1: 'value1' }, { field2: 'value2' }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -114,7 +115,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $not: { field: 'value' },
       };
       expect(translator.translate(filter)).toEqual({
@@ -125,7 +126,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with $eq operator', () => {
-      const filter = { field: { $not: { $eq: 'value' } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $eq: 'value' } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ term: { 'metadata.field.keyword': 'value' } }],
@@ -134,7 +135,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with $ne operator', () => {
-      const filter = { field: { $not: { $ne: 'value' } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $ne: 'value' } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -149,14 +150,14 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with $eq null', () => {
-      const filter = { field: { $not: { $eq: null } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $eq: null } } };
       expect(translator.translate(filter)).toEqual({
         exists: { field: 'metadata.field' },
       });
     });
 
     it('translates $not with $ne null', () => {
-      const filter = { field: { $not: { $ne: null } } };
+      const filter: OpenSearchVectorFilter = { field: { $not: { $ne: null } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ exists: { field: 'metadata.field' } }],
@@ -165,7 +166,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with nested fields', () => {
-      const filter = { 'user.profile.age': { $not: { $gt: 25 } } };
+      const filter: OpenSearchVectorFilter = { 'user.profile.age': { $not: { $gt: 25 } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -178,7 +179,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $not with multiple operators', () => {
-      const filter = { price: { $not: { $gte: 30, $lte: 70 } } };
+      const filter: OpenSearchVectorFilter = { price: { $not: { $gte: 30, $lte: 70 } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -191,7 +192,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $and array', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [],
       };
       // Empty $and should match everything
@@ -199,7 +200,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $or array', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $or: [],
       };
       // Empty $or should match nothing
@@ -218,7 +219,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with comparison operators', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         price: { $not: { $gt: 100 } },
       };
       expect(translator.translate(filter)).toEqual({
@@ -229,7 +230,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles nested $not with $or', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $not: { $or: [{ category: 'electronics' }, { category: 'books' }] },
       };
       expect(translator.translate(filter)).toEqual({
@@ -249,7 +250,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with $not operator', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $not: { $not: { category: 'electronics' } },
       };
       expect(translator.translate(filter)).toEqual({
@@ -266,7 +267,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [
           { field1: 'value1' },
           {
@@ -295,14 +296,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Array Operators
   describe('array operators', () => {
     it('translates $in operator', () => {
-      const filter = { field: { $in: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field.keyword': ['value1', 'value2'] },
       });
     });
 
     it('translates $nin operator', () => {
-      const filter = { field: { $nin: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $nin: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ terms: { 'metadata.field.keyword': ['value1', 'value2'] } }],
@@ -311,7 +312,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates $all operator', () => {
-      const filter = { field: { $all: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $all: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ term: { 'metadata.field.keyword': 'value1' } }, { term: { 'metadata.field.keyword': 'value2' } }],
@@ -320,7 +321,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $in array', () => {
-      const filter = { field: { $in: [] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: [] } };
       // Empty $in should match nothing (empty terms)
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field.keyword': [] },
@@ -328,7 +329,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $nin array', () => {
-      const filter = { field: { $nin: [] } };
+      const filter: OpenSearchVectorFilter = { field: { $nin: [] } };
       // Empty $nin should match everything
       expect(translator.translate(filter)).toEqual({
         match_all: {},
@@ -336,7 +337,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles empty $all array', () => {
-      const filter = { field: { $all: [] } };
+      const filter: OpenSearchVectorFilter = { field: { $all: [] } };
       // Empty $all should match nothing
       expect(translator.translate(filter)).toEqual({
         bool: {
@@ -346,7 +347,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with array operators', () => {
-      const filter = { tags: { $not: { $in: ['premium', 'new'] } } };
+      const filter: OpenSearchVectorFilter = { tags: { $not: { $in: ['premium', 'new'] } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -359,7 +360,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with empty array operators', () => {
-      const filter = { tags: { $not: { $in: [] } } };
+      const filter: OpenSearchVectorFilter = { tags: { $not: { $in: [] } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -375,14 +376,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Element Operators
   describe('element operators', () => {
     it('translates $exists operator', () => {
-      const filter = { field: { $exists: true } };
+      const filter: OpenSearchVectorFilter = { field: { $exists: true } };
       expect(translator.translate(filter)).toEqual({
         exists: { field: 'metadata.field' },
       });
     });
 
     it('translates $exists operator with false', () => {
-      const filter = { field: { $exists: false } };
+      const filter: OpenSearchVectorFilter = { field: { $exists: false } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [{ exists: { field: 'metadata.field' } }],
@@ -394,14 +395,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Regex Operators
   describe('regex operators', () => {
     it('translates $regex operator', () => {
-      const filter = { field: { $regex: 'pattern' } };
+      const filter: OpenSearchVectorFilter = { field: { $regex: 'pattern' } };
       expect(translator.translate(filter)).toEqual({
         regexp: { 'metadata.field': 'pattern' },
       });
     });
 
     it('handles $regex with start anchor', () => {
-      const filter = { category: { $regex: '^elect' } };
+      const filter: OpenSearchVectorFilter = { category: { $regex: '^elect' } };
       // Should use wildcard for better anchor handling
       expect(translator.translate(filter)).toEqual({
         wildcard: { 'metadata.category': 'elect*' },
@@ -409,7 +410,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $regex with end anchor', () => {
-      const filter = { category: { $regex: 'nics$' } };
+      const filter: OpenSearchVectorFilter = { category: { $regex: 'nics$' } };
       // Should use wildcard for better anchor handling
       expect(translator.translate(filter)).toEqual({
         wildcard: { 'metadata.category': '*nics' },
@@ -417,7 +418,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $regex with both anchors', () => {
-      const filter = { category: { $regex: '^electronics$' } };
+      const filter: OpenSearchVectorFilter = { category: { $regex: '^electronics$' } };
       // Should use exact match for both anchors
       expect(translator.translate(filter)).toEqual({
         wildcard: { 'metadata.category': 'electronics' },
@@ -425,7 +426,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles $not with $regex operator', () => {
-      const filter = { category: { $not: { $regex: '^elect' } } };
+      const filter: OpenSearchVectorFilter = { category: { $not: { $regex: '^elect' } } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must_not: [
@@ -441,14 +442,14 @@ describe('OpenSearchFilterTranslator', () => {
   // Complex Queries
   describe('complex queries', () => {
     it('translates numeric operators', () => {
-      const filter = { price: { $gt: 70, $lte: 100 } };
+      const filter: OpenSearchVectorFilter = { price: { $gt: 70, $lte: 100 } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.price': { gt: 70, lte: 100 } },
       });
     });
 
     it('translates multiple range operators on the same field', () => {
-      const filter = { price: { $gte: 50, $lt: 200 } };
+      const filter: OpenSearchVectorFilter = { price: { $gte: 50, $lt: 200 } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.price': { gte: 50, lt: 200 } },
       });
@@ -456,14 +457,14 @@ describe('OpenSearchFilterTranslator', () => {
 
     it('translates all four range operators combined', () => {
       // This is an edge case that would never occur in practice, but tests the implementation
-      const filter = { value: { $gt: 10, $gte: 20, $lt: 100, $lte: 90 } };
+      const filter: OpenSearchVectorFilter = { value: { $gt: 10, $gte: 20, $lt: 100, $lte: 90 } };
       expect(translator.translate(filter)).toEqual({
         range: { 'metadata.value': { gt: 10, gte: 20, lt: 100, lte: 90 } },
       });
     });
 
     it('translates mixed numeric and non-numeric operators', () => {
-      const filter = { price: { $gt: 50, $exists: true } };
+      const filter: OpenSearchVectorFilter = { price: { $gt: 50, $exists: true } };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ range: { 'metadata.price': { gt: 50 } } }, { exists: { field: 'metadata.price' } }],
@@ -471,7 +472,7 @@ describe('OpenSearchFilterTranslator', () => {
       });
     });
     it('translates mixed operators', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [{ field1: { $gt: 10 } }, { field2: { $in: ['value1', 'value2'] } }, { field3: { $exists: true } }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -486,7 +487,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('translates complex nested queries', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [
           { status: 'active' },
           {
@@ -542,7 +543,7 @@ describe('OpenSearchFilterTranslator', () => {
 
     it('throws error for invalid array operator values', () => {
       const filter = { field: { $in: 'not-an-array' } };
-      expect(() => translator.translate(filter)).toThrow();
+      expect(() => translator.translate(filter as any)).toThrow();
     });
 
     it('throws error for nested invalid operators', () => {
@@ -553,7 +554,7 @@ describe('OpenSearchFilterTranslator', () => {
 
   describe('special values', () => {
     it('handles boolean values', () => {
-      const filter = { active: true, disabled: false };
+      const filter: OpenSearchVectorFilter = { active: true, disabled: false };
       expect(translator.translate(filter)).toEqual({
         bool: {
           must: [{ term: { 'metadata.active': true } }, { term: { 'metadata.disabled': false } }],
@@ -562,7 +563,7 @@ describe('OpenSearchFilterTranslator', () => {
     });
 
     it('handles null values', () => {
-      const filter = { field: null };
+      const filter: OpenSearchVectorFilter = { field: null };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field': null },
       });
@@ -571,21 +572,21 @@ describe('OpenSearchFilterTranslator', () => {
 
   describe('array handling', () => {
     it('translates array values to terms query', () => {
-      const filter = { tags: ['premium', 'new'] };
+      const filter: OpenSearchVectorFilter = { tags: ['premium', 'new'] };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.tags.keyword': ['premium', 'new'] },
       });
     });
 
     it('translates numeric array values to terms query', () => {
-      const filter = { scores: [90, 95, 100] };
+      const filter: OpenSearchVectorFilter = { scores: [90, 95, 100] };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.scores': [90, 95, 100] },
       });
     });
 
     it('translates empty array values to empty terms query', () => {
-      const filter = { tags: [] };
+      const filter: OpenSearchVectorFilter = { tags: [] };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.tags.keyword': [] },
       });
@@ -609,35 +610,35 @@ describe('OpenSearchFilterTranslator', () => {
 
   describe('field type handling', () => {
     it('adds .keyword suffix for string fields', () => {
-      const filter = { field: 'value' };
+      const filter: OpenSearchVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field.keyword': 'value' },
       });
     });
 
     it('adds .keyword suffix for string array fields', () => {
-      const filter = { field: { $in: ['value1', 'value2'] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: ['value1', 'value2'] } };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field.keyword': ['value1', 'value2'] },
       });
     });
 
     it('does not add .keyword suffix for numeric fields', () => {
-      const filter = { field: 123 };
+      const filter: OpenSearchVectorFilter = { field: 123 };
       expect(translator.translate(filter)).toEqual({
         term: { 'metadata.field': 123 },
       });
     });
 
     it('does not add .keyword suffix for numeric array fields', () => {
-      const filter = { field: { $in: [1, 2, 3] } };
+      const filter: OpenSearchVectorFilter = { field: { $in: [1, 2, 3] } };
       expect(translator.translate(filter)).toEqual({
         terms: { 'metadata.field': [1, 2, 3] },
       });
     });
 
     it('handles mixed field types in complex queries', () => {
-      const filter = {
+      const filter: OpenSearchVectorFilter = {
         $and: [
           { textField: 'value' },
           { numericField: 123 },

package/src/vector/filter.ts

@@ -1,30 +1,48 @@
-import type { FieldCondition, OperatorSupport, QueryOperator, VectorFilter } from '@mastra/core/vector/filter';
+import type {
+  BlacklistedRootOperators,
+  LogicalOperatorValueMap,
+  OperatorSupport,
+  OperatorValueMap,
+  QueryOperator,
+  VectorFilter,
+} from '@mastra/core/vector/filter';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
+type OpenSearchOperatorValueMap = Omit<OperatorValueMap, '$options' | '$nor' | '$elemMatch'>;
+
+type OpenSearchLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor'>;
+
+type OpenSearchBlacklisted = BlacklistedRootOperators | '$nor';
+
+export type OpenSearchVectorFilter = VectorFilter<
+  keyof OpenSearchOperatorValueMap,
+  OpenSearchOperatorValueMap,
+  OpenSearchLogicalOperatorValueMap,
+  OpenSearchBlacklisted
+>;
 /**
  * Translator for OpenSearch filter queries.
  * Maintains OpenSearch-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class OpenSearchFilterTranslator extends BaseFilterTranslator {
+export class OpenSearchFilterTranslator extends BaseFilterTranslator<OpenSearchVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
       logical: ['$and', '$or', '$not'],
       array: ['$in', '$nin', '$all'],
-      element: ['$exists'],
       regex: ['$regex'],
       custom: [],
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: OpenSearchVectorFilter): OpenSearchVectorFilter {
     if (this.isEmpty(filter)) return undefined;
     this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition): any {
+  private translateNode(node: OpenSearchVectorFilter): any {
     // Handle primitive values and arrays
     if (this.isPrimitive(node) || Array.isArray(node)) {
       return node;

package/src/vector/index.test.ts

@@ -1,5 +1,5 @@
 // To setup a Opensearch server, run the docker compose file in the opensearch directory
-import type { QueryResult, QueryVectorParams } from '@mastra/core';
+import type { QueryResult } from '@mastra/core';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { OpenSearchVector } from './index';
@@ -215,12 +215,11 @@ describe('OpenSearchVector', () => {
 
         await vectorDB.upsert({ indexName: testIndexName, vectors: testVectors, metadata: testMetadata });
 
-        const queryParams: QueryVectorParams = {
+        const results = await vectorDB.query({
           indexName: testIndexName,
           queryVector: [1.0, 0.1, 0.1],
           topK: 3,
-        };
-        const results = await vectorDB.query(queryParams);
+        });
 
         expect(results).toHaveLength(3);
         expect(results[0]?.score).toBeGreaterThan(0);
@@ -1197,7 +1196,7 @@ describe('OpenSearchVector', () => {
           vectorDB.query({
             indexName,
             queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
+            filter: { price: { $invalid: 100 } as any },
           }),
         ).rejects.toThrow('Unsupported operator: $invalid');
       });

package/src/vector/index.ts

@@ -11,9 +11,9 @@ import type {
 } from '@mastra/core';
 import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { Client as OpenSearchClient } from '@opensearch-project/opensearch';
 import { OpenSearchFilterTranslator } from './filter';
+import type { OpenSearchVectorFilter } from './filter';
 
 const METRIC_MAPPING = {
   cosine: 'cosinesimil',
@@ -27,7 +27,9 @@ const REVERSE_METRIC_MAPPING = {
   innerproduct: 'dotproduct',
 } as const;
 
-export class OpenSearchVector extends MastraVector {
+type OpenSearchVectorParams = QueryVectorParams<OpenSearchVectorFilter>;
+
+export class OpenSearchVector extends MastraVector<OpenSearchVectorFilter> {
   private client: OpenSearchClient;
 
   /**
@@ -243,7 +245,7 @@ export class OpenSearchVector extends MastraVector {
     filter,
     topK = 10,
     includeVector = false,
-  }: QueryVectorParams): Promise<QueryResult[]> {
+  }: OpenSearchVectorParams): Promise<QueryResult[]> {
     try {
       const translatedFilter = this.transformFilter(filter);
 
@@ -300,10 +302,10 @@ export class OpenSearchVector extends MastraVector {
   /**
    * Transforms the filter to the OpenSearch DSL.
    *
-   * @param {VectorFilter} filter - The filter to transform.
+   * @param {OpenSearchVectorFilter} filter - The filter to transform.
    * @returns {Record<string, any>} The transformed filter.
    */
-  private transformFilter(filter?: VectorFilter) {
+  private transformFilter(filter?: OpenSearchVectorFilter): any {
     const translator = new OpenSearchFilterTranslator();
     return translator.translate(filter);
   }