@mastra/convex 0.0.0-main-test-2-20251127211532

package/dist/index.js

@@ -0,0 +1,1262 @@
+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, TABLE_MESSAGES, normalizePerPage, calculatePagination, safelyParseJSON, TABLE_RESOURCES, WorkflowsStorage, 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 { MastraVector } from '@mastra/core/vector';
+
+// src/storage/client.ts
+var DEFAULT_STORAGE_FUNCTION = "mastra/storage:handle";
+var ConvexAdminClient = class {
+  deploymentUrl;
+  adminAuthToken;
+  storageFunction;
+  constructor({ deploymentUrl, adminAuthToken, storageFunction }) {
+    if (!deploymentUrl) {
+      throw new Error("ConvexAdminClient: deploymentUrl is required.");
+    }
+    if (!adminAuthToken) {
+      throw new Error("ConvexAdminClient: adminAuthToken is required.");
+    }
+    this.deploymentUrl = deploymentUrl.replace(/\/$/, "");
+    this.adminAuthToken = adminAuthToken;
+    this.storageFunction = storageFunction ?? DEFAULT_STORAGE_FUNCTION;
+  }
+  /**
+   * Call storage and return the full response including hasMore flag.
+   * Use this for operations that may need multiple calls (e.g., clearTable).
+   */
+  async callStorageRaw(request) {
+    const url = `${this.deploymentUrl}/api/mutation`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Convex ${this.adminAuthToken}`
+      },
+      body: JSON.stringify({
+        path: this.storageFunction,
+        args: request,
+        format: "json"
+      })
+    });
+    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;
+      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;
+    }
+    return {
+      result: storageResponse.result,
+      hasMore: storageResponse.hasMore
+    };
+  }
+  async callStorage(request) {
+    const { result } = await this.callStorageRaw(request);
+    return result;
+  }
+};
+var MemoryConvex = class extends MemoryStorage {
+  constructor(operations) {
+    super();
+    this.operations = operations;
+  }
+  async getThreadById({ threadId }) {
+    const row = await this.operations.load({
+      tableName: TABLE_THREADS,
+      keys: { id: threadId }
+    });
+    if (!row) return null;
+    return {
+      ...row,
+      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+  async saveThread({ thread }) {
+    await this.operations.insert({
+      tableName: TABLE_THREADS,
+      record: {
+        ...thread,
+        metadata: thread.metadata ?? {}
+      }
+    });
+    return thread;
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    const existing = await this.getThreadById({ threadId: id });
+    if (!existing) {
+      throw new MastraError({
+        id: "CONVEX_STORAGE_THREAD_NOT_FOUND",
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread ${id} not found`
+      });
+    }
+    const updated = {
+      ...existing,
+      title,
+      metadata: {
+        ...existing.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    await this.saveThread({ thread: updated });
+    return updated;
+  }
+  async deleteThread({ threadId }) {
+    const messages = await this.operations.queryTable(TABLE_MESSAGES, [
+      { field: "thread_id", value: threadId }
+    ]);
+    await this.operations.deleteMany(
+      TABLE_MESSAGES,
+      messages.map((msg) => msg.id)
+    );
+    await this.operations.deleteMany(TABLE_THREADS, [threadId]);
+  }
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    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) => ({
+      ...row,
+      metadata: typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    }));
+    threads.sort((a, b) => {
+      const aValue = a[field];
+      const bValue = b[field];
+      const aTime = aValue instanceof Date ? aValue.getTime() : new Date(aValue).getTime();
+      const bTime = bValue instanceof Date ? bValue.getTime() : new Date(bValue).getTime();
+      return direction === "ASC" ? aTime - bTime : bTime - aTime;
+    });
+    const total = threads.length;
+    const paginated = perPageInput === false ? threads : threads.slice(offset, offset + perPage);
+    return {
+      threads: paginated,
+      total,
+      page,
+      perPage: perPageForResponse,
+      hasMore: perPageInput === false ? false : offset + perPage < total
+    };
+  }
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!threadId.trim()) {
+      throw new MastraError(
+        {
+          id: "CONVEX_STORAGE_LIST_MESSAGES_INVALID_THREAD_ID",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { threadId }
+        },
+        new Error("threadId must be a non-empty string")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+    let rows = await this.operations.queryTable(TABLE_MESSAGES, [
+      { field: "thread_id", value: threadId }
+    ]);
+    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.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];
+      if (typeof aValue === "number" && typeof bValue === "number") {
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      }
+      return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+    });
+    const totalThreadMessages = rows.length;
+    const paginatedRows = perPageInput === false ? rows : rows.slice(offset, offset + perPage);
+    const messages = paginatedRows.map((row) => this.parseStoredMessage(row));
+    const messageIds = new Set(messages.map((msg) => msg.id));
+    if (include && include.length > 0) {
+      const threadMessagesCache = /* @__PURE__ */ new Map();
+      threadMessagesCache.set(threadId, rows);
+      for (const includeItem of include) {
+        const targetThreadId = includeItem.threadId || threadId;
+        if (!threadMessagesCache.has(targetThreadId)) {
+          const otherThreadRows = await this.operations.queryTable(TABLE_MESSAGES, [
+            { field: "thread_id", value: targetThreadId }
+          ]);
+          threadMessagesCache.set(targetThreadId, otherThreadRows);
+        }
+        const targetThreadRows = threadMessagesCache.get(targetThreadId) || [];
+        const target = targetThreadRows.find((row) => row.id === includeItem.id);
+        if (target && !messageIds.has(target.id)) {
+          messages.push(this.parseStoredMessage(target));
+          messageIds.add(target.id);
+        }
+        await this.addContextMessages({
+          includeItem,
+          allMessages: targetThreadRows,
+          targetThreadId,
+          messageIds,
+          messages
+        });
+      }
+    }
+    messages.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];
+      if (typeof aValue === "number" && typeof bValue === "number") {
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      }
+      return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+    });
+    const hasMore = include && include.length > 0 ? new Set(messages.filter((m) => m.threadId === threadId).map((m) => m.id)).size < totalThreadMessages : perPageInput === false ? false : offset + perPage < totalThreadMessages;
+    return {
+      messages,
+      total: totalThreadMessages,
+      page,
+      perPage: perPageForResponse,
+      hasMore
+    };
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) {
+      return { messages: [] };
+    }
+    const rows = await this.operations.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() };
+  }
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return { messages: [] };
+    const normalized = messages.map((message) => {
+      if (!message.threadId) {
+        throw new Error("Thread ID is required");
+      }
+      if (!message.resourceId) {
+        throw new Error("Resource ID is required");
+      }
+      const createdAt = message.createdAt instanceof Date ? message.createdAt.toISOString() : message.createdAt;
+      return {
+        id: message.id,
+        thread_id: message.threadId,
+        content: JSON.stringify(message.content),
+        role: message.role,
+        type: message.type || "v2",
+        createdAt,
+        resourceId: message.resourceId
+      };
+    });
+    await this.operations.batchInsert({
+      tableName: TABLE_MESSAGES,
+      records: normalized
+    });
+    const threadIds = [...new Set(messages.map((m) => m.threadId).filter(Boolean))];
+    const now = /* @__PURE__ */ new Date();
+    for (const threadId of threadIds) {
+      const thread = await this.getThreadById({ threadId });
+      if (thread) {
+        await this.operations.insert({
+          tableName: TABLE_THREADS,
+          record: {
+            ...thread,
+            id: thread.id,
+            updatedAt: now.toISOString(),
+            createdAt: thread.createdAt instanceof Date ? thread.createdAt.toISOString() : thread.createdAt,
+            metadata: thread.metadata ?? {}
+          }
+        });
+      }
+    }
+    const list = new MessageList().add(messages, "memory");
+    return { messages: list.get.all.db() };
+  }
+  async updateMessages({
+    messages
+  }) {
+    if (messages.length === 0) return [];
+    const existing = await this.operations.queryTable(TABLE_MESSAGES, void 0);
+    const updated = [];
+    const affectedThreadIds = /* @__PURE__ */ new Set();
+    for (const update of messages) {
+      const current = existing.find((row) => row.id === update.id);
+      if (!current) continue;
+      affectedThreadIds.add(current.thread_id);
+      if (update.threadId) {
+        affectedThreadIds.add(update.threadId);
+        current.thread_id = update.threadId;
+      }
+      if (update.resourceId !== void 0) {
+        current.resourceId = update.resourceId ?? null;
+      }
+      if (update.role) {
+        current.role = update.role;
+      }
+      if (update.type) {
+        current.type = update.type;
+      }
+      if (update.content) {
+        const existingContent = safelyParseJSON(current.content) || {};
+        const mergedContent = {
+          ...existingContent,
+          ...update.content,
+          ...existingContent.metadata && update.content.metadata ? { metadata: { ...existingContent.metadata, ...update.content.metadata } } : {}
+        };
+        current.content = JSON.stringify(mergedContent);
+      }
+      await this.operations.insert({
+        tableName: TABLE_MESSAGES,
+        record: current
+      });
+      updated.push(this.parseStoredMessage(current));
+    }
+    const now = /* @__PURE__ */ new Date();
+    for (const threadId of affectedThreadIds) {
+      const thread = await this.getThreadById({ threadId });
+      if (thread) {
+        await this.operations.insert({
+          tableName: TABLE_THREADS,
+          record: {
+            ...thread,
+            id: thread.id,
+            updatedAt: now.toISOString(),
+            createdAt: thread.createdAt instanceof Date ? thread.createdAt.toISOString() : thread.createdAt,
+            metadata: thread.metadata ?? {}
+          }
+        });
+      }
+    }
+    return updated;
+  }
+  async deleteMessages(messageIds) {
+    await this.operations.deleteMany(TABLE_MESSAGES, messageIds);
+  }
+  async saveResource({ resource }) {
+    const record = {
+      ...resource,
+      createdAt: resource.createdAt instanceof Date ? resource.createdAt.toISOString() : resource.createdAt,
+      updatedAt: resource.updatedAt instanceof Date ? resource.updatedAt.toISOString() : resource.updatedAt
+    };
+    if (resource.metadata !== void 0) {
+      record.metadata = resource.metadata;
+    }
+    await this.operations.insert({
+      tableName: TABLE_RESOURCES,
+      record
+    });
+    return resource;
+  }
+  async getResourceById({ resourceId }) {
+    const record = await this.operations.load({
+      tableName: TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!record) return null;
+    return {
+      ...record,
+      metadata: typeof record.metadata === "string" ? safelyParseJSON(record.metadata) : record.metadata,
+      createdAt: new Date(record.createdAt),
+      updatedAt: new Date(record.updatedAt)
+    };
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existing = await this.getResourceById({ resourceId });
+    const now = /* @__PURE__ */ new Date();
+    if (!existing) {
+      const created = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata ?? {},
+        createdAt: now,
+        updatedAt: now
+      };
+      return this.saveResource({ resource: created });
+    }
+    const updated = {
+      ...existing,
+      workingMemory: workingMemory ?? existing.workingMemory,
+      metadata: {
+        ...existing.metadata,
+        ...metadata
+      },
+      updatedAt: now
+    };
+    await this.saveResource({ resource: updated });
+    return updated;
+  }
+  parseStoredMessage(message) {
+    const content = safelyParseJSON(message.content);
+    return {
+      id: message.id,
+      threadId: message.thread_id,
+      content,
+      role: message.role,
+      type: message.type,
+      createdAt: new Date(message.createdAt),
+      resourceId: message.resourceId ?? void 0
+    };
+  }
+  async addContextMessages({
+    includeItem,
+    allMessages,
+    targetThreadId,
+    messageIds,
+    messages
+  }) {
+    const ordered = allMessages.filter((row) => row.thread_id === targetThreadId).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    const targetIndex = ordered.findIndex((row) => row.id === includeItem.id);
+    if (targetIndex === -1) return;
+    if (includeItem.withPreviousMessages) {
+      const start = Math.max(0, targetIndex - includeItem.withPreviousMessages);
+      for (let i = start; i < targetIndex; i++) {
+        const row = ordered[i];
+        if (row && !messageIds.has(row.id)) {
+          messages.push(this.parseStoredMessage(row));
+          messageIds.add(row.id);
+        }
+      }
+    }
+    if (includeItem.withNextMessages) {
+      const end = Math.min(ordered.length, targetIndex + includeItem.withNextMessages + 1);
+      for (let i = targetIndex + 1; i < end; i++) {
+        const row = ordered[i];
+        if (row && !messageIds.has(row.id)) {
+          messages.push(this.parseStoredMessage(row));
+          messageIds.add(row.id);
+        }
+      }
+    }
+  }
+};
+var ScoresConvex = class extends ScoresStorage {
+  constructor(operations) {
+    super();
+    this.operations = operations;
+  }
+  async getScoreById({ id }) {
+    const row = await this.operations.load({
+      tableName: TABLE_SCORERS,
+      keys: { id }
+    });
+    return row ? this.deserialize(row) : null;
+  }
+  async saveScore(score) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      ...score,
+      id: crypto.randomUUID(),
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString()
+    };
+    await this.operations.insert({
+      tableName: TABLE_SCORERS,
+      record
+    });
+    return { score: this.deserialize(record) };
+  }
+  async listScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source
+  }) {
+    return this.listScores({
+      filters: { scorerId, entityId, entityType, source },
+      pagination
+    });
+  }
+  async listScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.listScores({
+      filters: { runId },
+      pagination
+    });
+  }
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.listScores({
+      filters: { entityId, entityType },
+      pagination
+    });
+  }
+  async listScores({
+    filters,
+    pagination
+  }) {
+    if (pagination.page < 0) {
+      throw new MastraError(
+        {
+          id: "CONVEX_STORAGE_INVALID_PAGINATION",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const rows = await this.operations.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;
+    const start = perPage === false ? 0 : page * perPageValue;
+    const end = perPage === false ? filtered.length : start + perPageValue;
+    const slice = filtered.slice(start, end).map((row) => this.deserialize(row));
+    return {
+      pagination: {
+        total: filtered.length,
+        page,
+        perPage,
+        hasMore: perPage === false ? false : end < filtered.length
+      },
+      scores: slice
+    };
+  }
+  deserialize(row) {
+    return {
+      ...row,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+};
+var WorkflowsConvex = class extends WorkflowsStorage {
+  constructor(operations) {
+    super();
+    this.operations = operations;
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
+  }) {
+    const run = await this.getRun(workflowName, runId);
+    if (!run) return {};
+    const snapshot = this.ensureSnapshot(run);
+    snapshot.context = snapshot.context || {};
+    snapshot.context[stepId] = result;
+    snapshot.requestContext = { ...snapshot.requestContext || {}, ...requestContext };
+    await this.persistWorkflowSnapshot({
+      workflowName,
+      runId,
+      resourceId: run.resourceId,
+      snapshot
+    });
+    return JSON.parse(JSON.stringify(snapshot.context));
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    const run = await this.getRun(workflowName, runId);
+    if (!run) return void 0;
+    const snapshot = this.ensureSnapshot(run);
+    const updated = { ...snapshot, ...opts };
+    await this.persistWorkflowSnapshot({
+      workflowName,
+      runId,
+      resourceId: run.resourceId,
+      snapshot: updated
+    });
+    return updated;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot
+  }) {
+    const now = /* @__PURE__ */ new Date();
+    const existing = await this.operations.load({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    await this.operations.insert({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      record: {
+        workflow_name: workflowName,
+        run_id: runId,
+        resourceId,
+        snapshot,
+        createdAt: existing?.createdAt ?? now.toISOString(),
+        updatedAt: now.toISOString()
+      }
+    });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    const row = await this.operations.load({
+      tableName: TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    if (!row) return null;
+    return typeof row.snapshot === "string" ? JSON.parse(row.snapshot) : JSON.parse(JSON.stringify(row.snapshot));
+  }
+  async listWorkflowRuns(args = {}) {
+    const { workflowName, fromDate, toDate, perPage, page, resourceId, status } = args;
+    let rows = await this.operations.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());
+    if (toDate) rows = rows.filter((run) => new Date(run.createdAt).getTime() <= toDate.getTime());
+    if (status) {
+      rows = rows.filter((run) => {
+        const snapshot = this.ensureSnapshot(run);
+        return snapshot.status === status;
+      });
+    }
+    const total = rows.length;
+    rows.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (perPage !== void 0 && page !== void 0) {
+      const normalized = normalizePerPage(perPage, Number.MAX_SAFE_INTEGER);
+      const offset = page * normalized;
+      rows = rows.slice(offset, offset + normalized);
+    }
+    const runs = rows.map((run) => ({
+      workflowName: run.workflow_name,
+      runId: run.run_id,
+      snapshot: this.ensureSnapshot(run),
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      resourceId: run.resourceId
+    }));
+    return { runs, total };
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    const runs = await this.operations.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 {
+      workflowName: match.workflow_name,
+      runId: match.run_id,
+      snapshot: this.ensureSnapshot(match),
+      createdAt: new Date(match.createdAt),
+      updatedAt: new Date(match.updatedAt),
+      resourceId: match.resourceId
+    };
+  }
+  async getRun(workflowName, runId) {
+    const runs = await this.operations.queryTable(TABLE_WORKFLOW_SNAPSHOT, [
+      { field: "workflow_name", value: workflowName }
+    ]);
+    return runs.find((run) => run.run_id === runId) ?? null;
+  }
+  ensureSnapshot(run) {
+    if (!run.snapshot) {
+      return {
+        context: {},
+        activePaths: [],
+        activeStepsPath: {},
+        timestamp: Date.now(),
+        suspendedPaths: {},
+        resumeLabels: {},
+        serializedStepGraph: [],
+        value: {},
+        waitingPaths: {},
+        status: "pending",
+        runId: ""
+      };
+    }
+    if (typeof run.snapshot === "string") {
+      return JSON.parse(run.snapshot);
+    }
+    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;
+  constructor(config) {
+    super({ id: config.id, name: config.name ?? "ConvexStore" });
+    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);
+    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
+    };
+  }
+  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 {
+  client;
+  constructor(config) {
+    super({ id: config.id });
+    this.client = new ConvexAdminClient(config);
+  }
+  async createIndex({ indexName, dimension }) {
+    await this.callStorage({
+      op: "insert",
+      tableName: INDEX_METADATA_TABLE,
+      record: {
+        id: indexName,
+        indexName,
+        dimension,
+        metric: "cosine",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+  }
+  async deleteIndex({ indexName }) {
+    await this.callStorage({
+      op: "deleteMany",
+      tableName: INDEX_METADATA_TABLE,
+      ids: [indexName]
+    });
+    await this.callStorageUntilComplete({
+      op: "clearTable",
+      tableName: this.vectorTable(indexName)
+    });
+  }
+  async truncateIndex({ indexName }) {
+    await this.callStorageUntilComplete({
+      op: "clearTable",
+      tableName: this.vectorTable(indexName)
+    });
+  }
+  async listIndexes() {
+    const indexes = await this.callStorage({
+      op: "queryTable",
+      tableName: INDEX_METADATA_TABLE
+    });
+    return indexes.map((index) => index.id);
+  }
+  async describeIndex({ indexName }) {
+    const index = await this.callStorage({
+      op: "load",
+      tableName: INDEX_METADATA_TABLE,
+      keys: { id: indexName }
+    });
+    if (!index) {
+      throw new Error(`Index ${indexName} not found`);
+    }
+    const vectors = await this.callStorage({
+      op: "queryTable",
+      tableName: this.vectorTable(indexName)
+    });
+    return {
+      dimension: index.dimension,
+      count: vectors.length,
+      metric: "cosine"
+    };
+  }
+  async upsert({ indexName, vectors, ids, metadata }) {
+    const vectorIds = ids ?? vectors.map(() => crypto.randomUUID());
+    const records = vectors.map((vector, i) => ({
+      id: vectorIds[i],
+      embedding: vector,
+      metadata: metadata?.[i]
+    }));
+    await this.callStorage({
+      op: "batchInsert",
+      tableName: this.vectorTable(indexName),
+      records
+    });
+    return vectorIds;
+  }
+  async query({
+    indexName,
+    queryVector,
+    topK = 10,
+    includeVector = false,
+    filter
+  }) {
+    const vectors = await this.callStorage({
+      op: "queryTable",
+      tableName: this.vectorTable(indexName)
+    });
+    const filtered = filter && !this.isEmptyFilter(filter) ? vectors.filter((record) => this.matchesFilter(record.metadata, filter)) : vectors;
+    const scored = filtered.map((record) => ({
+      id: record.id,
+      score: cosineSimilarity(queryVector, record.embedding),
+      metadata: record.metadata,
+      ...includeVector ? { vector: record.embedding } : {}
+    })).filter((result) => Number.isFinite(result.score)).sort((a, b) => b.score - a.score).slice(0, topK);
+    return scored;
+  }
+  async updateVector(params) {
+    const hasId = "id" in params && params.id;
+    const hasFilter = "filter" in params && params.filter !== void 0;
+    if (hasId && hasFilter) {
+      throw new Error("ConvexVector.updateVector: id and filter are mutually exclusive");
+    }
+    if (hasFilter) {
+      const filter = params.filter;
+      if (this.isEmptyFilter(filter)) {
+        throw new Error("ConvexVector.updateVector: cannot update with empty filter");
+      }
+      const vectors = await this.callStorage({
+        op: "queryTable",
+        tableName: this.vectorTable(params.indexName)
+      });
+      const matching = vectors.filter((record) => this.matchesFilter(record.metadata, filter));
+      for (const existing2 of matching) {
+        const updated2 = {
+          ...existing2,
+          ...params.update.vector ? { embedding: params.update.vector } : {},
+          ...params.update.metadata ? { metadata: { ...existing2.metadata, ...params.update.metadata } } : {}
+        };
+        await this.callStorage({
+          op: "insert",
+          tableName: this.vectorTable(params.indexName),
+          record: updated2
+        });
+      }
+      return;
+    }
+    if (!hasId) {
+      throw new Error("ConvexVector.updateVector: Either id or filter must be provided");
+    }
+    const existing = await this.callStorage({
+      op: "load",
+      tableName: this.vectorTable(params.indexName),
+      keys: { id: params.id }
+    });
+    if (!existing) return;
+    const updated = {
+      ...existing,
+      ...params.update.vector ? { embedding: params.update.vector } : {},
+      ...params.update.metadata ? { metadata: { ...existing.metadata, ...params.update.metadata } } : {}
+    };
+    await this.callStorage({
+      op: "insert",
+      tableName: this.vectorTable(params.indexName),
+      record: updated
+    });
+  }
+  async deleteVector({ indexName, id }) {
+    await this.callStorage({
+      op: "deleteMany",
+      tableName: this.vectorTable(indexName),
+      ids: [id]
+    });
+  }
+  async deleteVectors(params) {
+    const { indexName } = params;
+    const hasIds = "ids" in params && params.ids !== void 0;
+    const hasFilter = "filter" in params && params.filter !== void 0;
+    if (hasIds && hasFilter) {
+      throw new Error("ConvexVector.deleteVectors: ids and filter are mutually exclusive");
+    }
+    if (!hasIds && !hasFilter) {
+      throw new Error("ConvexVector.deleteVectors: Either filter or ids must be provided");
+    }
+    if (hasIds) {
+      const ids = params.ids;
+      if (ids.length === 0) {
+        throw new Error("ConvexVector.deleteVectors: cannot delete with empty ids array");
+      }
+      await this.callStorage({
+        op: "deleteMany",
+        tableName: this.vectorTable(indexName),
+        ids
+      });
+      return;
+    }
+    const filter = params.filter;
+    if (this.isEmptyFilter(filter)) {
+      throw new Error("ConvexVector.deleteVectors: cannot delete with empty filter");
+    }
+    const vectors = await this.callStorage({
+      op: "queryTable",
+      tableName: this.vectorTable(indexName)
+    });
+    const matchingIds = vectors.filter((record) => this.matchesFilter(record.metadata, filter)).map((record) => record.id);
+    if (matchingIds.length > 0) {
+      await this.callStorage({
+        op: "deleteMany",
+        tableName: this.vectorTable(indexName),
+        ids: matchingIds
+      });
+    }
+  }
+  vectorTable(indexName) {
+    return `mastra_vector_${indexName}`;
+  }
+  isEmptyFilter(filter) {
+    if (!filter) return true;
+    return Object.keys(filter).length === 0;
+  }
+  matchesFilter(recordMetadata, filter) {
+    if (!recordMetadata) return false;
+    if (!filter || Object.keys(filter).length === 0) return true;
+    if ("metadata" in filter && filter.metadata) {
+      return this.matchesFilterConditions(recordMetadata, filter.metadata);
+    }
+    return this.matchesFilterConditions(recordMetadata, filter);
+  }
+  matchesFilterConditions(recordMetadata, conditions) {
+    for (const [key, value] of Object.entries(conditions)) {
+      if (key === "$and" && Array.isArray(value)) {
+        const allMatch = value.every((cond) => this.matchesFilterConditions(recordMetadata, cond));
+        if (!allMatch) return false;
+        continue;
+      }
+      if (key === "$or" && Array.isArray(value)) {
+        const anyMatch = value.some((cond) => this.matchesFilterConditions(recordMetadata, cond));
+        if (!anyMatch) return false;
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$in" in value) {
+        if (!Array.isArray(value.$in) || !value.$in.includes(recordMetadata[key])) {
+          return false;
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$nin" in value) {
+        if (Array.isArray(value.$nin) && value.$nin.includes(recordMetadata[key])) {
+          return false;
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$gt" in value) {
+        if (!(recordMetadata[key] > value.$gt)) {
+          return false;
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$gte" in value) {
+        if (!(recordMetadata[key] >= value.$gte)) {
+          return false;
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$lt" in value) {
+        if (!(recordMetadata[key] < value.$lt)) {
+          return false;
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$lte" in value) {
+        if (!(recordMetadata[key] <= value.$lte)) {
+          return false;
+        }
+        continue;
+      }
+      if (typeof value === "object" && value !== null && "$ne" in value) {
+        if (recordMetadata[key] === value.$ne) {
+          return false;
+        }
+        continue;
+      }
+      if (recordMetadata[key] !== value) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async callStorage(request) {
+    return this.client.callStorage(request);
+  }
+  /**
+   * Call storage repeatedly until hasMore is false.
+   * Use for bulk operations like clearTable that may need multiple batches.
+   */
+  async callStorageUntilComplete(request) {
+    let hasMore = true;
+    while (hasMore) {
+      const response = await this.client.callStorageRaw(request);
+      hasMore = response.hasMore ?? false;
+    }
+  }
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    return -1;
+  }
+  let dot = 0;
+  let magA = 0;
+  let magB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const aVal = a[i] ?? 0;
+    const bVal = b[i] ?? 0;
+    dot += aVal * bVal;
+    magA += aVal * aVal;
+    magB += bVal * bVal;
+  }
+  if (magA === 0 || magB === 0) {
+    return -1;
+  }
+  return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+}
+
+export { ConvexStore, ConvexVector };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map