@mastra/convex 1.1.0 → 1.2.0-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # @mastra/convex
 
+## 1.2.0-alpha.0
+
+### Minor Changes
+
+- Convex can now persist channel installations and provider configuration. ([#16718](https://github.com/mastra-ai/mastra/pull/16718))
+
+  ```ts
+  import { ConvexStore } from '@mastra/convex';
+
+  const storage = new ConvexStore({
+    id: 'app-storage',
+    deploymentUrl: process.env.CONVEX_URL!,
+    adminAuthToken: process.env.CONVEX_ADMIN_KEY!,
+  });
+
+  const channels = await storage.getStore('channels');
+
+  await channels?.saveInstallation({
+    id: 'slack-agent-1',
+    platform: 'slack',
+    agentId: 'agent-1',
+    status: 'active',
+    webhookId: 'webhook-1',
+    data: { teamId: 'T123', botUserId: 'U123' },
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+  ```
+
+- Workflow schedules can now be stored in Convex. ([#16710](https://github.com/mastra-ai/mastra/pull/16710))
+
+  ```ts
+  import { ConvexStore } from '@mastra/convex';
+
+  const storage = new ConvexStore({
+    id: 'app-storage',
+    deploymentUrl: process.env.CONVEX_URL!,
+    adminAuthToken: process.env.CONVEX_ADMIN_KEY!,
+  });
+
+  const schedules = await storage.getStore('schedules');
+
+  await schedules?.createSchedule({
+    id: 'daily-summary',
+    target: { type: 'workflow', workflowId: 'summary-workflow' },
+    cron: '0 9 * * *',
+    status: 'active',
+    nextFireAt: Date.now(),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  });
+  ```
+
+### Patch Changes
+
+- Improved Convex background task reliability with safer lifecycle updates, faster filtering, and smoother upgrades from older storage rows. ([#16724](https://github.com/mastra-ai/mastra/pull/16724))
+
+- Updated dependencies [[`0cbece9`](https://github.com/mastra-ai/mastra/commit/0cbece9d832cb134a74cdbf3682d390a058215a4), [`7dfe1bc`](https://github.com/mastra-ai/mastra/commit/7dfe1bcfe71d261a6fd6bbf29b1dec49d78fb98f), [`70cb714`](https://github.com/mastra-ai/mastra/commit/70cb7149c8f16f478e15b58498254a53181750a4), [`7f9da22`](https://github.com/mastra-ai/mastra/commit/7f9da22efd5aa595e138a31de55a5f0f2f28b33d)]:
+  - @mastra/core@1.37.0-alpha.6
+
 ## 1.1.0
 
 ### Minor Changes

package/README.md

@@ -2,7 +2,7 @@
 
 Convex adapters for Mastra:
 
-- `ConvexStore` implements the Mastra storage contract (threads, messages, workflows, scores, resources).
+- `ConvexStore` implements the Mastra storage contract (threads, messages, workflows, scores, resources, schedules, channels, background tasks).
 - `ConvexVector` stores embeddings inside Convex and performs development-scale cosine similarity search.
 - `ConvexNativeVector` uses Convex native vector search for production workloads.
 - `ConvexServerCache` stores Mastra server cache entries in Convex for durable stream replay and response caching.
@@ -28,6 +28,11 @@ import {
   mastraResourcesTable,
   mastraWorkflowSnapshotsTable,
   mastraScoresTable,
+  mastraSchedulesTable,
+  mastraScheduleTriggersTable,
+  mastraChannelInstallationsTable,
+  mastraChannelConfigTable,
+  mastraBackgroundTasksTable,
   mastraVectorIndexesTable,
   mastraVectorsTable,
   mastraCacheTable,
@@ -41,6 +46,11 @@ export default defineSchema({
   mastra_resources: mastraResourcesTable,
   mastra_workflow_snapshots: mastraWorkflowSnapshotsTable,
   mastra_scorers: mastraScoresTable,
+  mastra_schedules: mastraSchedulesTable,
+  mastra_schedule_triggers: mastraScheduleTriggersTable,
+  mastra_channel_installations: mastraChannelInstallationsTable,
+  mastra_channel_config: mastraChannelConfigTable,
+  mastra_background_tasks: mastraBackgroundTasksTable,
   mastra_vector_indexes: mastraVectorIndexesTable,
   mastra_vectors: mastraVectorsTable,
   mastra_cache: mastraCacheTable,
@@ -160,24 +170,32 @@ Native vector search uses Convex's schema-defined vector indexes and action-only
 
 This adapter uses **typed Convex tables** for each Mastra domain:
 
-| Domain         | Convex Table                | Purpose              |
-| -------------- | --------------------------- | -------------------- |
-| Threads        | `mastra_threads`            | Conversation threads |
-| Messages       | `mastra_messages`           | Chat messages        |
-| Resources      | `mastra_resources`          | User working memory  |
-| Workflows      | `mastra_workflow_snapshots` | Workflow state       |
-| Scorers        | `mastra_scorers`            | Evaluation data      |
-| Vector Indexes | `mastra_vector_indexes`     | Index metadata       |
-| Vectors        | `mastra_vectors`            | Embeddings           |
-| Cache          | `mastra_cache`              | Cache metadata       |
-| Cache Items    | `mastra_cache_list_items`   | Cache list entries   |
-| Fallback       | `mastra_documents`          | Unknown tables       |
+| Domain           | Convex Table                                            | Purpose                          |
+| ---------------- | ------------------------------------------------------- | -------------------------------- |
+| Threads          | `mastra_threads`                                        | Conversation threads             |
+| Messages         | `mastra_messages`                                       | Chat messages                    |
+| Resources        | `mastra_resources`                                      | User working memory              |
+| Workflows        | `mastra_workflow_snapshots`                             | Workflow state                   |
+| Scorers          | `mastra_scorers`                                        | Evaluation data                  |
+| Schedules        | `mastra_schedules`                                      | Workflow schedules               |
+| Triggers         | `mastra_schedule_triggers`                              | Schedule history                 |
+| Channels         | `mastra_channel_installations`, `mastra_channel_config` | Channel installations and config |
+| Background Tasks | `mastra_background_tasks`                               | Background task state            |
+| Vector Indexes   | `mastra_vector_indexes`                                 | Index metadata                   |
+| Vectors          | `mastra_vectors`                                        | Embeddings                       |
+| Cache            | `mastra_cache`                                          | Cache metadata                   |
+| Cache Items      | `mastra_cache_list_items`                               | Cache list entries               |
+| Fallback         | `mastra_documents`                                      | Unknown tables                   |
 
 All typed tables include:
 
 - An `id` field for Mastra's record ID (distinct from Convex's auto-generated `_id`)
 - A `by_record_id` index for efficient lookups by Mastra ID
 
+Schedule due reads and trigger-history reads use bounded Convex queries to avoid deployment read limits. When no explicit trigger-history limit is provided, the adapter returns the newest 100 rows. Schedule listing is capped at 8,000 rows per call. Schedule rows also store a normalized `workflow_id` alongside the serialized target so workflow filters can run inside Convex before the listing cap is applied.
+
+Background task reads and updates also tolerate older rows that were written to the fallback `mastra_documents` table.
+
 ## Testing
 
 Set the following environment variables before running tests:

package/dist/{chunk-FZDLZ4S3.js → chunk-AJFME2ZF.js}

@@ -1,5 +1,5 @@
 import { mutationGeneric, actionGeneric, queryGeneric } from 'convex/server';
-import { TABLE_SCORERS, TABLE_WORKFLOW_SNAPSHOT, TABLE_RESOURCES, TABLE_MESSAGES, TABLE_THREADS } from '@mastra/core/storage/constants';
+import { TABLE_BACKGROUND_TASKS, TABLE_CHANNEL_CONFIG, TABLE_CHANNEL_INSTALLATIONS, TABLE_SCHEDULE_TRIGGERS, TABLE_SCHEDULES, TABLE_SCORERS, TABLE_WORKFLOW_SNAPSHOT, TABLE_RESOURCES, TABLE_MESSAGES, TABLE_THREADS } from '@mastra/core/storage/constants';
 import { v } from 'convex/values';
 
 // src/server/cache.ts
@@ -227,6 +227,41 @@ var TABLE_INDEX_MAP = {
     { name: "by_created", fields: ["createdAt"] },
     { name: "by_record_id", fields: ["id"] }
   ],
+  mastra_schedules: [
+    { name: "by_workflow_status", fields: ["workflow_id", "status"] },
+    { name: "by_workflow_id", fields: ["workflow_id"] },
+    { name: "by_owner", fields: ["owner_type", "owner_id"] },
+    { name: "by_owner_id", fields: ["owner_id"] },
+    { name: "by_status_next_fire_at", fields: ["status", "next_fire_at"] },
+    { name: "by_created", fields: ["created_at"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_schedule_triggers: [
+    { name: "by_schedule_actual", fields: ["schedule_id", "actual_fire_at"] },
+    { name: "by_parent_trigger", fields: ["parent_trigger_id"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_channel_installations: [
+    { name: "by_platform_agent", fields: ["platform", "agentId"] },
+    { name: "by_webhook", fields: ["webhookId"] },
+    { name: "by_platform", fields: ["platform"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_channel_config: [
+    { name: "by_platform", fields: ["platform"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_background_tasks: [
+    { name: "by_agent_status", fields: ["agent_id", "status"] },
+    { name: "by_status_created", fields: ["status", "createdAt"] },
+    { name: "by_run", fields: ["run_id"] },
+    { name: "by_tool_call", fields: ["tool_call_id"] },
+    { name: "by_thread", fields: ["thread_id"] },
+    { name: "by_resource", fields: ["resource_id"] },
+    { name: "by_tool", fields: ["tool_name"] },
+    { name: "by_created", fields: ["createdAt"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
   mastra_vector_indexes: [
     { name: "by_name", fields: ["indexName"] },
     { name: "by_record_id", fields: ["id"] }
@@ -263,7 +298,44 @@ function findBestIndex(convexTable, filters) {
 var TABLE_VECTOR_INDEXES = "mastra_vector_indexes";
 var VECTOR_TABLE_PREFIX = "mastra_vector_";
 var CONVEX_TABLE_WORKFLOW_SNAPSHOTS = "mastra_workflow_snapshots";
+var CONVEX_TABLE_BACKGROUND_TASKS = "mastra_background_tasks";
+var CONVEX_TABLE_DOCUMENTS = "mastra_documents";
 var STORAGE_MUTATION_BATCH_SIZE = 25;
+var DEFAULT_SCHEDULE_QUERY_LIMIT = 100;
+var BACKGROUND_TASK_FIELD_ALIASES = {
+  tool_call_id: "toolCallId",
+  toolCallId: "tool_call_id",
+  tool_name: "toolName",
+  toolName: "tool_name",
+  agent_id: "agentId",
+  agentId: "agent_id",
+  run_id: "runId",
+  runId: "run_id",
+  thread_id: "threadId",
+  threadId: "thread_id",
+  resource_id: "resourceId",
+  resourceId: "resource_id",
+  suspend_payload: "suspendPayload",
+  suspendPayload: "suspend_payload",
+  retry_count: "retryCount",
+  retryCount: "retry_count",
+  max_retries: "maxRetries",
+  maxRetries: "max_retries",
+  timeout_ms: "timeoutMs",
+  timeoutMs: "timeout_ms"
+};
+function normalizeScheduleQueryLimit(limit) {
+  if (limit == null || !Number.isFinite(limit)) return DEFAULT_SCHEDULE_QUERY_LIMIT;
+  return Math.max(0, Math.floor(limit));
+}
+function applyConvexEqualityFilters(query, filters, indexedFields = /* @__PURE__ */ new Set()) {
+  const remainingFilters = filters?.filter((filter) => !indexedFields.has(filter.field));
+  if (!remainingFilters?.length) return query;
+  return query.filter((q) => {
+    const predicates = remainingFilters.map((filter) => q.eq(q.field(filter.field), filter.value));
+    return predicates.length === 1 ? predicates[0] : q.and(...predicates);
+  });
+}
 async function mapInBatches(inputs, batchSize, mapper) {
   const results = [];
   for (let index = 0; index < inputs.length; index += batchSize) {
@@ -278,6 +350,58 @@ async function findExistingDocsByIds(ids, findDoc) {
   const docs = await mapInBatches([...new Set(ids)], STORAGE_MUTATION_BATCH_SIZE, findDoc);
   return docs.filter((doc) => Boolean(doc));
 }
+function isBackgroundTasksTable(convexTable, request) {
+  return convexTable === CONVEX_TABLE_BACKGROUND_TASKS && request.tableName === TABLE_BACKGROUND_TASKS;
+}
+function matchesFilters(record, filters) {
+  return filters.every((filter) => {
+    if (record[filter.field] === filter.value) return true;
+    const alternateField = BACKGROUND_TASK_FIELD_ALIASES[filter.field];
+    return alternateField ? record[alternateField] === filter.value : false;
+  });
+}
+function mergeLegacyRecord(record, patch) {
+  const merged = { ...record };
+  for (const [field, value] of Object.entries(patch)) {
+    const alternateField = BACKGROUND_TASK_FIELD_ALIASES[field];
+    if (alternateField) delete merged[alternateField];
+    merged[field] = value;
+  }
+  return merged;
+}
+function stripPatchKeys(record, keys) {
+  const stripped = { ...record };
+  for (const key of keys) delete stripped[key];
+  return stripped;
+}
+function dedupeByRecordId(records) {
+  const seen = /* @__PURE__ */ new Set();
+  return records.filter((record) => {
+    if (record?.id == null) return true;
+    const id = String(record.id);
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+function isMissingBackgroundTaskSchemaError(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return message.includes(CONVEX_TABLE_BACKGROUND_TASKS) && (message.includes("does not exist") || message.includes("not found") || message.includes("not defined") || message.includes("no such"));
+}
+async function findGenericDocumentById(ctx, tableName, id) {
+  return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique();
+}
+async function findGenericDocumentsByTable(ctx, tableName, limit) {
+  return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table", (q) => q.eq("table", tableName)).take(limit);
+}
+async function filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords) {
+  const records = await mapInBatches(legacyRecords, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+    if (record.id == null) return record;
+    const typedDoc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", String(record.id))).unique();
+    return typedDoc ? null : record;
+  });
+  return records.filter((record) => Boolean(record));
+}
 function coalesceTypedRecordsForBatchInsert(records) {
   const recordsById = /* @__PURE__ */ new Map();
   for (const record of records) {
@@ -309,6 +433,16 @@ function resolveTable(tableName) {
       return { convexTable: CONVEX_TABLE_WORKFLOW_SNAPSHOTS, isTyped: true };
     case TABLE_SCORERS:
       return { convexTable: "mastra_scorers", isTyped: true };
+    case TABLE_SCHEDULES:
+      return { convexTable: "mastra_schedules", isTyped: true };
+    case TABLE_SCHEDULE_TRIGGERS:
+      return { convexTable: "mastra_schedule_triggers", isTyped: true };
+    case TABLE_CHANNEL_INSTALLATIONS:
+      return { convexTable: "mastra_channel_installations", isTyped: true };
+    case TABLE_CHANNEL_CONFIG:
+      return { convexTable: "mastra_channel_config", isTyped: true };
+    case TABLE_BACKGROUND_TASKS:
+      return { convexTable: CONVEX_TABLE_BACKGROUND_TASKS, isTyped: true };
     case TABLE_VECTOR_INDEXES:
       return { convexTable: "mastra_vector_indexes", isTyped: true };
     default:
@@ -325,6 +459,14 @@ var mastraStorage = mutationGeneric(async (ctx, request) => {
       return handleVectorOperation(ctx, request);
     }
     if (isTyped) {
+      if (isBackgroundTasksTable(convexTable, request)) {
+        try {
+          return await handleTypedOperation(ctx, convexTable, request);
+        } catch (error) {
+          if (!isMissingBackgroundTaskSchemaError(error)) throw error;
+          return handleGenericOperation(ctx, request);
+        }
+      }
       return handleTypedOperation(ctx, convexTable, request);
     }
     return handleGenericOperation(ctx, request);
@@ -338,6 +480,100 @@ var mastraStorage = mutationGeneric(async (ctx, request) => {
 });
 async function handleTypedOperation(ctx, convexTable, request) {
   switch (request.op) {
+    case "createSchedule": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`createSchedule is only supported for mastra_schedules`);
+      }
+      const record = request.record;
+      const id = record.id;
+      if (!id) {
+        throw new Error(`Schedule is missing an id`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+      if (existing) {
+        throw new Error(`Schedule with id "${id}" already exists`);
+      }
+      await ctx.db.insert(convexTable, record);
+      return { ok: true };
+    }
+    case "recordScheduleTrigger": {
+      if (convexTable !== "mastra_schedule_triggers") {
+        throw new Error(`recordScheduleTrigger is only supported for mastra_schedule_triggers`);
+      }
+      const record = request.record;
+      const id = record.id;
+      if (!id) {
+        throw new Error(`Schedule trigger is missing an id`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+      if (existing) {
+        throw new Error(`Schedule trigger with id "${id}" already exists`);
+      }
+      await ctx.db.insert(convexTable, record);
+      return { ok: true };
+    }
+    case "listDueSchedules": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`listDueSchedules is only supported for mastra_schedules`);
+      }
+      const query = ctx.db.query(convexTable).withIndex("by_status_next_fire_at", (q) => q.eq("status", "active").lte("next_fire_at", request.now));
+      const docs = await query.take(normalizeScheduleQueryLimit(request.limit));
+      return { ok: true, result: docs };
+    }
+    case "updateScheduleNextFire": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`updateScheduleNextFire is only supported for mastra_schedules`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+      if (!existing || existing.status !== "active" || existing.next_fire_at !== request.expectedNextFireAt) {
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, {
+        next_fire_at: request.newNextFireAt,
+        last_fire_at: request.lastFireAt,
+        last_run_id: request.lastRunId,
+        updated_at: Date.now()
+      });
+      return { ok: true, result: true };
+    }
+    case "updateSchedule": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`updateSchedule is only supported for mastra_schedules`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+      if (!existing) {
+        throw new Error(`Schedule ${request.id} not found`);
+      }
+      await ctx.db.patch(existing._id, request.patch);
+      return { ok: true, result: { ...existing, ...request.patch } };
+    }
+    case "listScheduleTriggers": {
+      if (convexTable !== "mastra_schedule_triggers") {
+        throw new Error(`listScheduleTriggers is only supported for mastra_schedule_triggers`);
+      }
+      const query = ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => {
+        let builder = q.eq("schedule_id", request.scheduleId);
+        if (request.fromActualFireAt != null) {
+          builder = builder.gte("actual_fire_at", request.fromActualFireAt);
+        }
+        if (request.toActualFireAt != null) {
+          builder = builder.lt("actual_fire_at", request.toActualFireAt);
+        }
+        return builder;
+      }).order("desc");
+      const docs = await query.take(normalizeScheduleQueryLimit(request.limit));
+      return { ok: true, result: docs };
+    }
+    case "deleteScheduleTriggers": {
+      if (convexTable !== "mastra_schedule_triggers") {
+        throw new Error(`deleteScheduleTriggers is only supported for mastra_schedule_triggers`);
+      }
+      const docs = await ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => q.eq("schedule_id", request.scheduleId)).take(STORAGE_MUTATION_BATCH_SIZE + 1);
+      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true, hasMore };
+    }
     case "insert": {
       const record = request.record;
       const id = record.id;
@@ -367,10 +603,36 @@ async function handleTypedOperation(ctx, convexTable, request) {
       });
       return { ok: true };
     }
+    case "patch": {
+      const patchRecord = stripPatchKeys(request.record, ["id"]);
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+      if (!existing) {
+        if (isBackgroundTasksTable(convexTable, request)) {
+          const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
+          if (legacy) {
+            await ctx.db.patch(legacy._id, { record: mergeLegacyRecord(legacy.record, patchRecord) });
+            return { ok: true, result: true };
+          }
+        }
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, patchRecord);
+      if (isBackgroundTasksTable(convexTable, request)) {
+        const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
+        if (legacy) {
+          await ctx.db.delete(legacy._id);
+        }
+      }
+      return { ok: true, result: true };
+    }
     case "load": {
       const keys = request.keys;
       if (keys.id) {
         const doc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", keys.id)).unique();
+        if (!doc && isBackgroundTasksTable(convexTable, request)) {
+          const legacy = await findGenericDocumentById(ctx, request.tableName, String(keys.id));
+          return { ok: true, result: legacy?.record ?? null };
+        }
         return { ok: true, result: doc || null };
       }
       if (convexTable === CONVEX_TABLE_WORKFLOW_SNAPSHOTS && typeof keys.workflow_name === "string" && typeof keys.run_id === "string") {
@@ -383,34 +645,47 @@ async function handleTypedOperation(ctx, convexTable, request) {
     }
     case "queryTable": {
       const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
-      let docs;
+      let query;
+      let indexedFields = /* @__PURE__ */ new Set();
       if (request.indexHint) {
         const hint = request.indexHint;
         if (hint.index === "by_workflow") {
-          docs = await ctx.db.query(convexTable).withIndex("by_workflow", (q) => q.eq("workflow_name", hint.workflowName)).take(maxDocs);
+          query = ctx.db.query(convexTable).withIndex("by_workflow", (q) => q.eq("workflow_name", hint.workflowName));
         } else if (hint.index === "by_workflow_run") {
-          docs = await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", hint.workflowName).eq("run_id", hint.runId)).take(maxDocs);
+          query = ctx.db.query(convexTable).withIndex(
+            "by_workflow_run",
+            (q) => q.eq("workflow_name", hint.workflowName).eq("run_id", hint.runId)
+          );
         } else {
-          docs = await ctx.db.query(convexTable).take(maxDocs);
+          query = ctx.db.query(convexTable);
         }
       } else if (request.filters && request.filters.length > 0) {
         const match = findBestIndex(convexTable, request.filters);
         if (match) {
-          docs = await ctx.db.query(convexTable).withIndex(match.indexName, (q) => {
+          query = ctx.db.query(convexTable).withIndex(match.indexName, (q) => {
             let builder = q;
             for (const filter of match.indexedFilters) {
               builder = builder.eq(filter.field, filter.value);
             }
             return builder;
-          }).take(maxDocs);
+          });
+          indexedFields = new Set(match.indexedFilters.map((filter) => filter.field));
         } else {
-          docs = await ctx.db.query(convexTable).take(maxDocs);
+          query = ctx.db.query(convexTable);
         }
       } else {
-        docs = await ctx.db.query(convexTable).take(maxDocs);
+        query = ctx.db.query(convexTable);
       }
-      if (request.filters && request.filters.length > 0) {
-        docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
+      let docs = await applyConvexEqualityFilters(query, request.filters, indexedFields).take(maxDocs);
+      if (isBackgroundTasksTable(convexTable, request)) {
+        const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, maxDocs);
+        let legacyRecords = legacyDocs.map((doc) => doc.record);
+        if (request.filters && request.filters.length > 0) {
+          legacyRecords = legacyRecords.filter((record) => matchesFilters(record, request.filters));
+        }
+        legacyRecords = await filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords);
+        docs.push(...legacyRecords);
+        docs = dedupeByRecordId(docs);
       }
       if (request.limit) {
         docs = docs.slice(0, request.limit);
@@ -421,15 +696,27 @@ async function handleTypedOperation(ctx, convexTable, request) {
     case "dropTable": {
       const docs = await ctx.db.query(convexTable).take(STORAGE_MUTATION_BATCH_SIZE + 1);
       const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
-      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      let docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      let legacyHasMore = false;
+      if (!hasMore && docsToDelete.length < STORAGE_MUTATION_BATCH_SIZE && isBackgroundTasksTable(convexTable, request)) {
+        const remainingBatchSize = STORAGE_MUTATION_BATCH_SIZE - docsToDelete.length;
+        const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, remainingBatchSize + 1);
+        legacyHasMore = legacyDocs.length > remainingBatchSize;
+        docsToDelete = docsToDelete.concat(legacyHasMore ? legacyDocs.slice(0, remainingBatchSize) : legacyDocs);
+      }
       await deleteDocs(ctx, docsToDelete);
-      return { ok: true, hasMore };
+      return { ok: true, hasMore: hasMore || legacyHasMore };
     }
     case "deleteMany": {
       const docsToDelete = await findExistingDocsByIds(
         request.ids,
         (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()
       );
+      if (isBackgroundTasksTable(convexTable, request)) {
+        docsToDelete.push(
+          ...await findExistingDocsByIds(request.ids, (id) => findGenericDocumentById(ctx, request.tableName, id))
+        );
+      }
       await deleteDocs(ctx, docsToDelete);
       return { ok: true };
     }
@@ -484,6 +771,15 @@ async function handleVectorOperation(ctx, request) {
       });
       return { ok: true };
     }
+    case "patch": {
+      const patchRecord = stripPatchKeys(request.record, ["id", "indexName"]);
+      const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", request.id)).unique();
+      if (!existing) {
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, patchRecord);
+      return { ok: true, result: true };
+    }
     case "load": {
       const keys = request.keys;
       if (keys.id) {
@@ -565,6 +861,17 @@ async function handleGenericOperation(ctx, request) {
       });
       return { ok: true };
     }
+    case "patch": {
+      const patchRecord = stripPatchKeys(request.record, ["id"]);
+      const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(request.id))).unique();
+      if (!existing) {
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, {
+        record: tableName === TABLE_BACKGROUND_TASKS ? mergeLegacyRecord(existing.record, patchRecord) : { ...existing.record, ...patchRecord }
+      });
+      return { ok: true, result: true };
+    }
     case "load": {
       const keys = request.keys;
       if (keys.id) {
@@ -581,7 +888,7 @@ async function handleGenericOperation(ctx, request) {
       let records = docs.map((doc) => doc.record);
       if (request.filters && request.filters.length > 0) {
         records = records.filter(
-          (record) => request.filters.every((filter) => record?.[filter.field] === filter.value)
+          (record) => tableName === TABLE_BACKGROUND_TASKS ? matchesFilters(record, request.filters) : request.filters.every((filter) => record?.[filter.field] === filter.value)
         );
       }
       if (request.limit) {
@@ -883,5 +1190,5 @@ var mastraNativeVectorMutation = mutationGeneric({
 });
 
 export { mastraCache, mastraNativeVectorAction, mastraNativeVectorMutation, mastraNativeVectorQuery, mastraStorage };
-//# sourceMappingURL=chunk-FZDLZ4S3.js.map
-//# sourceMappingURL=chunk-FZDLZ4S3.js.map
+//# sourceMappingURL=chunk-AJFME2ZF.js.map
+//# sourceMappingURL=chunk-AJFME2ZF.js.map