@mastra/convex 0.0.0-scorers-logs-20251208103858 → 0.0.0-standard-schema-20260123120255

package/dist/index.js

@@ -1,8 +1,10 @@
-export { TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, mastraDocumentsTable, mastraMessagesTable, mastraResourcesTable, mastraScoresTable, mastraStorage, mastraThreadsTable, mastraVectorIndexesTable, mastraVectorsTable, mastraWorkflowSnapshotsTable } from './chunk-NZCHEPNU.js';
-import { MastraStorage, StoreOperations, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, createStorageErrorId, TABLE_MESSAGES, normalizePerPage, calculatePagination, safelyParseJSON, TABLE_RESOURCES, WorkflowsStorage, ScoresStorage, TABLE_SCORERS } from '@mastra/core/storage';
+export { mastraStorage } from './chunk-KSAPIIEJ.js';
+export { TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, mastraDocumentsTable, mastraMessagesTable, mastraResourcesTable, mastraScoresTable, mastraThreadsTable, mastraVectorIndexesTable, mastraVectorsTable, mastraWorkflowSnapshotsTable } from './chunk-HXB4DWFE.js';
+import { MastraCompositeStore, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, safelyParseJSON, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS } from '@mastra/core/storage';
 import { MessageList } from '@mastra/core/agent';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import crypto from 'crypto';
+import { MastraBase } from '@mastra/core/base';
 import { MastraVector } from '@mastra/core/vector';
 
 // src/storage/client.ts
@@ -68,13 +70,127 @@ var ConvexAdminClient = class {
     return result;
   }
 };
+function resolveConvexConfig(config) {
+  if ("client" in config) {
+    return config.client;
+  }
+  return new ConvexAdminClient(config);
+}
+var ConvexDB = class extends MastraBase {
+  constructor(client) {
+    super({ name: "convex-db" });
+    this.client = client;
+  }
+  async hasColumn(_table, _column) {
+    return true;
+  }
+  async createTable({
+    tableName,
+    schema: _schema
+  }) {
+    this.logger.debug(`ConvexDB: createTable called for ${tableName} (schema managed server-side)`);
+  }
+  async alterTable({
+    tableName,
+    schema: _schema,
+    ifNotExists: _ifNotExists
+  }) {
+    this.logger.debug(`ConvexDB: alterTable called for ${tableName} (schema managed server-side)`);
+  }
+  async clearTable({ tableName }) {
+    let hasMore = true;
+    while (hasMore) {
+      const response = await this.client.callStorageRaw({
+        op: "clearTable",
+        tableName
+      });
+      hasMore = response.hasMore ?? false;
+    }
+  }
+  async dropTable({ tableName }) {
+    let hasMore = true;
+    while (hasMore) {
+      const response = await this.client.callStorageRaw({
+        op: "dropTable",
+        tableName
+      });
+      hasMore = response.hasMore ?? false;
+    }
+  }
+  async insert({ tableName, record }) {
+    await this.client.callStorage({
+      op: "insert",
+      tableName,
+      record: this.normalizeRecord(tableName, record)
+    });
+  }
+  async batchInsert({ tableName, records }) {
+    if (records.length === 0) return;
+    await this.client.callStorage({
+      op: "batchInsert",
+      tableName,
+      records: records.map((record) => this.normalizeRecord(tableName, record))
+    });
+  }
+  async load({ tableName, keys }) {
+    const result = await this.client.callStorage({
+      op: "load",
+      tableName,
+      keys
+    });
+    return result;
+  }
+  async queryTable(tableName, filters) {
+    return this.client.callStorage({
+      op: "queryTable",
+      tableName,
+      filters
+    });
+  }
+  async deleteMany(tableName, ids) {
+    if (ids.length === 0) return;
+    await this.client.callStorage({
+      op: "deleteMany",
+      tableName,
+      ids
+    });
+  }
+  normalizeRecord(tableName, record) {
+    const normalized = { ...record };
+    if (tableName === TABLE_WORKFLOW_SNAPSHOT && !normalized.id) {
+      const runId = normalized.run_id || normalized.runId;
+      const workflowName = normalized.workflow_name || normalized.workflowName;
+      normalized.id = workflowName ? `${workflowName}-${runId}` : runId;
+    }
+    if (!normalized.id) {
+      normalized.id = crypto.randomUUID();
+    }
+    for (const [key, value] of Object.entries(normalized)) {
+      if (value instanceof Date) {
+        normalized[key] = value.toISOString();
+      }
+    }
+    return normalized;
+  }
+};
+
+// src/storage/domains/memory/index.ts
 var MemoryConvex = class extends MemoryStorage {
-  constructor(operations) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    const client = resolveConvexConfig(config);
+    this.#db = new ConvexDB(client);
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_THREADS });
+    await this.#db.clearTable({ tableName: TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: TABLE_RESOURCES });
   }
   async getThreadById({ threadId }) {
-    const row = await this.operations.load({
+    const row = await this.#db.load({
       tableName: TABLE_THREADS,
       keys: { id: threadId }
     });
@@ -87,7 +203,7 @@ var MemoryConvex = class extends MemoryStorage {
     };
   }
   async saveThread({ thread }) {
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: TABLE_THREADS,
       record: {
         ...thread,
@@ -123,27 +239,50 @@ var MemoryConvex = class extends MemoryStorage {
     return updated;
   }
   async deleteThread({ threadId }) {
-    const messages = await this.operations.queryTable(TABLE_MESSAGES, [
+    const messages = await this.#db.queryTable(TABLE_MESSAGES, [
       { field: "thread_id", value: threadId }
     ]);
-    await this.operations.deleteMany(
+    await this.#db.deleteMany(
       TABLE_MESSAGES,
       messages.map((msg) => msg.id)
     );
-    await this.operations.deleteMany(TABLE_THREADS, [threadId]);
+    await this.#db.deleteMany(TABLE_THREADS, [threadId]);
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CONVEX", "LIST_THREADS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+        },
+        error instanceof Error ? error : new Error("Invalid pagination parameters")
+      );
+    }
     const perPage = normalizePerPage(perPageInput, 100);
     const { field, direction } = this.parseOrderBy(orderBy);
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
-    const rows = await this.operations.queryTable(TABLE_THREADS, [{ field: "resourceId", value: resourceId }]);
-    const threads = rows.map((row) => ({
+    const queryFilters = [];
+    if (filter?.resourceId) {
+      queryFilters.push({ field: "resourceId", value: filter.resourceId });
+    }
+    const rows = await this.#db.queryTable(TABLE_THREADS, queryFilters);
+    let threads = rows.map((row) => ({
       ...row,
       metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
       createdAt: new Date(row.createdAt),
       updatedAt: new Date(row.updatedAt)
     }));
+    if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+      threads = threads.filter((thread) => {
+        if (!thread.metadata) return false;
+        return Object.entries(filter.metadata).every(([key, value]) => thread.metadata[key] === value);
+      });
+    }
     threads.sort((a, b) => {
       const aValue = a[field];
       const bValue = b[field];
@@ -180,23 +319,13 @@ var MemoryConvex = class extends MemoryStorage {
     const { field, direction } = this.parseOrderBy(orderBy, "ASC");
     let rows = [];
     for (const tid of threadIds) {
-      const threadRows = await this.operations.queryTable(TABLE_MESSAGES, [
-        { field: "thread_id", value: tid }
-      ]);
+      const threadRows = await this.#db.queryTable(TABLE_MESSAGES, [{ field: "thread_id", value: tid }]);
       rows.push(...threadRows);
     }
     if (resourceId) {
       rows = rows.filter((row) => row.resourceId === resourceId);
     }
-    if (filter?.dateRange) {
-      const { start, end } = filter.dateRange;
-      rows = rows.filter((row) => {
-        const created = new Date(row.createdAt).getTime();
-        if (start && created < start.getTime()) return false;
-        if (end && created > end.getTime()) return false;
-        return true;
-      });
-    }
+    rows = filterByDateRange(rows, (row) => new Date(row.createdAt), filter?.dateRange);
     rows.sort((a, b) => {
       const aValue = field === "createdAt" || field === "updatedAt" ? new Date(a[field]).getTime() : a[field];
       const bValue = field === "createdAt" || field === "updatedAt" ? new Date(b[field]).getTime() : b[field];
@@ -226,14 +355,14 @@ var MemoryConvex = class extends MemoryStorage {
           }
         }
         if (!target) {
-          const messageRows = await this.operations.queryTable(TABLE_MESSAGES, [
+          const messageRows = await this.#db.queryTable(TABLE_MESSAGES, [
             { field: "id", value: includeItem.id }
           ]);
           if (messageRows.length > 0) {
             target = messageRows[0];
             targetThreadId = target.thread_id;
             if (targetThreadId && !threadMessagesCache.has(targetThreadId)) {
-              const otherThreadRows = await this.operations.queryTable(TABLE_MESSAGES, [
+              const otherThreadRows = await this.#db.queryTable(TABLE_MESSAGES, [
                 { field: "thread_id", value: targetThreadId }
               ]);
               threadMessagesCache.set(targetThreadId, otherThreadRows);
@@ -276,7 +405,7 @@ var MemoryConvex = class extends MemoryStorage {
     if (messageIds.length === 0) {
       return { messages: [] };
     }
-    const rows = await this.operations.queryTable(TABLE_MESSAGES, void 0);
+    const rows = await this.#db.queryTable(TABLE_MESSAGES, void 0);
     const filtered = rows.filter((row) => messageIds.includes(row.id)).map((row) => this.parseStoredMessage(row));
     const list = new MessageList().add(filtered, "memory");
     return { messages: list.get.all.db() };
@@ -301,7 +430,7 @@ var MemoryConvex = class extends MemoryStorage {
         resourceId: message.resourceId
       };
     });
-    await this.operations.batchInsert({
+    await this.#db.batchInsert({
       tableName: TABLE_MESSAGES,
       records: normalized
     });
@@ -310,7 +439,7 @@ var MemoryConvex = class extends MemoryStorage {
     for (const threadId of threadIds) {
       const thread = await this.getThreadById({ threadId });
       if (thread) {
-        await this.operations.insert({
+        await this.#db.insert({
           tableName: TABLE_THREADS,
           record: {
             ...thread,
@@ -329,7 +458,7 @@ var MemoryConvex = class extends MemoryStorage {
     messages
   }) {
     if (messages.length === 0) return [];
-    const existing = await this.operations.queryTable(TABLE_MESSAGES, void 0);
+    const existing = await this.#db.queryTable(TABLE_MESSAGES, void 0);
     const updated = [];
     const affectedThreadIds = /* @__PURE__ */ new Set();
     for (const update of messages) {
@@ -358,7 +487,7 @@ var MemoryConvex = class extends MemoryStorage {
         };
         current.content = JSON.stringify(mergedContent);
       }
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: TABLE_MESSAGES,
         record: current
       });
@@ -368,7 +497,7 @@ var MemoryConvex = class extends MemoryStorage {
     for (const threadId of affectedThreadIds) {
       const thread = await this.getThreadById({ threadId });
       if (thread) {
-        await this.operations.insert({
+        await this.#db.insert({
           tableName: TABLE_THREADS,
           record: {
             ...thread,
@@ -383,7 +512,7 @@ var MemoryConvex = class extends MemoryStorage {
     return updated;
   }
   async deleteMessages(messageIds) {
-    await this.operations.deleteMany(TABLE_MESSAGES, messageIds);
+    await this.#db.deleteMany(TABLE_MESSAGES, messageIds);
   }
   async saveResource({ resource }) {
     const record = {
@@ -394,14 +523,14 @@ var MemoryConvex = class extends MemoryStorage {
     if (resource.metadata !== void 0) {
       record.metadata = resource.metadata;
     }
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: TABLE_RESOURCES,
       record
     });
     return resource;
   }
   async getResourceById({ resourceId }) {
-    const record = await this.operations.load({
+    const record = await this.#db.load({
       tableName: TABLE_RESOURCES,
       keys: { id: resourceId }
     });
@@ -487,12 +616,19 @@ var MemoryConvex = class extends MemoryStorage {
   }
 };
 var ScoresConvex = class extends ScoresStorage {
-  constructor(operations) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    const client = resolveConvexConfig(config);
+    this.#db = new ConvexDB(client);
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_SCORERS });
   }
   async getScoreById({ id }) {
-    const row = await this.operations.load({
+    const row = await this.#db.load({
       tableName: TABLE_SCORERS,
       keys: { id }
     });
@@ -506,7 +642,7 @@ var ScoresConvex = class extends ScoresStorage {
       createdAt: now.toISOString(),
       updatedAt: now.toISOString()
     };
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: TABLE_SCORERS,
       record
     });
@@ -557,7 +693,7 @@ var ScoresConvex = class extends ScoresStorage {
         new Error("page must be >= 0")
       );
     }
-    const rows = await this.operations.queryTable(TABLE_SCORERS, void 0);
+    const rows = await this.#db.queryTable(TABLE_SCORERS, void 0);
     const filtered = rows.filter((row) => filters.scorerId ? row.scorerId === filters.scorerId : true).filter((row) => filters.entityId ? row.entityId === filters.entityId : true).filter((row) => filters.entityType ? row.entityType === filters.entityType : true).filter((row) => filters.runId ? row.runId === filters.runId : true).filter((row) => filters.source ? row.source === filters.source : true).sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
     const { perPage, page } = pagination;
     const perPageValue = perPage === false ? filtered.length : perPage;
@@ -583,9 +719,16 @@ var ScoresConvex = class extends ScoresStorage {
   }
 };
 var WorkflowsConvex = class extends WorkflowsStorage {
-  constructor(operations) {
+  #db;
+  constructor(config) {
     super();
-    this.operations = operations;
+    const client = resolveConvexConfig(config);
+    this.#db = new ConvexDB(client);
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
   }
   async updateWorkflowResults({
     workflowName,
@@ -632,11 +775,11 @@ var WorkflowsConvex = class extends WorkflowsStorage {
     snapshot
   }) {
     const now = /* @__PURE__ */ new Date();
-    const existing = await this.operations.load({
+    const existing = await this.#db.load({
       tableName: TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: TABLE_WORKFLOW_SNAPSHOT,
       record: {
         workflow_name: workflowName,
@@ -652,7 +795,7 @@ var WorkflowsConvex = class extends WorkflowsStorage {
     workflowName,
     runId
   }) {
-    const row = await this.operations.load({
+    const row = await this.#db.load({
       tableName: TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
@@ -661,7 +804,7 @@ var WorkflowsConvex = class extends WorkflowsStorage {
   }
   async listWorkflowRuns(args = {}) {
     const { workflowName, fromDate, toDate, perPage, page, resourceId, status } = args;
-    let rows = await this.operations.queryTable(TABLE_WORKFLOW_SNAPSHOT, void 0);
+    let rows = await this.#db.queryTable(TABLE_WORKFLOW_SNAPSHOT, void 0);
     if (workflowName) rows = rows.filter((run) => run.workflow_name === workflowName);
     if (resourceId) rows = rows.filter((run) => run.resourceId === resourceId);
     if (fromDate) rows = rows.filter((run) => new Date(run.createdAt).getTime() >= fromDate.getTime());
@@ -693,7 +836,7 @@ var WorkflowsConvex = class extends WorkflowsStorage {
     runId,
     workflowName
   }) {
-    const runs = await this.operations.queryTable(TABLE_WORKFLOW_SNAPSHOT, void 0);
+    const runs = await this.#db.queryTable(TABLE_WORKFLOW_SNAPSHOT, void 0);
     const match = runs.find((run) => run.run_id === runId && (!workflowName || run.workflow_name === workflowName));
     if (!match) return null;
     return {
@@ -705,8 +848,11 @@ var WorkflowsConvex = class extends WorkflowsStorage {
       resourceId: match.resourceId
     };
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    await this.#db.deleteMany(TABLE_WORKFLOW_SNAPSHOT, [`${workflowName}-${runId}`]);
+  }
   async getRun(workflowName, runId) {
-    const runs = await this.operations.queryTable(TABLE_WORKFLOW_SNAPSHOT, [
+    const runs = await this.#db.queryTable(TABLE_WORKFLOW_SNAPSHOT, [
       { field: "workflow_name", value: workflowName }
     ]);
     return runs.find((run) => run.run_id === runId) ?? null;
@@ -733,251 +879,25 @@ var WorkflowsConvex = class extends WorkflowsStorage {
     return JSON.parse(JSON.stringify(run.snapshot));
   }
 };
-var StoreOperationsConvex = class extends StoreOperations {
-  constructor(client) {
-    super();
-    this.client = client;
-  }
-  async hasColumn(_table, _column) {
-    return true;
-  }
-  async createTable(_args) {
-  }
-  async clearTable({ tableName }) {
-    let hasMore = true;
-    while (hasMore) {
-      const response = await this.client.callStorageRaw({
-        op: "clearTable",
-        tableName
-      });
-      hasMore = response.hasMore ?? false;
-    }
-  }
-  async dropTable({ tableName }) {
-    let hasMore = true;
-    while (hasMore) {
-      const response = await this.client.callStorageRaw({
-        op: "dropTable",
-        tableName
-      });
-      hasMore = response.hasMore ?? false;
-    }
-  }
-  async alterTable(_args) {
-  }
-  async insert({ tableName, record }) {
-    await this.client.callStorage({
-      op: "insert",
-      tableName,
-      record: this.normalizeRecord(tableName, record)
-    });
-  }
-  async batchInsert({ tableName, records }) {
-    if (records.length === 0) return;
-    await this.client.callStorage({
-      op: "batchInsert",
-      tableName,
-      records: records.map((record) => this.normalizeRecord(tableName, record))
-    });
-  }
-  async load({ tableName, keys }) {
-    const result = await this.client.callStorage({
-      op: "load",
-      tableName,
-      keys
-    });
-    return result;
-  }
-  async queryTable(tableName, filters) {
-    return this.client.callStorage({
-      op: "queryTable",
-      tableName,
-      filters
-    });
-  }
-  async deleteMany(tableName, ids) {
-    if (ids.length === 0) return;
-    await this.client.callStorage({
-      op: "deleteMany",
-      tableName,
-      ids
-    });
-  }
-  normalizeRecord(tableName, record) {
-    const normalized = { ...record };
-    if (tableName === TABLE_WORKFLOW_SNAPSHOT && !normalized.id) {
-      const runId = normalized.run_id || normalized.runId;
-      const workflowName = normalized.workflow_name || normalized.workflowName;
-      normalized.id = workflowName ? `${workflowName}-${runId}` : runId;
-    }
-    if (!normalized.id) {
-      normalized.id = crypto.randomUUID();
-    }
-    for (const [key, value] of Object.entries(normalized)) {
-      if (value instanceof Date) {
-        normalized[key] = value.toISOString();
-      }
-    }
-    return normalized;
-  }
-};
 
 // src/storage/index.ts
-var ConvexStore = class extends MastraStorage {
-  operations;
-  memory;
-  workflows;
-  scores;
+var isClientConfig = (config) => {
+  return "client" in config;
+};
+var ConvexStore = class extends MastraCompositeStore {
   constructor(config) {
     super({ id: config.id, name: config.name ?? "ConvexStore", disableInit: config.disableInit });
-    const client = new ConvexAdminClient(config);
-    this.operations = new StoreOperationsConvex(client);
-    this.memory = new MemoryConvex(this.operations);
-    this.workflows = new WorkflowsConvex(this.operations);
-    this.scores = new ScoresConvex(this.operations);
+    const client = isClientConfig(config) ? config.client : new ConvexAdminClient(config);
+    const domainConfig = { client };
+    const memory = new MemoryConvex(domainConfig);
+    const workflows = new WorkflowsConvex(domainConfig);
+    const scores = new ScoresConvex(domainConfig);
     this.stores = {
-      operations: this.operations,
-      memory: this.memory,
-      workflows: this.workflows,
-      scores: this.scores
-    };
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: true,
-      observabilityInstance: false,
-      listScoresBySpan: false
+      memory,
+      workflows,
+      scores
     };
   }
-  async createTable(_args) {
-  }
-  async clearTable({ tableName }) {
-    await this.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    await this.operations.dropTable({ tableName });
-  }
-  async alterTable(_args) {
-  }
-  async insert({ tableName, record }) {
-    await this.operations.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    await this.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.memory.getThreadById({ threadId });
-  }
-  async saveThread({ thread }) {
-    return this.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    await this.memory.deleteThread({ threadId });
-  }
-  async listMessages(args) {
-    return this.memory.listMessages(args);
-  }
-  async listMessagesById({ messageIds }) {
-    return this.memory.listMessagesById({ messageIds });
-  }
-  async saveMessages(args) {
-    return this.memory.saveMessages(args);
-  }
-  async updateMessages({
-    messages
-  }) {
-    return this.memory.updateMessages({ messages });
-  }
-  async deleteMessages(messageIds) {
-    await this.memory.deleteMessages(messageIds);
-  }
-  async listThreadsByResourceId(args) {
-    return this.memory.listThreadsByResourceId(args);
-  }
-  async getResourceById({ resourceId }) {
-    return this.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
-  async updateWorkflowResults(params) {
-    return this.workflows.updateWorkflowResults(params);
-  }
-  async updateWorkflowState(params) {
-    return this.workflows.updateWorkflowState(params);
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    await this.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async listWorkflowRuns(args) {
-    return this.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  async getScoreById({ id }) {
-    return this.scores.getScoreById({ id });
-  }
-  async saveScore(score) {
-    return this.scores.saveScore(score);
-  }
-  async listScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source
-  }) {
-    return this.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
-  }
-  async listScoresByRunId({
-    runId,
-    pagination
-  }) {
-    return this.scores.listScoresByRunId({ runId, pagination });
-  }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.scores.listScoresByEntityId({ entityId, entityType, pagination });
-  }
 };
 var INDEX_METADATA_TABLE = "mastra_vector_indexes";
 var ConvexVector = class extends MastraVector {