@mastra/convex 1.1.0-alpha.0 → 1.2.0-alpha.0

package/dist/index.js

@@ -1,7 +1,7 @@
-export { mastraCache, mastraNativeVectorAction, mastraNativeVectorMutation, mastraNativeVectorQuery, mastraStorage } from './chunk-FZDLZ4S3.js';
-export { TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, defineMastraNativeVectorTable, mastraCacheListItemsTable, mastraCacheTable, mastraDocumentsTable, mastraMessagesTable, mastraResourcesTable, mastraScoresTable, mastraThreadsTable, mastraVectorIndexesTable, mastraVectorsTable, mastraWorkflowSnapshotsTable } from './chunk-JPWDG4L3.js';
+export { mastraCache, mastraNativeVectorAction, mastraNativeVectorMutation, mastraNativeVectorQuery, mastraStorage } from './chunk-AJFME2ZF.js';
+export { TABLE_BACKGROUND_TASKS, TABLE_CHANNEL_CONFIG, TABLE_CHANNEL_INSTALLATIONS, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCHEDULES, TABLE_SCHEDULE_TRIGGERS, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, defineMastraNativeVectorTable, mastraBackgroundTasksTable, mastraCacheListItemsTable, mastraCacheTable, mastraChannelConfigTable, mastraChannelInstallationsTable, mastraDocumentsTable, mastraMessagesTable, mastraResourcesTable, mastraScheduleTriggersTable, mastraSchedulesTable, mastraScoresTable, mastraThreadsTable, mastraVectorIndexesTable, mastraVectorsTable, mastraWorkflowSnapshotsTable } from './chunk-MC75WADX.js';
 import { MastraServerCache } from '@mastra/core/cache';
-import { MastraCompositeStore, createVectorErrorId, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, safelyParseJSON, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS } from '@mastra/core/storage';
+import { MastraCompositeStore, createVectorErrorId, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, safelyParseJSON, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS, ChannelsStorage, TABLE_CHANNEL_INSTALLATIONS, TABLE_CHANNEL_CONFIG, SchedulesStorage, TABLE_SCHEDULE_TRIGGERS, TABLE_SCHEDULES, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS } from '@mastra/core/storage';
 import crypto from 'crypto';
 import { MastraBase } from '@mastra/core/base';
 import { MessageList } from '@mastra/core/agent';
@@ -337,6 +337,18 @@ var ConvexDB = class extends MastraBase {
       records: records.map((record) => this.normalizeRecord(tableName, record))
     });
   }
+  async patch({
+    tableName,
+    id,
+    record
+  }) {
+    return this.client.callStorage({
+      op: "patch",
+      tableName,
+      id,
+      record: this.normalizePatch(record)
+    });
+  }
   async load({ tableName, keys }) {
     const result = await this.client.callStorage({
       op: "load",
@@ -345,12 +357,13 @@ var ConvexDB = class extends MastraBase {
     });
     return result;
   }
-  async queryTable(tableName, filters, indexHint) {
+  async queryTable(tableName, filters, indexHint, limit) {
     return this.client.callStorage({
       op: "queryTable",
       tableName,
       filters,
-      indexHint
+      indexHint,
+      limit
     });
   }
   async deleteMany(tableName, ids) {
@@ -361,6 +374,85 @@ var ConvexDB = class extends MastraBase {
       ids
     });
   }
+  async createSchedule(record) {
+    if (!record.id) {
+      throw new Error(`Schedule is missing an id`);
+    }
+    await this.client.callStorage({
+      op: "createSchedule",
+      tableName: TABLE_SCHEDULES,
+      record: this.normalizeRecord(TABLE_SCHEDULES, record)
+    });
+  }
+  async recordScheduleTrigger(record) {
+    if (!record.id) {
+      throw new Error(`Schedule trigger is missing an id`);
+    }
+    await this.client.callStorage({
+      op: "recordScheduleTrigger",
+      tableName: TABLE_SCHEDULE_TRIGGERS,
+      record: this.normalizeRecord(TABLE_SCHEDULE_TRIGGERS, record)
+    });
+  }
+  async listDueSchedules(now, limit) {
+    return this.client.callStorage({
+      op: "listDueSchedules",
+      tableName: TABLE_SCHEDULES,
+      now,
+      limit
+    });
+  }
+  async updateScheduleNextFire({
+    id,
+    expectedNextFireAt,
+    newNextFireAt,
+    lastFireAt,
+    lastRunId
+  }) {
+    return this.client.callStorage({
+      op: "updateScheduleNextFire",
+      tableName: TABLE_SCHEDULES,
+      id,
+      expectedNextFireAt,
+      newNextFireAt,
+      lastFireAt,
+      lastRunId
+    });
+  }
+  async updateSchedule({ id, patch }) {
+    return this.client.callStorage({
+      op: "updateSchedule",
+      tableName: TABLE_SCHEDULES,
+      id,
+      patch
+    });
+  }
+  async listScheduleTriggers({
+    scheduleId,
+    fromActualFireAt,
+    toActualFireAt,
+    limit
+  }) {
+    return this.client.callStorage({
+      op: "listScheduleTriggers",
+      tableName: TABLE_SCHEDULE_TRIGGERS,
+      scheduleId,
+      fromActualFireAt,
+      toActualFireAt,
+      limit
+    });
+  }
+  async deleteScheduleTriggers(scheduleId) {
+    let hasMore = true;
+    while (hasMore) {
+      const response = await this.client.callStorageRaw({
+        op: "deleteScheduleTriggers",
+        tableName: TABLE_SCHEDULE_TRIGGERS,
+        scheduleId
+      });
+      hasMore = response.hasMore ?? false;
+    }
+  }
   normalizeRecord(tableName, record) {
     const normalized = { ...record };
     if (tableName === TABLE_WORKFLOW_SNAPSHOT && !normalized.id) {
@@ -378,29 +470,69 @@ var ConvexDB = class extends MastraBase {
     }
     return normalized;
   }
+  normalizePatch(record) {
+    const normalized = { ...record };
+    for (const [key, value] of Object.entries(normalized)) {
+      if (value instanceof Date) {
+        normalized[key] = value.toISOString();
+      }
+    }
+    return normalized;
+  }
 };
 
 // src/storage/domains/background-tasks/index.ts
 function serializeJson(v) {
-  if (typeof v === "object" && v != null) return JSON.stringify(v);
-  return v ?? void 0;
+  if (v === void 0 || v === null) return null;
+  return JSON.stringify(v);
+}
+function serializeRequiredJson(v) {
+  return JSON.stringify(v ?? {});
 }
 function toStored(task) {
   return {
-    ...task,
-    args: serializeJson(task.args),
+    id: task.id,
+    status: task.status,
+    tool_call_id: task.toolCallId,
+    tool_name: task.toolName,
+    agent_id: task.agentId,
+    run_id: task.runId,
+    thread_id: task.threadId ?? null,
+    resource_id: task.resourceId ?? null,
+    args: serializeRequiredJson(task.args),
     result: serializeJson(task.result),
     error: serializeJson(task.error),
-    suspendPayload: serializeJson(task.suspendPayload),
+    suspend_payload: serializeJson(task.suspendPayload),
+    retry_count: task.retryCount,
+    max_retries: task.maxRetries,
+    timeout_ms: task.timeoutMs,
     createdAt: task.createdAt.toISOString(),
-    startedAt: task.startedAt?.toISOString(),
-    suspendedAt: task.suspendedAt?.toISOString(),
-    completedAt: task.completedAt?.toISOString()
+    startedAt: task.startedAt?.toISOString() ?? null,
+    suspendedAt: task.suspendedAt?.toISOString() ?? null,
+    completedAt: task.completedAt?.toISOString() ?? null
   };
 }
+function toStoredPatch(update) {
+  const patch = {};
+  if (update.status !== void 0) patch.status = update.status;
+  if ("result" in update) patch.result = serializeJson(update.result);
+  if ("error" in update) patch.error = serializeJson(update.error);
+  if ("suspendPayload" in update) patch.suspend_payload = serializeJson(update.suspendPayload);
+  if (update.retryCount !== void 0) patch.retry_count = update.retryCount;
+  if (update.maxRetries !== void 0) patch.max_retries = update.maxRetries;
+  if (update.timeoutMs !== void 0) patch.timeout_ms = update.timeoutMs;
+  if ("startedAt" in update) patch.startedAt = update.startedAt?.toISOString() ?? null;
+  if ("suspendedAt" in update) patch.suspendedAt = update.suspendedAt?.toISOString() ?? null;
+  if ("completedAt" in update) patch.completedAt = update.completedAt?.toISOString() ?? null;
+  return patch;
+}
+function legacyOrCurrent(stored, currentKey, legacyKey) {
+  return currentKey in stored ? stored[currentKey] : stored[legacyKey];
+}
 function fromStored(stored) {
-  const parseJson = (val) => {
-    if (!val) return void 0;
+  const record = stored;
+  const parseJson3 = (val) => {
+    if (val == null) return void 0;
     try {
       return JSON.parse(val);
     } catch {
@@ -408,27 +540,32 @@ function fromStored(stored) {
     }
   };
   return {
-    id: stored.id,
-    status: stored.status,
-    toolName: stored.toolName,
-    toolCallId: stored.toolCallId,
-    args: parseJson(stored.args) ?? {},
-    agentId: stored.agentId,
-    threadId: stored.threadId,
-    resourceId: stored.resourceId,
-    runId: stored.runId,
-    result: parseJson(stored.result),
-    error: parseJson(stored.error),
-    suspendPayload: parseJson(stored.suspendPayload),
-    retryCount: stored.retryCount,
-    maxRetries: stored.maxRetries,
-    timeoutMs: stored.timeoutMs,
-    createdAt: new Date(stored.createdAt),
-    startedAt: stored.startedAt ? new Date(stored.startedAt) : void 0,
-    suspendedAt: stored.suspendedAt ? new Date(stored.suspendedAt) : void 0,
-    completedAt: stored.completedAt ? new Date(stored.completedAt) : void 0
+    id: record.id,
+    status: record.status,
+    toolName: legacyOrCurrent(record, "tool_name", "toolName"),
+    toolCallId: legacyOrCurrent(record, "tool_call_id", "toolCallId"),
+    args: parseJson3(record.args) ?? {},
+    agentId: legacyOrCurrent(record, "agent_id", "agentId"),
+    threadId: legacyOrCurrent(record, "thread_id", "threadId") ?? void 0,
+    resourceId: legacyOrCurrent(record, "resource_id", "resourceId") ?? void 0,
+    runId: legacyOrCurrent(record, "run_id", "runId"),
+    result: parseJson3(record.result),
+    error: parseJson3(record.error),
+    suspendPayload: parseJson3(legacyOrCurrent(record, "suspend_payload", "suspendPayload")),
+    retryCount: legacyOrCurrent(record, "retry_count", "retryCount"),
+    maxRetries: legacyOrCurrent(record, "max_retries", "maxRetries"),
+    timeoutMs: legacyOrCurrent(record, "timeout_ms", "timeoutMs"),
+    createdAt: new Date(record.createdAt),
+    startedAt: record.startedAt ? new Date(record.startedAt) : void 0,
+    suspendedAt: record.suspendedAt ? new Date(record.suspendedAt) : void 0,
+    completedAt: record.completedAt ? new Date(record.completedAt) : void 0
   };
 }
+function hasDeleteFilter(filter) {
+  return Boolean(
+    (Array.isArray(filter.status) ? filter.status.length > 0 : filter.status) || filter.agentId || filter.threadId || filter.resourceId || filter.toolName || filter.toolCallId || filter.runId || filter.fromDate || filter.toDate
+  );
+}
 var BackgroundTasksConvex = class extends BackgroundTasksStorage {
   #db;
   constructor(config) {
@@ -443,26 +580,34 @@ var BackgroundTasksConvex = class extends BackgroundTasksStorage {
     await this.#db.insert({ tableName: TABLE_BACKGROUND_TASKS, record: toStored(task) });
   }
   async updateTask(taskId, update) {
-    const existing = await this.getTask(taskId);
-    if (!existing) return;
-    const merged = { ...existing };
-    if ("status" in update) merged.status = update.status;
-    if ("result" in update) merged.result = update.result;
-    if ("error" in update) merged.error = update.error;
-    if ("suspendPayload" in update) merged.suspendPayload = update.suspendPayload;
-    if ("retryCount" in update) merged.retryCount = update.retryCount;
-    if ("startedAt" in update) merged.startedAt = update.startedAt;
-    if ("suspendedAt" in update) merged.suspendedAt = update.suspendedAt;
-    if ("completedAt" in update) merged.completedAt = update.completedAt;
-    await this.#db.deleteMany(TABLE_BACKGROUND_TASKS, [taskId]);
-    await this.#db.insert({ tableName: TABLE_BACKGROUND_TASKS, record: toStored(merged) });
+    const patch = toStoredPatch(update);
+    if (Object.keys(patch).length === 0) return;
+    await this.#db.patch({
+      tableName: TABLE_BACKGROUND_TASKS,
+      id: taskId,
+      record: patch
+    });
   }
   async getTask(taskId) {
     const data = await this.#db.load({ tableName: TABLE_BACKGROUND_TASKS, keys: { id: taskId } });
     return data ? fromStored(data) : null;
   }
   async listTasks(filter) {
-    const all = await this.#db.queryTable(TABLE_BACKGROUND_TASKS);
+    const queryFilters = [];
+    if (typeof filter.status === "string") queryFilters.push({ field: "status", value: filter.status });
+    if (Array.isArray(filter.status) && filter.status.length === 1) {
+      queryFilters.push({ field: "status", value: filter.status[0] });
+    }
+    if (filter.agentId) queryFilters.push({ field: "agent_id", value: filter.agentId });
+    if (filter.threadId) queryFilters.push({ field: "thread_id", value: filter.threadId });
+    if (filter.resourceId) queryFilters.push({ field: "resource_id", value: filter.resourceId });
+    if (filter.toolName) queryFilters.push({ field: "tool_name", value: filter.toolName });
+    if (filter.toolCallId) queryFilters.push({ field: "tool_call_id", value: filter.toolCallId });
+    if (filter.runId) queryFilters.push({ field: "run_id", value: filter.runId });
+    const all = await this.#db.queryTable(
+      TABLE_BACKGROUND_TASKS,
+      queryFilters.length > 0 ? queryFilters : void 0
+    );
     let tasks = all.map(fromStored);
     if (filter.status) {
       const s = Array.isArray(filter.status) ? filter.status : [filter.status];
@@ -470,6 +615,7 @@ var BackgroundTasksConvex = class extends BackgroundTasksStorage {
     }
     if (filter.agentId) tasks = tasks.filter((t) => t.agentId === filter.agentId);
     if (filter.threadId) tasks = tasks.filter((t) => t.threadId === filter.threadId);
+    if (filter.resourceId) tasks = tasks.filter((t) => t.resourceId === filter.resourceId);
     if (filter.toolName) tasks = tasks.filter((t) => t.toolName === filter.toolName);
     if (filter.toolCallId) tasks = tasks.filter((t) => t.toolCallId === filter.toolCallId);
     if (filter.runId) tasks = tasks.filter((t) => t.runId === filter.runId);
@@ -502,6 +648,7 @@ var BackgroundTasksConvex = class extends BackgroundTasksStorage {
     await this.#db.deleteMany(TABLE_BACKGROUND_TASKS, [taskId]);
   }
   async deleteTasks(filter) {
+    if (!hasDeleteFilter(filter)) return;
     const { tasks } = await this.listTasks(filter);
     const taskIds = tasks.map((t) => t.id);
     await this.#db.deleteMany(TABLE_BACKGROUND_TASKS, taskIds);
@@ -515,6 +662,141 @@ var BackgroundTasksConvex = class extends BackgroundTasksStorage {
     return total;
   }
 };
+var statusPriority = {
+  active: 0,
+  pending: 1,
+  error: 2
+};
+function stringifyJson(value) {
+  return JSON.stringify(value);
+}
+function parseJson(value, context) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid channel data JSON for ${context}`, { cause: error });
+  }
+}
+function installationToRecord(installation, existingRecord) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: installation.id,
+    platform: installation.platform,
+    agentId: installation.agentId,
+    status: installation.status,
+    webhookId: installation.webhookId ?? null,
+    data: stringifyJson(installation.data),
+    configHash: installation.configHash ?? null,
+    error: installation.error ?? null,
+    createdAt: existingRecord?.createdAt ?? installation.createdAt?.toISOString() ?? now,
+    updatedAt: now
+  };
+}
+function recordToInstallation(record) {
+  return {
+    id: record.id,
+    platform: record.platform,
+    agentId: record.agentId,
+    status: record.status,
+    webhookId: record.webhookId ?? void 0,
+    data: parseJson(record.data, `installation ${record.id}`),
+    configHash: record.configHash ?? void 0,
+    error: record.error ?? void 0,
+    createdAt: new Date(record.createdAt),
+    updatedAt: new Date(record.updatedAt)
+  };
+}
+function configToRecord(config) {
+  return {
+    id: config.platform,
+    platform: config.platform,
+    data: stringifyJson(config.data),
+    updatedAt: config.updatedAt.toISOString()
+  };
+}
+function recordToConfig(record) {
+  return {
+    platform: record.platform,
+    data: parseJson(record.data, `config ${record.platform}`),
+    updatedAt: new Date(record.updatedAt)
+  };
+}
+function sortInstallationsForAgent(a, b) {
+  const statusDiff = statusPriority[a.status] - statusPriority[b.status];
+  if (statusDiff !== 0) return statusDiff;
+  return b.updatedAt.getTime() - a.updatedAt.getTime();
+}
+var ChannelsConvex = class extends ChannelsStorage {
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveConvexConfig(config);
+    this.#db = new ConvexDB(client);
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_CHANNEL_INSTALLATIONS });
+    await this.#db.clearTable({ tableName: TABLE_CHANNEL_CONFIG });
+  }
+  async saveInstallation(installation) {
+    const existingRecord = await this.#db.load({
+      tableName: TABLE_CHANNEL_INSTALLATIONS,
+      keys: { id: installation.id }
+    });
+    await this.#db.insert({
+      tableName: TABLE_CHANNEL_INSTALLATIONS,
+      record: installationToRecord(installation, existingRecord)
+    });
+  }
+  async getInstallation(id) {
+    const record = await this.#db.load({
+      tableName: TABLE_CHANNEL_INSTALLATIONS,
+      keys: { id }
+    });
+    return record ? recordToInstallation(record) : null;
+  }
+  async getInstallationByAgent(platform, agentId) {
+    const records = await this.#db.queryTable(TABLE_CHANNEL_INSTALLATIONS, [
+      { field: "platform", value: platform },
+      { field: "agentId", value: agentId }
+    ]);
+    const [installation] = records.map(recordToInstallation).sort(sortInstallationsForAgent);
+    return installation ?? null;
+  }
+  async getInstallationByWebhookId(webhookId) {
+    const records = await this.#db.queryTable(TABLE_CHANNEL_INSTALLATIONS, [
+      { field: "webhookId", value: webhookId }
+    ]);
+    const [installation] = records.map(recordToInstallation).sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+    return installation ?? null;
+  }
+  async listInstallations(platform) {
+    const records = await this.#db.queryTable(TABLE_CHANNEL_INSTALLATIONS, [
+      { field: "platform", value: platform }
+    ]);
+    return records.map(recordToInstallation).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  }
+  async deleteInstallation(id) {
+    await this.#db.deleteMany(TABLE_CHANNEL_INSTALLATIONS, [id]);
+  }
+  async saveConfig(config) {
+    await this.#db.insert({
+      tableName: TABLE_CHANNEL_CONFIG,
+      record: configToRecord(config)
+    });
+  }
+  async getConfig(platform) {
+    const record = await this.#db.load({
+      tableName: TABLE_CHANNEL_CONFIG,
+      keys: { id: platform }
+    });
+    return record ? recordToConfig(record) : null;
+  }
+  async deleteConfig(platform) {
+    await this.#db.deleteMany(TABLE_CHANNEL_CONFIG, [platform]);
+  }
+};
 var MemoryConvex = class extends MemoryStorage {
   #db;
   constructor(config) {
@@ -1000,6 +1282,247 @@ var MemoryConvex = class extends MemoryStorage {
     }
   }
 };
+var SCHEDULE_LIST_LIMIT = 8e3;
+function serializeJson2(value) {
+  return JSON.stringify(value);
+}
+function parseJson2(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function isMissingSchedulesSchemaError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /(?:Table|table)\s+(?:["'`])?(?:mastra_schedules|mastra_schedule_triggers)(?:["'`])?\s+(?:is\s+)?(?:not\s+in\s+the\s+schema|not\s+found\s+in\s+schema|not\s+found|does\s+not\s+exist)/i.test(
+    message
+  );
+}
+function scheduleToRecord(schedule) {
+  return {
+    id: schedule.id,
+    target: serializeJson2(schedule.target),
+    cron: schedule.cron,
+    timezone: schedule.timezone ?? null,
+    status: schedule.status,
+    next_fire_at: schedule.nextFireAt,
+    last_fire_at: schedule.lastFireAt ?? null,
+    last_run_id: schedule.lastRunId ?? null,
+    created_at: schedule.createdAt,
+    updated_at: schedule.updatedAt,
+    metadata: schedule.metadata == null ? null : serializeJson2(schedule.metadata),
+    owner_type: schedule.ownerType ?? null,
+    owner_id: schedule.ownerId ?? null,
+    workflow_id: schedule.target.type === "workflow" ? schedule.target.workflowId : null
+  };
+}
+function recordToSchedule(record) {
+  const target = parseJson2(record.target);
+  if (!target || typeof target !== "object" || typeof target.type !== "string") {
+    throw new Error(`Schedule ${record.id} has invalid target`);
+  }
+  const schedule = {
+    id: String(record.id),
+    target,
+    cron: String(record.cron),
+    status: String(record.status),
+    nextFireAt: Number(record.next_fire_at),
+    createdAt: Number(record.created_at),
+    updatedAt: Number(record.updated_at)
+  };
+  if (record.timezone != null) schedule.timezone = String(record.timezone);
+  if (record.last_fire_at != null) schedule.lastFireAt = Number(record.last_fire_at);
+  if (record.last_run_id != null) schedule.lastRunId = String(record.last_run_id);
+  const metadata = parseJson2(record.metadata);
+  if (metadata != null) schedule.metadata = metadata;
+  if (record.owner_type != null) schedule.ownerType = String(record.owner_type);
+  if (record.owner_id != null) schedule.ownerId = String(record.owner_id);
+  return schedule;
+}
+function triggerToRecord(trigger) {
+  return {
+    id: trigger.id ?? crypto.randomUUID(),
+    schedule_id: trigger.scheduleId,
+    run_id: trigger.runId,
+    scheduled_fire_at: trigger.scheduledFireAt,
+    actual_fire_at: trigger.actualFireAt,
+    outcome: trigger.outcome,
+    error: trigger.error ?? null,
+    trigger_kind: trigger.triggerKind ?? "schedule-fire",
+    parent_trigger_id: trigger.parentTriggerId ?? null,
+    metadata: trigger.metadata == null ? null : serializeJson2(trigger.metadata)
+  };
+}
+function recordToTrigger(record) {
+  const trigger = {
+    id: record.id != null ? String(record.id) : void 0,
+    scheduleId: String(record.schedule_id),
+    runId: record.run_id != null ? String(record.run_id) : null,
+    scheduledFireAt: Number(record.scheduled_fire_at),
+    actualFireAt: Number(record.actual_fire_at),
+    outcome: String(record.outcome),
+    triggerKind: record.trigger_kind != null ? String(record.trigger_kind) : "schedule-fire"
+  };
+  if (record.error != null) trigger.error = String(record.error);
+  if (record.parent_trigger_id != null) trigger.parentTriggerId = String(record.parent_trigger_id);
+  const metadata = parseJson2(record.metadata);
+  if (metadata != null) trigger.metadata = metadata;
+  return trigger;
+}
+var SchedulesConvex = class extends SchedulesStorage {
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveConvexConfig(config);
+    this.#db = new ConvexDB(client);
+  }
+  async init() {
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_SCHEDULE_TRIGGERS });
+    await this.#db.clearTable({ tableName: TABLE_SCHEDULES });
+  }
+  async createSchedule(schedule) {
+    await this.#db.createSchedule(scheduleToRecord(schedule));
+    return schedule;
+  }
+  async getSchedule(id) {
+    const record = await this.#db.load({ tableName: TABLE_SCHEDULES, keys: { id } });
+    return record ? recordToSchedule(record) : null;
+  }
+  async listSchedules(filter) {
+    const queryFilters = [];
+    if (filter?.status) queryFilters.push({ field: "status", value: filter.status });
+    if (filter?.ownerType !== void 0 && filter.ownerType !== null) {
+      queryFilters.push({ field: "owner_type", value: filter.ownerType });
+    }
+    if (filter?.ownerType === null) {
+      queryFilters.push({ field: "owner_type", value: null });
+    }
+    if (filter?.ownerId !== void 0 && filter.ownerId !== null) {
+      queryFilters.push({ field: "owner_id", value: filter.ownerId });
+    }
+    if (filter?.ownerId === null) {
+      queryFilters.push({ field: "owner_id", value: null });
+    }
+    if (filter?.workflowId) queryFilters.push({ field: "workflow_id", value: filter.workflowId });
+    let records;
+    try {
+      records = await this.#db.queryTable(
+        TABLE_SCHEDULES,
+        queryFilters.length ? queryFilters : void 0,
+        void 0,
+        SCHEDULE_LIST_LIMIT
+      );
+    } catch (error) {
+      if (isMissingSchedulesSchemaError(error)) {
+        this.logger.warn("Convex schedules schema is not available; returning no schedules", { error });
+        return [];
+      }
+      throw error;
+    }
+    if (records.length >= SCHEDULE_LIST_LIMIT) {
+      this.logger.warn("Convex schedules list reached the adapter limit; results may be truncated", {
+        limit: SCHEDULE_LIST_LIMIT
+      });
+    }
+    let schedules = records.map(recordToSchedule);
+    if (filter?.workflowId) {
+      schedules = schedules.filter(
+        (schedule) => schedule.target.type === "workflow" && schedule.target.workflowId === filter.workflowId
+      );
+    }
+    if (filter?.ownerType === null) {
+      schedules = schedules.filter((schedule) => (schedule.ownerType ?? null) === null);
+    }
+    if (filter?.ownerId === null) {
+      schedules = schedules.filter((schedule) => (schedule.ownerId ?? null) === null);
+    }
+    schedules.sort((a, b) => a.createdAt - b.createdAt);
+    return schedules;
+  }
+  async listDueSchedules(now, limit) {
+    let records;
+    try {
+      records = await this.#db.listDueSchedules(now, limit);
+    } catch (error) {
+      if (isMissingSchedulesSchemaError(error)) {
+        this.logger.warn("Convex schedules schema is not available; returning no due schedules", { error });
+        return [];
+      }
+      throw error;
+    }
+    return records.map(recordToSchedule);
+  }
+  async updateSchedule(id, patch) {
+    const updates = {};
+    if ("cron" in patch && patch.cron !== void 0) {
+      updates.cron = patch.cron;
+    }
+    if ("timezone" in patch) {
+      updates.timezone = patch.timezone ?? null;
+    }
+    if ("status" in patch && patch.status !== void 0) {
+      updates.status = patch.status;
+    }
+    if ("nextFireAt" in patch && patch.nextFireAt !== void 0) {
+      updates.next_fire_at = patch.nextFireAt;
+    }
+    if ("target" in patch && patch.target !== void 0) {
+      updates.target = serializeJson2(patch.target);
+      updates.workflow_id = patch.target.type === "workflow" ? patch.target.workflowId : null;
+    }
+    if ("metadata" in patch) {
+      updates.metadata = patch.metadata == null ? null : serializeJson2(patch.metadata);
+    }
+    if ("ownerType" in patch) {
+      updates.owner_type = patch.ownerType ?? null;
+    }
+    if ("ownerId" in patch) {
+      updates.owner_id = patch.ownerId ?? null;
+    }
+    if (Object.keys(updates).length === 0) {
+      const existing = await this.getSchedule(id);
+      if (!existing) {
+        throw new Error(`Schedule ${id} not found`);
+      }
+      return existing;
+    }
+    updates.updated_at = Date.now();
+    const updated = await this.#db.updateSchedule({ id, patch: updates });
+    return recordToSchedule(updated);
+  }
+  async updateScheduleNextFire(id, expectedNextFireAt, newNextFireAt, lastFireAt, lastRunId) {
+    return this.#db.updateScheduleNextFire({
+      id,
+      expectedNextFireAt,
+      newNextFireAt,
+      lastFireAt,
+      lastRunId
+    });
+  }
+  async deleteSchedule(id) {
+    await this.#db.deleteScheduleTriggers(id);
+    await this.#db.deleteMany(TABLE_SCHEDULES, [id]);
+  }
+  async recordTrigger(trigger) {
+    await this.#db.recordScheduleTrigger(triggerToRecord(trigger));
+  }
+  async listTriggers(scheduleId, opts) {
+    const triggers = await this.#db.listScheduleTriggers({
+      scheduleId,
+      fromActualFireAt: opts?.fromActualFireAt,
+      toActualFireAt: opts?.toActualFireAt,
+      limit: opts?.limit
+    });
+    return triggers.map(recordToTrigger);
+  }
+};
 var ScoresConvex = class extends ScoresStorage {
   #db;
   constructor(config) {
@@ -1280,7 +1803,9 @@ var ConvexStore = class extends MastraCompositeStore {
       memory,
       workflows,
       scores,
-      backgroundTasks: new BackgroundTasksConvex(domainConfig)
+      backgroundTasks: new BackgroundTasksConvex(domainConfig),
+      schedules: new SchedulesConvex(domainConfig),
+      channels: new ChannelsConvex(domainConfig)
     };
   }
 };