@mastra/convex 1.0.11 → 1.1.0

package/dist/index.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-var chunkC6QDNSBM_cjs = require('./chunk-C6QDNSBM.cjs');
-var chunkFTVDAP6U_cjs = require('./chunk-FTVDAP6U.cjs');
+var chunkEEELVBWO_cjs = require('./chunk-EEELVBWO.cjs');
+var chunkCV23JOCS_cjs = require('./chunk-CV23JOCS.cjs');
+var cache = require('@mastra/core/cache');
 var storage = require('@mastra/core/storage');
 var crypto = require('crypto');
 var base = require('@mastra/core/base');
@@ -13,6 +14,186 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 
+// src/cache/client.ts
+var DEFAULT_CACHE_FUNCTION = "mastra/cache:handle";
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var trimTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+var ConvexCacheClient = class {
+  deploymentUrl;
+  adminAuthToken;
+  cacheFunction;
+  requestTimeoutMs;
+  constructor({ deploymentUrl, adminAuthToken, cacheFunction, requestTimeoutMs }) {
+    const normalizedDeploymentUrl = deploymentUrl.trim();
+    const normalizedAdminAuthToken = adminAuthToken.trim();
+    const normalizedCacheFunction = cacheFunction?.trim();
+    if (!normalizedDeploymentUrl) {
+      throw new Error("ConvexCacheClient: deploymentUrl is required.");
+    }
+    if (!normalizedAdminAuthToken) {
+      throw new Error("ConvexCacheClient: adminAuthToken is required.");
+    }
+    if (requestTimeoutMs !== void 0 && requestTimeoutMs < 0) {
+      throw new Error("ConvexCacheClient: requestTimeoutMs must be greater than or equal to 0.");
+    }
+    this.deploymentUrl = trimTrailingSlashes(normalizedDeploymentUrl);
+    this.adminAuthToken = normalizedAdminAuthToken;
+    this.cacheFunction = normalizedCacheFunction || DEFAULT_CACHE_FUNCTION;
+    this.requestTimeoutMs = requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  async callCacheRaw(request) {
+    const controller = this.requestTimeoutMs > 0 ? new AbortController() : void 0;
+    const timeoutId = controller ? setTimeout(() => controller.abort(), this.requestTimeoutMs) : void 0;
+    let response;
+    try {
+      response = await fetch(`${this.deploymentUrl}/api/mutation`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Convex ${this.adminAuthToken}`
+        },
+        body: JSON.stringify({
+          path: this.cacheFunction,
+          args: request,
+          format: "json"
+        }),
+        signal: controller?.signal
+      });
+    } catch (error) {
+      if (controller?.signal.aborted) {
+        throw new Error(`Convex cache request timed out after ${this.requestTimeoutMs} ms.`);
+      }
+      throw error;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Convex API error: ${response.status} ${text}`);
+    }
+    const result = await response.json();
+    if (result.status === "error") {
+      const error = new Error(result.errorMessage || "Unknown Convex error");
+      error.code = result.errorCode ?? result.code;
+      error.details = result.details;
+      throw error;
+    }
+    const cacheResponse = result.value;
+    if (!cacheResponse?.ok) {
+      const errResponse = cacheResponse;
+      const error = new Error(errResponse?.error || "Unknown Convex cache error");
+      error.code = errResponse?.code;
+      error.details = errResponse?.details;
+      throw error;
+    }
+    return {
+      result: cacheResponse.result,
+      hasMore: cacheResponse.hasMore
+    };
+  }
+  async callCache(request) {
+    const { result } = await this.callCacheRaw(request);
+    return result;
+  }
+};
+
+// src/cache/index.ts
+var DEFAULT_KEY_PREFIX = "mastra:cache:";
+var DEFAULT_TTL_MS = 3e5;
+var MAX_CACHE_OPERATION_BATCHES = 1e3;
+var isClientConfig = (config) => "client" in config;
+var ConvexServerCache = class extends cache.MastraServerCache {
+  client;
+  keyPrefix;
+  ttlMs;
+  constructor(config) {
+    super({ name: "ConvexServerCache" });
+    this.client = isClientConfig(config) ? config.client : new ConvexCacheClient(config);
+    this.keyPrefix = config.keyPrefix ?? DEFAULT_KEY_PREFIX;
+    this.ttlMs = config.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  getKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  getExpiresAt(ttlMs) {
+    const effectiveTtlMs = ttlMs ?? this.ttlMs;
+    return effectiveTtlMs > 0 ? Date.now() + effectiveTtlMs : null;
+  }
+  async callUntilSettled(request) {
+    for (let batch = 0; batch < MAX_CACHE_OPERATION_BATCHES; batch += 1) {
+      const response = await this.client.callCacheRaw({
+        ...request()
+      });
+      if (!response.hasMore) return response.result;
+    }
+    throw new Error(`ConvexServerCache operation exceeded ${MAX_CACHE_OPERATION_BATCHES} batches.`);
+  }
+  async get(key) {
+    return this.callUntilSettled(() => ({
+      op: "get",
+      key: this.getKey(key)
+    }));
+  }
+  async set(key, value, ttlMs) {
+    await this.callUntilSettled(() => ({
+      op: "set",
+      key: this.getKey(key),
+      keyPrefix: this.keyPrefix,
+      value,
+      expiresAt: this.getExpiresAt(ttlMs)
+    }));
+  }
+  async listLength(key) {
+    return this.callUntilSettled(() => ({
+      op: "listLength",
+      key: this.getKey(key)
+    }));
+  }
+  async listPush(key, value) {
+    await this.callUntilSettled(() => ({
+      op: "listPush",
+      key: this.getKey(key),
+      keyPrefix: this.keyPrefix,
+      value,
+      expiresAt: this.getExpiresAt()
+    }));
+  }
+  async listFromTo(key, from, to = -1) {
+    return this.callUntilSettled(() => ({
+      op: "listFromTo",
+      key: this.getKey(key),
+      from,
+      to
+    }));
+  }
+  async delete(key) {
+    await this.callUntilSettled(() => ({
+      op: "delete",
+      key: this.getKey(key)
+    }));
+  }
+  async clear() {
+    await this.callUntilSettled(() => ({
+      op: "clear",
+      keyPrefix: this.keyPrefix
+    }));
+  }
+  async increment(key) {
+    return this.callUntilSettled(() => ({
+      op: "increment",
+      key: this.getKey(key),
+      keyPrefix: this.keyPrefix,
+      expiresAt: this.getExpiresAt()
+    }));
+  }
+};
+
 // src/storage/client.ts
 var DEFAULT_STORAGE_FUNCTION = "mastra/storage:handle";
 var ConvexAdminClient = class {
@@ -35,7 +216,39 @@ var ConvexAdminClient = class {
    * Use this for operations that may need multiple calls (e.g., clearTable).
    */
   async callStorageRaw(request) {
-    const url = `${this.deploymentUrl}/api/mutation`;
+    const result = await this.callConvexFunction("mutation", this.storageFunction, request);
+    const storageResponse = result.value;
+    if (!storageResponse?.ok) {
+      const errResponse = storageResponse;
+      const error = new Error(errResponse?.error || "Unknown Convex storage error");
+      error.code = errResponse?.code;
+      error.details = errResponse?.details;
+      throw error;
+    }
+    return {
+      result: storageResponse.result,
+      hasMore: storageResponse.hasMore
+    };
+  }
+  async callStorage(request) {
+    const { result } = await this.callStorageRaw(request);
+    return result;
+  }
+  async callAction(path, args) {
+    return this.callFunction("action", path, args);
+  }
+  async callMutation(path, args) {
+    return this.callFunction("mutation", path, args);
+  }
+  async callQuery(path, args) {
+    return this.callFunction("query", path, args);
+  }
+  async callFunction(kind, path, args) {
+    const result = await this.callConvexFunction(kind, path, args);
+    return result.value;
+  }
+  async callConvexFunction(kind, path, args) {
+    const url = `${this.deploymentUrl}/api/${kind}`;
     const response = await fetch(url, {
       method: "POST",
       headers: {
@@ -43,8 +256,8 @@ var ConvexAdminClient = class {
         Authorization: `Convex ${this.adminAuthToken}`
       },
       body: JSON.stringify({
-        path: this.storageFunction,
-        args: request,
+        path,
+        args,
         format: "json"
       })
     });
@@ -55,24 +268,15 @@ var ConvexAdminClient = class {
     const result = await response.json();
     if (result.status === "error") {
       const error = new Error(result.errorMessage || "Unknown Convex error");
-      error.code = result.errorCode;
+      error.details = result.errorData;
       throw error;
     }
-    const storageResponse = result.value;
-    if (!storageResponse?.ok) {
-      const errResponse = storageResponse;
-      const error = new Error(errResponse?.error || "Unknown Convex storage error");
-      error.code = errResponse?.code;
-      error.details = errResponse?.details;
-      throw error;
+    if (result.status !== "success") {
+      throw new Error(`Convex ${kind} ${path} returned an invalid response`);
+    }
+    if (result.value === void 0) {
+      throw new Error(`Convex ${kind} ${path} returned no value`);
     }
-    return {
-      result: storageResponse.result,
-      hasMore: storageResponse.hasMore
-    };
-  }
-  async callStorage(request) {
-    const { result } = await this.callStorageRaw(request);
     return result;
   }
 };
@@ -87,6 +291,7 @@ var ConvexDB = class extends base.MastraBase {
     super({ name: "convex-db" });
     this.client = client;
   }
+  client;
   async hasColumn(_table, _column) {
     return true;
   }
@@ -1066,13 +1271,13 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
 };
 
 // src/storage/index.ts
-var isClientConfig = (config) => {
+var isClientConfig2 = (config) => {
   return "client" in config;
 };
 var ConvexStore = class extends storage.MastraCompositeStore {
   constructor(config) {
     super({ id: config.id, name: config.name ?? "ConvexStore", disableInit: config.disableInit });
-    const client = isClientConfig(config) ? config.client : new ConvexAdminClient(config);
+    const client = isClientConfig2(config) ? config.client : new ConvexAdminClient(config);
     const domainConfig = { client };
     const memory = new MemoryConvex(domainConfig);
     const workflows = new WorkflowsConvex(domainConfig);
@@ -1396,63 +1601,337 @@ function cosineSimilarity(a, b) {
   }
   return dot / (Math.sqrt(magA) * Math.sqrt(magB));
 }
+var DEFAULT_VECTOR_INDEX = "by_embedding";
+var DEFAULT_ID_FIELD = "id";
+var DEFAULT_ID_INDEX = "by_record_id";
+var DEFAULT_VECTOR_FIELD = "embedding";
+var DEFAULT_METADATA_FIELD = "metadata";
+var DEFAULT_NATIVE_ACTION = "mastra/nativeVector:query";
+var DEFAULT_NATIVE_QUERY = "mastra/nativeVector:read";
+var DEFAULT_NATIVE_MUTATION = "mastra/nativeVector:write";
+var MAX_CONVEX_VECTOR_RESULTS = 256;
+var NATIVE_VECTOR_UPSERT_BATCH_SIZE = 100;
+function isMetadataRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var ConvexNativeVector = class extends vector.MastraVector {
+  client;
+  indexes;
+  nativeVectorAction;
+  nativeVectorQuery;
+  nativeVectorMutation;
+  describeCountLimit;
+  constructor(config) {
+    super({ id: config.id });
+    this.client = new ConvexAdminClient(config);
+    this.indexes = Object.fromEntries(
+      Object.entries(config.indexes).map(([indexName, index]) => [
+        indexName,
+        {
+          tableName: index.tableName,
+          vectorIndexName: index.vectorIndexName ?? DEFAULT_VECTOR_INDEX,
+          dimension: index.dimension,
+          idField: index.idField ?? DEFAULT_ID_FIELD,
+          idIndexName: index.idIndexName ?? DEFAULT_ID_INDEX,
+          vectorField: index.vectorField ?? DEFAULT_VECTOR_FIELD,
+          metadataField: index.metadataField ?? DEFAULT_METADATA_FIELD,
+          filterFields: index.filterFields ?? []
+        }
+      ])
+    );
+    this.nativeVectorAction = config.nativeVectorAction ?? DEFAULT_NATIVE_ACTION;
+    this.nativeVectorQuery = config.nativeVectorQuery ?? DEFAULT_NATIVE_QUERY;
+    this.nativeVectorMutation = config.nativeVectorMutation ?? DEFAULT_NATIVE_MUTATION;
+    this.describeCountLimit = config.describeCountLimit ?? 1e4;
+  }
+  async createIndex({ indexName, dimension, metric = "cosine" }) {
+    const index = this.getIndex(indexName);
+    if (index.dimension !== dimension) {
+      throw new Error(
+        `ConvexNativeVector.createIndex: deployed Convex index "${indexName}" has ${index.dimension} dimensions, but ${dimension} were requested`
+      );
+    }
+    if (metric !== "cosine") {
+      throw new Error("ConvexNativeVector.createIndex: Convex native vector search currently supports cosine only");
+    }
+  }
+  async listIndexes() {
+    return Object.keys(this.indexes);
+  }
+  async describeIndex({ indexName }) {
+    const index = this.getIndex(indexName);
+    const result = await this.client.callQuery(this.nativeVectorQuery, {
+      op: "describe",
+      config: index,
+      countLimit: this.describeCountLimit
+    });
+    if (result.countIsLimited) {
+      this.logger.warn(
+        `ConvexNativeVector.describeIndex: count for "${indexName}" reached ${this.describeCountLimit}; reported count is capped.`
+      );
+    }
+    return {
+      dimension: index.dimension,
+      count: result.count,
+      metric: "cosine"
+    };
+  }
+  async upsert({ indexName, vectors, ids, metadata, deleteFilter }) {
+    if (deleteFilter) {
+      throw new Error("ConvexNativeVector.upsert: deleteFilter is not supported. Delete by IDs before upserting.");
+    }
+    const index = this.getIndex(indexName);
+    if (ids && ids.length !== vectors.length) {
+      throw new Error(
+        `ConvexNativeVector.upsert: ids length (${ids.length}) must match vectors length (${vectors.length})`
+      );
+    }
+    if (metadata && metadata.length !== vectors.length) {
+      throw new Error(
+        `ConvexNativeVector.upsert: metadata length (${metadata.length}) must match vectors length (${vectors.length})`
+      );
+    }
+    if (metadata && !metadata.every(isMetadataRecord)) {
+      throw new Error("ConvexNativeVector.upsert: metadata entries must be objects when provided");
+    }
+    const vectorIds = ids ?? vectors.map(() => crypto__default.default.randomUUID());
+    if (new Set(vectorIds).size !== vectorIds.length) {
+      throw new Error("ConvexNativeVector.upsert: ids must be unique");
+    }
+    for (let start = 0; start < vectors.length; start += NATIVE_VECTOR_UPSERT_BATCH_SIZE) {
+      const end = start + NATIVE_VECTOR_UPSERT_BATCH_SIZE;
+      await this.client.callMutation(this.nativeVectorMutation, {
+        op: "upsert",
+        config: index,
+        ids: vectorIds.slice(start, end),
+        vectors: vectors.slice(start, end),
+        ...metadata ? { metadata: metadata.slice(start, end) } : {}
+      });
+    }
+    return vectorIds;
+  }
+  async query({
+    indexName,
+    queryVector,
+    topK = 10,
+    includeVector = false,
+    filter
+  }) {
+    if (!queryVector) {
+      throw new error.MastraError({
+        id: storage.createVectorErrorId("CONVEX_NATIVE", "QUERY", "MISSING_VECTOR"),
+        text: "queryVector is required for Convex native vector queries.",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        details: { indexName }
+      });
+    }
+    if (!Number.isFinite(topK) || !Number.isInteger(topK) || topK < 1 || topK > MAX_CONVEX_VECTOR_RESULTS) {
+      throw new Error(`ConvexNativeVector.query: topK must be an integer between 1 and ${MAX_CONVEX_VECTOR_RESULTS}`);
+    }
+    const index = this.getIndex(indexName);
+    const nativeFilter = this.toNativeFilter(filter, index);
+    const searchResults = await this.client.callAction(this.nativeVectorAction, {
+      config: index,
+      vector: queryVector,
+      limit: topK,
+      ...nativeFilter ? { filter: nativeFilter } : {}
+    });
+    if (searchResults.length === 0) return [];
+    const docs = await this.client.callQuery(this.nativeVectorQuery, {
+      op: "getByConvexIds",
+      config: index,
+      ids: searchResults.map((result) => result.id),
+      includeVector
+    });
+    const scoresByConvexId = new Map(searchResults.map((result) => [result.id, result.score]));
+    return docs.flatMap((doc) => {
+      if (!doc?._id) return [];
+      return [
+        {
+          id: String(doc[index.idField]),
+          score: scoresByConvexId.get(String(doc._id)) ?? 0,
+          metadata: doc[index.metadataField],
+          ...includeVector ? { vector: doc[index.vectorField] } : {}
+        }
+      ];
+    });
+  }
+  async updateVector(params) {
+    if ("filter" in params && params.filter !== void 0) {
+      throw new Error("ConvexNativeVector.updateVector: filter-based updates are not supported. Update by ID instead.");
+    }
+    if (params.update.metadata !== void 0 && !isMetadataRecord(params.update.metadata)) {
+      throw new Error("ConvexNativeVector.updateVector: metadata must be an object when provided");
+    }
+    const index = this.getIndex(params.indexName);
+    await this.client.callMutation(this.nativeVectorMutation, {
+      op: "updateById",
+      config: index,
+      id: params.id,
+      vector: params.update.vector,
+      metadata: params.update.metadata
+    });
+  }
+  async deleteVector({ indexName, id }) {
+    const index = this.getIndex(indexName);
+    await this.client.callMutation(this.nativeVectorMutation, {
+      op: "deleteByIds",
+      config: index,
+      ids: [id]
+    });
+  }
+  async deleteVectors(params) {
+    if (params.filter !== void 0) {
+      throw new Error(
+        "ConvexNativeVector.deleteVectors: filter-based deletes are not supported. Delete by IDs instead."
+      );
+    }
+    if (!params.ids || params.ids.length === 0) {
+      throw new Error("ConvexNativeVector.deleteVectors: ids are required");
+    }
+    const index = this.getIndex(params.indexName);
+    await this.client.callMutation(this.nativeVectorMutation, {
+      op: "deleteByIds",
+      config: index,
+      ids: params.ids
+    });
+  }
+  async deleteIndex({ indexName }) {
+    this.getIndex(indexName);
+    throw new Error("ConvexNativeVector.deleteIndex: Convex native vector indexes are managed in convex/schema.ts.");
+  }
+  getIndex(indexName) {
+    const index = this.indexes[indexName];
+    if (!index) {
+      throw new Error(`ConvexNativeVector: index "${indexName}" is not configured`);
+    }
+    return index;
+  }
+  toNativeFilter(filter, index) {
+    if (!filter || Object.keys(filter).length === 0) return void 0;
+    if (this.isOrFilter(filter)) {
+      const clauses = filter.$or.map((branch) => this.toSingleClause(branch, index));
+      return { $or: clauses };
+    }
+    const fieldFilter = this.isMetadataFilter(filter) ? filter.metadata : filter;
+    return this.toSingleClause(fieldFilter, index);
+  }
+  toSingleClause(filter, index) {
+    const entries = Object.entries(filter).filter(([, value2]) => value2 !== void 0);
+    if (entries.length !== 1) {
+      throw new Error(
+        "ConvexNativeVector.query: native Convex filters support one equality field or $or of equality fields"
+      );
+    }
+    const [field, rawValue] = entries[0];
+    if (!index.filterFields.includes(field)) {
+      throw new Error(`ConvexNativeVector.query: field "${field}" is not configured as a Convex vector filter field`);
+    }
+    const value = typeof rawValue === "object" && rawValue !== null && "$eq" in rawValue ? rawValue.$eq : rawValue;
+    if (!["string", "number", "boolean"].includes(typeof value) && value !== null) {
+      throw new Error(
+        "ConvexNativeVector.query: native Convex filters support string, number, boolean, and null values"
+      );
+    }
+    return { field, value };
+  }
+  isOrFilter(filter) {
+    return Array.isArray(filter.$or);
+  }
+  isMetadataFilter(filter) {
+    const metadata = filter.metadata;
+    return typeof metadata === "object" && metadata !== null && !Array.isArray(metadata);
+  }
+};
 
+Object.defineProperty(exports, "mastraCache", {
+  enumerable: true,
+  get: function () { return chunkEEELVBWO_cjs.mastraCache; }
+});
+Object.defineProperty(exports, "mastraNativeVectorAction", {
+  enumerable: true,
+  get: function () { return chunkEEELVBWO_cjs.mastraNativeVectorAction; }
+});
+Object.defineProperty(exports, "mastraNativeVectorMutation", {
+  enumerable: true,
+  get: function () { return chunkEEELVBWO_cjs.mastraNativeVectorMutation; }
+});
+Object.defineProperty(exports, "mastraNativeVectorQuery", {
+  enumerable: true,
+  get: function () { return chunkEEELVBWO_cjs.mastraNativeVectorQuery; }
+});
 Object.defineProperty(exports, "mastraStorage", {
   enumerable: true,
-  get: function () { return chunkC6QDNSBM_cjs.mastraStorage; }
+  get: function () { return chunkEEELVBWO_cjs.mastraStorage; }
 });
 Object.defineProperty(exports, "TABLE_MESSAGES", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.TABLE_MESSAGES; }
+  get: function () { return chunkCV23JOCS_cjs.TABLE_MESSAGES; }
 });
 Object.defineProperty(exports, "TABLE_RESOURCES", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.TABLE_RESOURCES; }
+  get: function () { return chunkCV23JOCS_cjs.TABLE_RESOURCES; }
 });
 Object.defineProperty(exports, "TABLE_SCORERS", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.TABLE_SCORERS; }
+  get: function () { return chunkCV23JOCS_cjs.TABLE_SCORERS; }
 });
 Object.defineProperty(exports, "TABLE_THREADS", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.TABLE_THREADS; }
+  get: function () { return chunkCV23JOCS_cjs.TABLE_THREADS; }
 });
 Object.defineProperty(exports, "TABLE_WORKFLOW_SNAPSHOT", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.TABLE_WORKFLOW_SNAPSHOT; }
+  get: function () { return chunkCV23JOCS_cjs.TABLE_WORKFLOW_SNAPSHOT; }
+});
+Object.defineProperty(exports, "defineMastraNativeVectorTable", {
+  enumerable: true,
+  get: function () { return chunkCV23JOCS_cjs.defineMastraNativeVectorTable; }
+});
+Object.defineProperty(exports, "mastraCacheListItemsTable", {
+  enumerable: true,
+  get: function () { return chunkCV23JOCS_cjs.mastraCacheListItemsTable; }
+});
+Object.defineProperty(exports, "mastraCacheTable", {
+  enumerable: true,
+  get: function () { return chunkCV23JOCS_cjs.mastraCacheTable; }
 });
 Object.defineProperty(exports, "mastraDocumentsTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraDocumentsTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraDocumentsTable; }
 });
 Object.defineProperty(exports, "mastraMessagesTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraMessagesTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraMessagesTable; }
 });
 Object.defineProperty(exports, "mastraResourcesTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraResourcesTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraResourcesTable; }
 });
 Object.defineProperty(exports, "mastraScoresTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraScoresTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraScoresTable; }
 });
 Object.defineProperty(exports, "mastraThreadsTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraThreadsTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraThreadsTable; }
 });
 Object.defineProperty(exports, "mastraVectorIndexesTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraVectorIndexesTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraVectorIndexesTable; }
 });
 Object.defineProperty(exports, "mastraVectorsTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraVectorsTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraVectorsTable; }
 });
 Object.defineProperty(exports, "mastraWorkflowSnapshotsTable", {
   enumerable: true,
-  get: function () { return chunkFTVDAP6U_cjs.mastraWorkflowSnapshotsTable; }
+  get: function () { return chunkCV23JOCS_cjs.mastraWorkflowSnapshotsTable; }
 });
+exports.ConvexCacheClient = ConvexCacheClient;
+exports.ConvexNativeVector = ConvexNativeVector;
+exports.ConvexServerCache = ConvexServerCache;
 exports.ConvexStore = ConvexStore;
 exports.ConvexVector = ConvexVector;
 //# sourceMappingURL=index.cjs.map