@mastra/core 0.9.5-alpha.0 → 0.10.0

package/dist/vector/filter/index.cjs

@@ -1,10 +1,192 @@
 'use strict';
 
-var chunkYK3XJ52U_cjs = require('../../chunk-YK3XJ52U.cjs');
+// src/vector/filter/base.ts
+var BaseFilterTranslator = class _BaseFilterTranslator {
+  /**
+   * Operator type checks
+   */
+  isOperator(key) {
+    return key.startsWith("$");
+  }
+  static BASIC_OPERATORS = ["$eq", "$ne"];
+  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
+  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
+  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
+  static ELEMENT_OPERATORS = ["$exists"];
+  static REGEX_OPERATORS = ["$regex", "$options"];
+  static DEFAULT_OPERATORS = {
+    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
+    basic: _BaseFilterTranslator.BASIC_OPERATORS,
+    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
+    array: _BaseFilterTranslator.ARRAY_OPERATORS,
+    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
+    regex: _BaseFilterTranslator.REGEX_OPERATORS
+  };
+  isLogicalOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
+  }
+  isBasicOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
+  }
+  isNumericOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
+  }
+  isArrayOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
+  }
+  isElementOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
+  }
+  isRegexOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
+  }
+  isFieldOperator(key) {
+    return this.isOperator(key) && !this.isLogicalOperator(key);
+  }
+  isCustomOperator(key) {
+    const support = this.getSupportedOperators();
+    return support.custom?.includes(key) ?? false;
+  }
+  getSupportedOperators() {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS;
+  }
+  isValidOperator(key) {
+    const support = this.getSupportedOperators();
+    const allSupported = Object.values(support).flat();
+    return allSupported.includes(key);
+  }
+  /**
+   * Value normalization for comparison operators
+   */
+  normalizeComparisonValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "number" && Object.is(value, -0)) {
+      return 0;
+    }
+    return value;
+  }
+  /**
+   * Helper method to simulate $all operator using $and + $eq when needed.
+   * Some vector stores don't support $all natively.
+   */
+  simulateAllOperator(field, values) {
+    return {
+      $and: values.map((value) => ({
+        [field]: { $in: [this.normalizeComparisonValue(value)] }
+      }))
+    };
+  }
+  /**
+   * Utility functions for type checking
+   */
+  isPrimitive(value) {
+    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  isRegex(value) {
+    return value instanceof RegExp;
+  }
+  isEmpty(obj) {
+    return obj === null || obj === void 0 || typeof obj === "object" && Object.keys(obj).length === 0;
+  }
+  static ErrorMessages = {
+    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
+    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path) => `Logical operator ${op} cannot be used at field level: ${path}`,
+    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
+    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
+    INVALID_LOGICAL_OPERATOR_CONTENT: (path) => `Logical operators must contain field conditions, not direct operators: ${path}`,
+    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
+    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
+  };
+  /**
+   * Helper to handle array value normalization consistently
+   */
+  normalizeArrayValues(values) {
+    return values.map((value) => this.normalizeComparisonValue(value));
+  }
+  validateFilter(filter) {
+    const validation = this.validateFilterSupport(filter);
+    if (!validation.supported) {
+      throw new Error(validation.messages.join(", "));
+    }
+  }
+  /**
+   * Validates if a filter structure is supported by the specific vector DB
+   * and returns detailed validation information.
+   */
+  validateFilterSupport(node, path = "") {
+    const messages = [];
+    if (this.isPrimitive(node) || this.isEmpty(node)) {
+      return { supported: true, messages: [] };
+    }
+    if (Array.isArray(node)) {
+      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
+      const arrayMessages = arrayResults.flatMap((r) => r.messages);
+      return {
+        supported: arrayResults.every((r) => r.supported),
+        messages: arrayMessages
+      };
+    }
+    const nodeObj = node;
+    let isSupported = true;
+    for (const [key, value] of Object.entries(nodeObj)) {
+      const newPath = path ? `${path}.${key}` : key;
+      if (this.isOperator(key)) {
+        if (!this.isValidOperator(key)) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
+          continue;
+        }
+        if (!path && !this.isLogicalOperator(key)) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
+          continue;
+        }
+        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
+          continue;
+        }
+        if (this.isLogicalOperator(key)) {
+          if (key === "$not") {
+            if (Array.isArray(value) || typeof value !== "object") {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
+              continue;
+            }
+            if (this.isEmpty(value)) {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
+              continue;
+            }
+            continue;
+          }
+          if (path && !this.isLogicalOperator(path.split(".").pop())) {
+            isSupported = false;
+            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
+            continue;
+          }
+          if (Array.isArray(value)) {
+            const hasDirectOperators = value.some(
+              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
+            );
+            if (hasDirectOperators) {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
+              continue;
+            }
+          }
+        }
+      }
+      const nestedValidation = this.validateFilterSupport(value, newPath);
+      if (!nestedValidation.supported) {
+        isSupported = false;
+        messages.push(...nestedValidation.messages);
+      }
+    }
+    return { supported: isSupported, messages };
+  }
+};
 
-
-
-Object.defineProperty(exports, "BaseFilterTranslator", {
-  enumerable: true,
-  get: function () { return chunkYK3XJ52U_cjs.BaseFilterTranslator; }
-});
+exports.BaseFilterTranslator = BaseFilterTranslator;

package/dist/vector/filter/index.js

@@ -1 +1,190 @@
-export { BaseFilterTranslator } from '../../chunk-LGERQTJM.js';
+// src/vector/filter/base.ts
+var BaseFilterTranslator = class _BaseFilterTranslator {
+  /**
+   * Operator type checks
+   */
+  isOperator(key) {
+    return key.startsWith("$");
+  }
+  static BASIC_OPERATORS = ["$eq", "$ne"];
+  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
+  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
+  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
+  static ELEMENT_OPERATORS = ["$exists"];
+  static REGEX_OPERATORS = ["$regex", "$options"];
+  static DEFAULT_OPERATORS = {
+    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
+    basic: _BaseFilterTranslator.BASIC_OPERATORS,
+    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
+    array: _BaseFilterTranslator.ARRAY_OPERATORS,
+    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
+    regex: _BaseFilterTranslator.REGEX_OPERATORS
+  };
+  isLogicalOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
+  }
+  isBasicOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
+  }
+  isNumericOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
+  }
+  isArrayOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
+  }
+  isElementOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
+  }
+  isRegexOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
+  }
+  isFieldOperator(key) {
+    return this.isOperator(key) && !this.isLogicalOperator(key);
+  }
+  isCustomOperator(key) {
+    const support = this.getSupportedOperators();
+    return support.custom?.includes(key) ?? false;
+  }
+  getSupportedOperators() {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS;
+  }
+  isValidOperator(key) {
+    const support = this.getSupportedOperators();
+    const allSupported = Object.values(support).flat();
+    return allSupported.includes(key);
+  }
+  /**
+   * Value normalization for comparison operators
+   */
+  normalizeComparisonValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "number" && Object.is(value, -0)) {
+      return 0;
+    }
+    return value;
+  }
+  /**
+   * Helper method to simulate $all operator using $and + $eq when needed.
+   * Some vector stores don't support $all natively.
+   */
+  simulateAllOperator(field, values) {
+    return {
+      $and: values.map((value) => ({
+        [field]: { $in: [this.normalizeComparisonValue(value)] }
+      }))
+    };
+  }
+  /**
+   * Utility functions for type checking
+   */
+  isPrimitive(value) {
+    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  isRegex(value) {
+    return value instanceof RegExp;
+  }
+  isEmpty(obj) {
+    return obj === null || obj === void 0 || typeof obj === "object" && Object.keys(obj).length === 0;
+  }
+  static ErrorMessages = {
+    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
+    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path) => `Logical operator ${op} cannot be used at field level: ${path}`,
+    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
+    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
+    INVALID_LOGICAL_OPERATOR_CONTENT: (path) => `Logical operators must contain field conditions, not direct operators: ${path}`,
+    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
+    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
+  };
+  /**
+   * Helper to handle array value normalization consistently
+   */
+  normalizeArrayValues(values) {
+    return values.map((value) => this.normalizeComparisonValue(value));
+  }
+  validateFilter(filter) {
+    const validation = this.validateFilterSupport(filter);
+    if (!validation.supported) {
+      throw new Error(validation.messages.join(", "));
+    }
+  }
+  /**
+   * Validates if a filter structure is supported by the specific vector DB
+   * and returns detailed validation information.
+   */
+  validateFilterSupport(node, path = "") {
+    const messages = [];
+    if (this.isPrimitive(node) || this.isEmpty(node)) {
+      return { supported: true, messages: [] };
+    }
+    if (Array.isArray(node)) {
+      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
+      const arrayMessages = arrayResults.flatMap((r) => r.messages);
+      return {
+        supported: arrayResults.every((r) => r.supported),
+        messages: arrayMessages
+      };
+    }
+    const nodeObj = node;
+    let isSupported = true;
+    for (const [key, value] of Object.entries(nodeObj)) {
+      const newPath = path ? `${path}.${key}` : key;
+      if (this.isOperator(key)) {
+        if (!this.isValidOperator(key)) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
+          continue;
+        }
+        if (!path && !this.isLogicalOperator(key)) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
+          continue;
+        }
+        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
+          continue;
+        }
+        if (this.isLogicalOperator(key)) {
+          if (key === "$not") {
+            if (Array.isArray(value) || typeof value !== "object") {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
+              continue;
+            }
+            if (this.isEmpty(value)) {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
+              continue;
+            }
+            continue;
+          }
+          if (path && !this.isLogicalOperator(path.split(".").pop())) {
+            isSupported = false;
+            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
+            continue;
+          }
+          if (Array.isArray(value)) {
+            const hasDirectOperators = value.some(
+              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
+            );
+            if (hasDirectOperators) {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
+              continue;
+            }
+          }
+        }
+      }
+      const nestedValidation = this.validateFilterSupport(value, newPath);
+      if (!nestedValidation.supported) {
+        isSupported = false;
+        messages.push(...nestedValidation.messages);
+      }
+    }
+    return { supported: isSupported, messages };
+  }
+};
+
+export { BaseFilterTranslator };

package/dist/vector/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkNQE264UM_cjs = require('../chunk-NQE264UM.cjs');
+var chunkPIZM25KI_cjs = require('../chunk-PIZM25KI.cjs');
 
 
 
 Object.defineProperty(exports, "MastraVector", {
   enumerable: true,
-  get: function () { return chunkNQE264UM_cjs.MastraVector; }
+  get: function () { return chunkPIZM25KI_cjs.MastraVector; }
 });

package/dist/vector/index.d.cts

@@ -1,9 +1,8 @@
-import { M as MastraBase } from '../base-H7siSAfu.cjs';
+import { M as MastraBase } from '../base-aPYtPBT2.cjs';
 import { VectorFilter } from './filter/index.cjs';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.cjs';
+import '../logger-EhZkzZOr.cjs';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
 
 interface QueryResult {
@@ -29,13 +28,11 @@ interface UpsertVectorParams {
     metadata?: Record<string, any>[];
     ids?: string[];
 }
-type UpsertVectorArgs = [string, number[][], Record<string, any>[], string[]?];
 interface CreateIndexParams {
     indexName: string;
     dimension: number;
     metric?: 'cosine' | 'euclidean' | 'dotproduct';
 }
-type CreateIndexArgs = [string, number, 'cosine' | 'euclidean' | 'dotproduct'];
 interface QueryVectorParams {
     indexName: string;
     queryVector: number[];
@@ -43,15 +40,12 @@ interface QueryVectorParams {
     filter?: VectorFilter;
     includeVector?: boolean;
 }
-type QueryVectorArgs = [string, number[], number, VectorFilter?, boolean?];
 interface DescribeIndexParams {
     indexName: string;
 }
-type DescribeIndexArgs = [string];
 interface DeleteIndexParams {
     indexName: string;
 }
-type DeleteIndexArgs = [string];
 interface UpdateVectorParams {
     indexName: string;
     id: string;
@@ -60,31 +54,23 @@ interface UpdateVectorParams {
         metadata?: Record<string, any>;
     };
 }
-type UpdateVectorArgs = [string, string, {
-    vector?: number[];
-    metadata?: Record<string, any>;
-}];
 interface DeleteVectorParams {
     indexName: string;
     id: string;
 }
-type DeleteVectorArgs = [string, string];
-type ParamsToArgs<T> = [T] | (T extends QueryVectorParams ? QueryVectorArgs : never) | (T extends UpsertVectorParams ? UpsertVectorArgs : never) | (T extends CreateIndexParams ? CreateIndexArgs : never) | (T extends DescribeIndexParams ? DescribeIndexArgs : never) | (T extends DeleteIndexParams ? DeleteIndexArgs : never) | (T extends UpdateVectorParams ? UpdateVectorArgs : never) | (T extends DeleteVectorParams ? DeleteVectorArgs : never);
 
 declare abstract class MastraVector extends MastraBase {
     constructor();
     get indexSeparator(): string;
-    private readonly baseKeys;
-    protected normalizeArgs<T, E extends any[] = never>(method: string, [first, ...rest]: ParamsToArgs<T> | E, extendedKeys?: string[]): T;
-    abstract query<E extends QueryVectorArgs = QueryVectorArgs>(...args: ParamsToArgs<QueryVectorParams> | E): Promise<QueryResult[]>;
-    abstract upsert<E extends UpsertVectorArgs = UpsertVectorArgs>(...args: ParamsToArgs<UpsertVectorParams> | E): Promise<string[]>;
-    abstract createIndex<E extends CreateIndexArgs = CreateIndexArgs>(...args: ParamsToArgs<CreateIndexParams> | E): Promise<void>;
+    abstract query(params: QueryVectorParams): Promise<QueryResult[]>;
+    abstract upsert(params: UpsertVectorParams): Promise<string[]>;
+    abstract createIndex(params: CreateIndexParams): Promise<void>;
     abstract listIndexes(): Promise<string[]>;
-    abstract describeIndex(...args: ParamsToArgs<DescribeIndexParams>): Promise<IndexStats>;
-    abstract deleteIndex(...args: ParamsToArgs<DeleteIndexParams>): Promise<void>;
-    abstract updateVector(...args: ParamsToArgs<UpdateVectorParams>): Promise<void>;
-    abstract deleteVector(...args: ParamsToArgs<DeleteVectorParams>): Promise<void>;
+    abstract describeIndex(params: DescribeIndexParams): Promise<IndexStats>;
+    abstract deleteIndex(params: DeleteIndexParams): Promise<void>;
+    abstract updateVector(params: UpdateVectorParams): Promise<void>;
+    abstract deleteVector(params: DeleteVectorParams): Promise<void>;
     protected validateExistingIndex(indexName: string, dimension: number, metric: string): Promise<void>;
 }
 
-export { type CreateIndexArgs, type CreateIndexParams, type DeleteIndexArgs, type DeleteIndexParams, type DeleteVectorArgs, type DeleteVectorParams, type DescribeIndexArgs, type DescribeIndexParams, type IndexStats, MastraVector, type ParamsToArgs, type QueryResult, type QueryVectorArgs, type QueryVectorParams, type UpdateVectorArgs, type UpdateVectorParams, type UpsertVectorArgs, type UpsertVectorParams };
+export { type CreateIndexParams, type DeleteIndexParams, type DeleteVectorParams, type DescribeIndexParams, type IndexStats, MastraVector, type QueryResult, type QueryVectorParams, type UpdateVectorParams, type UpsertVectorParams };

package/dist/vector/index.d.ts

@@ -1,9 +1,8 @@
-import { M as MastraBase } from '../base-4Z34GQL8.js';
+import { M as MastraBase } from '../base-tc5kgDTD.js';
 import { VectorFilter } from './filter/index.js';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.js';
+import '../logger-EhZkzZOr.js';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
 
 interface QueryResult {
@@ -29,13 +28,11 @@ interface UpsertVectorParams {
     metadata?: Record<string, any>[];
     ids?: string[];
 }
-type UpsertVectorArgs = [string, number[][], Record<string, any>[], string[]?];
 interface CreateIndexParams {
     indexName: string;
     dimension: number;
     metric?: 'cosine' | 'euclidean' | 'dotproduct';
 }
-type CreateIndexArgs = [string, number, 'cosine' | 'euclidean' | 'dotproduct'];
 interface QueryVectorParams {
     indexName: string;
     queryVector: number[];
@@ -43,15 +40,12 @@ interface QueryVectorParams {
     filter?: VectorFilter;
     includeVector?: boolean;
 }
-type QueryVectorArgs = [string, number[], number, VectorFilter?, boolean?];
 interface DescribeIndexParams {
     indexName: string;
 }
-type DescribeIndexArgs = [string];
 interface DeleteIndexParams {
     indexName: string;
 }
-type DeleteIndexArgs = [string];
 interface UpdateVectorParams {
     indexName: string;
     id: string;
@@ -60,31 +54,23 @@ interface UpdateVectorParams {
         metadata?: Record<string, any>;
     };
 }
-type UpdateVectorArgs = [string, string, {
-    vector?: number[];
-    metadata?: Record<string, any>;
-}];
 interface DeleteVectorParams {
     indexName: string;
     id: string;
 }
-type DeleteVectorArgs = [string, string];
-type ParamsToArgs<T> = [T] | (T extends QueryVectorParams ? QueryVectorArgs : never) | (T extends UpsertVectorParams ? UpsertVectorArgs : never) | (T extends CreateIndexParams ? CreateIndexArgs : never) | (T extends DescribeIndexParams ? DescribeIndexArgs : never) | (T extends DeleteIndexParams ? DeleteIndexArgs : never) | (T extends UpdateVectorParams ? UpdateVectorArgs : never) | (T extends DeleteVectorParams ? DeleteVectorArgs : never);
 
 declare abstract class MastraVector extends MastraBase {
     constructor();
     get indexSeparator(): string;
-    private readonly baseKeys;
-    protected normalizeArgs<T, E extends any[] = never>(method: string, [first, ...rest]: ParamsToArgs<T> | E, extendedKeys?: string[]): T;
-    abstract query<E extends QueryVectorArgs = QueryVectorArgs>(...args: ParamsToArgs<QueryVectorParams> | E): Promise<QueryResult[]>;
-    abstract upsert<E extends UpsertVectorArgs = UpsertVectorArgs>(...args: ParamsToArgs<UpsertVectorParams> | E): Promise<string[]>;
-    abstract createIndex<E extends CreateIndexArgs = CreateIndexArgs>(...args: ParamsToArgs<CreateIndexParams> | E): Promise<void>;
+    abstract query(params: QueryVectorParams): Promise<QueryResult[]>;
+    abstract upsert(params: UpsertVectorParams): Promise<string[]>;
+    abstract createIndex(params: CreateIndexParams): Promise<void>;
     abstract listIndexes(): Promise<string[]>;
-    abstract describeIndex(...args: ParamsToArgs<DescribeIndexParams>): Promise<IndexStats>;
-    abstract deleteIndex(...args: ParamsToArgs<DeleteIndexParams>): Promise<void>;
-    abstract updateVector(...args: ParamsToArgs<UpdateVectorParams>): Promise<void>;
-    abstract deleteVector(...args: ParamsToArgs<DeleteVectorParams>): Promise<void>;
+    abstract describeIndex(params: DescribeIndexParams): Promise<IndexStats>;
+    abstract deleteIndex(params: DeleteIndexParams): Promise<void>;
+    abstract updateVector(params: UpdateVectorParams): Promise<void>;
+    abstract deleteVector(params: DeleteVectorParams): Promise<void>;
     protected validateExistingIndex(indexName: string, dimension: number, metric: string): Promise<void>;
 }
 
-export { type CreateIndexArgs, type CreateIndexParams, type DeleteIndexArgs, type DeleteIndexParams, type DeleteVectorArgs, type DeleteVectorParams, type DescribeIndexArgs, type DescribeIndexParams, type IndexStats, MastraVector, type ParamsToArgs, type QueryResult, type QueryVectorArgs, type QueryVectorParams, type UpdateVectorArgs, type UpdateVectorParams, type UpsertVectorArgs, type UpsertVectorParams };
+export { type CreateIndexParams, type DeleteIndexParams, type DeleteVectorParams, type DescribeIndexParams, type IndexStats, MastraVector, type QueryResult, type QueryVectorParams, type UpdateVectorParams, type UpsertVectorParams };

package/dist/vector/index.js

@@ -1 +1 @@
-export { MastraVector } from '../chunk-SU4O2A72.js';
+export { MastraVector } from '../chunk-LHRZV5VG.js';

package/dist/voice/index.cjs

@@ -1,18 +1,18 @@
 'use strict';
 
-var chunkS7J63JOG_cjs = require('../chunk-S7J63JOG.cjs');
+var chunkRVS6OUJN_cjs = require('../chunk-RVS6OUJN.cjs');
 
 
 
 Object.defineProperty(exports, "CompositeVoice", {
   enumerable: true,
-  get: function () { return chunkS7J63JOG_cjs.CompositeVoice; }
+  get: function () { return chunkRVS6OUJN_cjs.CompositeVoice; }
 });
 Object.defineProperty(exports, "DefaultVoice", {
   enumerable: true,
-  get: function () { return chunkS7J63JOG_cjs.DefaultVoice; }
+  get: function () { return chunkRVS6OUJN_cjs.DefaultVoice; }
 });
 Object.defineProperty(exports, "MastraVoice", {
   enumerable: true,
-  get: function () { return chunkS7J63JOG_cjs.MastraVoice; }
+  get: function () { return chunkRVS6OUJN_cjs.MastraVoice; }
 });

package/dist/voice/index.d.cts

@@ -1,26 +1,25 @@
-export { bw as CompositeVoice, bx as DefaultVoice, bv as MastraVoice, bu as VoiceConfig, bt as VoiceEventMap, bs as VoiceEventType } from '../base-BV8SNIdm.cjs';
+export { bm as CompositeVoice, bn as DefaultVoice, bl as MastraVoice, bk as VoiceConfig, bj as VoiceEventMap, bi as VoiceEventType } from '../base-aJ3etsh5.cjs';
 import 'ai';
-import '../base-H7siSAfu.cjs';
+import '../base-aPYtPBT2.cjs';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.cjs';
+import '../logger-EhZkzZOr.cjs';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
-import '../types-BtMyV38I.cjs';
+import '../types-Bo1uigWx.cjs';
 import 'sift';
 import 'zod';
 import 'json-schema';
-import '../runtime-context/index.cjs';
-import 'xstate';
-import 'node:events';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
 import 'node:http';
 import 'hono';
-import '../tts/index.cjs';
+import '../runtime-context/index.cjs';
 import '../vector/index.cjs';
 import '../vector/filter/index.cjs';
-import 'events';
-import '../deployer/index.cjs';
-import '../bundler/index.cjs';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.cjs';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';

package/dist/voice/index.d.ts

@@ -1,26 +1,25 @@
-export { bw as CompositeVoice, bx as DefaultVoice, bv as MastraVoice, bu as VoiceConfig, bt as VoiceEventMap, bs as VoiceEventType } from '../base-CI7Uz2GO.js';
+export { bm as CompositeVoice, bn as DefaultVoice, bl as MastraVoice, bk as VoiceConfig, bj as VoiceEventMap, bi as VoiceEventType } from '../base-DttB7sJD.js';
 import 'ai';
-import '../base-4Z34GQL8.js';
+import '../base-tc5kgDTD.js';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.js';
+import '../logger-EhZkzZOr.js';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
-import '../types-BtMyV38I.js';
+import '../types-Bo1uigWx.js';
 import 'sift';
 import 'zod';
 import 'json-schema';
-import '../runtime-context/index.js';
-import 'xstate';
-import 'node:events';
+import '../deployer/index.js';
+import '../bundler/index.js';
 import 'node:http';
 import 'hono';
-import '../tts/index.js';
+import '../runtime-context/index.js';
 import '../vector/index.js';
 import '../vector/filter/index.js';
-import 'events';
-import '../deployer/index.js';
-import '../bundler/index.js';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.js';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';