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

package/dist/index.cjs

@@ -1,10 +1,12 @@
 'use strict';
 
-var chunkQKN2PWR2_cjs = require('./chunk-QKN2PWR2.cjs');
+var chunkBKVR7SL7_cjs = require('./chunk-BKVR7SL7.cjs');
+var chunkH5QJE733_cjs = require('./chunk-H5QJE733.cjs');
 var storage = require('@mastra/core/storage');
 var agent = require('@mastra/core/agent');
 var error = require('@mastra/core/error');
 var crypto = require('crypto');
+var base = require('@mastra/core/base');
 var vector = require('@mastra/core/vector');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -74,13 +76,127 @@ var ConvexAdminClient = class {
     return result;
   }
 };
+function resolveConvexConfig(config) {
+  if ("client" in config) {
+    return config.client;
+  }
+  return new ConvexAdminClient(config);
+}
+var ConvexDB = class extends base.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 === storage.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__default.default.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 storage.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: storage.TABLE_THREADS });
+    await this.#db.clearTable({ tableName: storage.TABLE_MESSAGES });
+    await this.#db.clearTable({ tableName: storage.TABLE_RESOURCES });
   }
   async getThreadById({ threadId }) {
-    const row = await this.operations.load({
+    const row = await this.#db.load({
       tableName: storage.TABLE_THREADS,
       keys: { id: threadId }
     });
@@ -93,7 +209,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     };
   }
   async saveThread({ thread }) {
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: storage.TABLE_THREADS,
       record: {
         ...thread,
@@ -129,27 +245,50 @@ var MemoryConvex = class extends storage.MemoryStorage {
     return updated;
   }
   async deleteThread({ threadId }) {
-    const messages = await this.operations.queryTable(storage.TABLE_MESSAGES, [
+    const messages = await this.#db.queryTable(storage.TABLE_MESSAGES, [
       { field: "thread_id", value: threadId }
     ]);
-    await this.operations.deleteMany(
+    await this.#db.deleteMany(
       storage.TABLE_MESSAGES,
       messages.map((msg) => msg.id)
     );
-    await this.operations.deleteMany(storage.TABLE_THREADS, [threadId]);
+    await this.#db.deleteMany(storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CONVEX", "LIST_THREADS", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+        },
+        error$1 instanceof Error ? error$1 : new Error("Invalid pagination parameters")
+      );
+    }
     const perPage = storage.normalizePerPage(perPageInput, 100);
     const { field, direction } = this.parseOrderBy(orderBy);
     const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    const rows = await this.operations.queryTable(storage.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(storage.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];
@@ -186,23 +325,13 @@ var MemoryConvex = class extends storage.MemoryStorage {
     const { field, direction } = this.parseOrderBy(orderBy, "ASC");
     let rows = [];
     for (const tid of threadIds) {
-      const threadRows = await this.operations.queryTable(storage.TABLE_MESSAGES, [
-        { field: "thread_id", value: tid }
-      ]);
+      const threadRows = await this.#db.queryTable(storage.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 = storage.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];
@@ -232,14 +361,14 @@ var MemoryConvex = class extends storage.MemoryStorage {
           }
         }
         if (!target) {
-          const messageRows = await this.operations.queryTable(storage.TABLE_MESSAGES, [
+          const messageRows = await this.#db.queryTable(storage.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(storage.TABLE_MESSAGES, [
+              const otherThreadRows = await this.#db.queryTable(storage.TABLE_MESSAGES, [
                 { field: "thread_id", value: targetThreadId }
               ]);
               threadMessagesCache.set(targetThreadId, otherThreadRows);
@@ -282,7 +411,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     if (messageIds.length === 0) {
       return { messages: [] };
     }
-    const rows = await this.operations.queryTable(storage.TABLE_MESSAGES, void 0);
+    const rows = await this.#db.queryTable(storage.TABLE_MESSAGES, void 0);
     const filtered = rows.filter((row) => messageIds.includes(row.id)).map((row) => this.parseStoredMessage(row));
     const list = new agent.MessageList().add(filtered, "memory");
     return { messages: list.get.all.db() };
@@ -307,7 +436,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
         resourceId: message.resourceId
       };
     });
-    await this.operations.batchInsert({
+    await this.#db.batchInsert({
       tableName: storage.TABLE_MESSAGES,
       records: normalized
     });
@@ -316,7 +445,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     for (const threadId of threadIds) {
       const thread = await this.getThreadById({ threadId });
       if (thread) {
-        await this.operations.insert({
+        await this.#db.insert({
           tableName: storage.TABLE_THREADS,
           record: {
             ...thread,
@@ -335,7 +464,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     messages
   }) {
     if (messages.length === 0) return [];
-    const existing = await this.operations.queryTable(storage.TABLE_MESSAGES, void 0);
+    const existing = await this.#db.queryTable(storage.TABLE_MESSAGES, void 0);
     const updated = [];
     const affectedThreadIds = /* @__PURE__ */ new Set();
     for (const update of messages) {
@@ -364,7 +493,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
         };
         current.content = JSON.stringify(mergedContent);
       }
-      await this.operations.insert({
+      await this.#db.insert({
         tableName: storage.TABLE_MESSAGES,
         record: current
       });
@@ -374,7 +503,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     for (const threadId of affectedThreadIds) {
       const thread = await this.getThreadById({ threadId });
       if (thread) {
-        await this.operations.insert({
+        await this.#db.insert({
           tableName: storage.TABLE_THREADS,
           record: {
             ...thread,
@@ -389,7 +518,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     return updated;
   }
   async deleteMessages(messageIds) {
-    await this.operations.deleteMany(storage.TABLE_MESSAGES, messageIds);
+    await this.#db.deleteMany(storage.TABLE_MESSAGES, messageIds);
   }
   async saveResource({ resource }) {
     const record = {
@@ -400,14 +529,14 @@ var MemoryConvex = class extends storage.MemoryStorage {
     if (resource.metadata !== void 0) {
       record.metadata = resource.metadata;
     }
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: storage.TABLE_RESOURCES,
       record
     });
     return resource;
   }
   async getResourceById({ resourceId }) {
-    const record = await this.operations.load({
+    const record = await this.#db.load({
       tableName: storage.TABLE_RESOURCES,
       keys: { id: resourceId }
     });
@@ -493,12 +622,19 @@ var MemoryConvex = class extends storage.MemoryStorage {
   }
 };
 var ScoresConvex = class extends storage.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: storage.TABLE_SCORERS });
   }
   async getScoreById({ id }) {
-    const row = await this.operations.load({
+    const row = await this.#db.load({
       tableName: storage.TABLE_SCORERS,
       keys: { id }
     });
@@ -512,7 +648,7 @@ var ScoresConvex = class extends storage.ScoresStorage {
       createdAt: now.toISOString(),
       updatedAt: now.toISOString()
     };
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: storage.TABLE_SCORERS,
       record
     });
@@ -563,7 +699,7 @@ var ScoresConvex = class extends storage.ScoresStorage {
         new Error("page must be >= 0")
       );
     }
-    const rows = await this.operations.queryTable(storage.TABLE_SCORERS, void 0);
+    const rows = await this.#db.queryTable(storage.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;
@@ -589,9 +725,16 @@ var ScoresConvex = class extends storage.ScoresStorage {
   }
 };
 var WorkflowsConvex = class extends storage.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: storage.TABLE_WORKFLOW_SNAPSHOT });
   }
   async updateWorkflowResults({
     workflowName,
@@ -638,11 +781,11 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
     snapshot
   }) {
     const now = /* @__PURE__ */ new Date();
-    const existing = await this.operations.load({
+    const existing = await this.#db.load({
       tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
-    await this.operations.insert({
+    await this.#db.insert({
       tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
       record: {
         workflow_name: workflowName,
@@ -658,7 +801,7 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
     workflowName,
     runId
   }) {
-    const row = await this.operations.load({
+    const row = await this.#db.load({
       tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
       keys: { workflow_name: workflowName, run_id: runId }
     });
@@ -667,7 +810,7 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
   }
   async listWorkflowRuns(args = {}) {
     const { workflowName, fromDate, toDate, perPage, page, resourceId, status } = args;
-    let rows = await this.operations.queryTable(storage.TABLE_WORKFLOW_SNAPSHOT, void 0);
+    let rows = await this.#db.queryTable(storage.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());
@@ -699,7 +842,7 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
     runId,
     workflowName
   }) {
-    const runs = await this.operations.queryTable(storage.TABLE_WORKFLOW_SNAPSHOT, void 0);
+    const runs = await this.#db.queryTable(storage.TABLE_WORKFLOW_SNAPSHOT, void 0);
     const match = runs.find((run) => run.run_id === runId && (!workflowName || run.workflow_name === workflowName));
     if (!match) return null;
     return {
@@ -711,8 +854,11 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
       resourceId: match.resourceId
     };
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    await this.#db.deleteMany(storage.TABLE_WORKFLOW_SNAPSHOT, [`${workflowName}-${runId}`]);
+  }
   async getRun(workflowName, runId) {
-    const runs = await this.operations.queryTable(storage.TABLE_WORKFLOW_SNAPSHOT, [
+    const runs = await this.#db.queryTable(storage.TABLE_WORKFLOW_SNAPSHOT, [
       { field: "workflow_name", value: workflowName }
     ]);
     return runs.find((run) => run.run_id === runId) ?? null;
@@ -739,251 +885,25 @@ var WorkflowsConvex = class extends storage.WorkflowsStorage {
     return JSON.parse(JSON.stringify(run.snapshot));
   }
 };
-var StoreOperationsConvex = class extends storage.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 === storage.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__default.default.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 storage.MastraStorage {
-  operations;
-  memory;
-  workflows;
-  scores;
+var isClientConfig = (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 = 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 vector.MastraVector {
@@ -1288,61 +1208,61 @@ function cosineSimilarity(a, b) {
   return dot / (Math.sqrt(magA) * Math.sqrt(magB));
 }
 
+Object.defineProperty(exports, "mastraStorage", {
+  enumerable: true,
+  get: function () { return chunkBKVR7SL7_cjs.mastraStorage; }
+});
 Object.defineProperty(exports, "TABLE_MESSAGES", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.TABLE_MESSAGES; }
+  get: function () { return chunkH5QJE733_cjs.TABLE_MESSAGES; }
 });
 Object.defineProperty(exports, "TABLE_RESOURCES", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.TABLE_RESOURCES; }
+  get: function () { return chunkH5QJE733_cjs.TABLE_RESOURCES; }
 });
 Object.defineProperty(exports, "TABLE_SCORERS", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.TABLE_SCORERS; }
+  get: function () { return chunkH5QJE733_cjs.TABLE_SCORERS; }
 });
 Object.defineProperty(exports, "TABLE_THREADS", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.TABLE_THREADS; }
+  get: function () { return chunkH5QJE733_cjs.TABLE_THREADS; }
 });
 Object.defineProperty(exports, "TABLE_WORKFLOW_SNAPSHOT", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.TABLE_WORKFLOW_SNAPSHOT; }
+  get: function () { return chunkH5QJE733_cjs.TABLE_WORKFLOW_SNAPSHOT; }
 });
 Object.defineProperty(exports, "mastraDocumentsTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraDocumentsTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraDocumentsTable; }
 });
 Object.defineProperty(exports, "mastraMessagesTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraMessagesTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraMessagesTable; }
 });
 Object.defineProperty(exports, "mastraResourcesTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraResourcesTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraResourcesTable; }
 });
 Object.defineProperty(exports, "mastraScoresTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraScoresTable; }
-});
-Object.defineProperty(exports, "mastraStorage", {
-  enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraStorage; }
+  get: function () { return chunkH5QJE733_cjs.mastraScoresTable; }
 });
 Object.defineProperty(exports, "mastraThreadsTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraThreadsTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraThreadsTable; }
 });
 Object.defineProperty(exports, "mastraVectorIndexesTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraVectorIndexesTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraVectorIndexesTable; }
 });
 Object.defineProperty(exports, "mastraVectorsTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraVectorsTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraVectorsTable; }
 });
 Object.defineProperty(exports, "mastraWorkflowSnapshotsTable", {
   enumerable: true,
-  get: function () { return chunkQKN2PWR2_cjs.mastraWorkflowSnapshotsTable; }
+  get: function () { return chunkH5QJE733_cjs.mastraWorkflowSnapshotsTable; }
 });
 exports.ConvexStore = ConvexStore;
 exports.ConvexVector = ConvexVector;