@mastra/convex 1.3.2 → 1.4.0

package/dist/index.js

@@ -1,8 +1,7 @@
-export { mastraCache, mastraNativeVectorAction, mastraNativeVectorMutation, mastraNativeVectorQuery, mastraStorage } from './chunk-77UWNT5X.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';
+export { mastraCache, mastraNativeVectorAction, mastraNativeVectorMutation, mastraNativeVectorQuery, mastraStorage } from './chunk-MC2EQATP.js';
+export { TABLE_BACKGROUND_TASKS, TABLE_CHANNEL_CONFIG, TABLE_CHANNEL_INSTALLATIONS, TABLE_MESSAGES, TABLE_OBSERVATIONAL_MEMORY, TABLE_RESOURCES, TABLE_SCHEDULES, TABLE_SCHEDULE_TRIGGERS, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, defineMastraNativeVectorTable, mastraBackgroundTasksTable, mastraCacheListItemsTable, mastraCacheTable, mastraChannelConfigTable, mastraChannelInstallationsTable, mastraDocumentsTable, mastraMessagesTable, mastraObservationalMemoryTable, mastraResourcesTable, mastraScheduleTriggersTable, mastraSchedulesTable, mastraScoresTable, mastraThreadsTable, mastraVectorIndexesTable, mastraVectorsTable, mastraWorkflowSnapshotsTable } from './chunk-QWWFHN52.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, ChannelsStorage, TABLE_CHANNEL_INSTALLATIONS, TABLE_CHANNEL_CONFIG, SchedulesStorage, TABLE_SCHEDULE_TRIGGERS, TABLE_SCHEDULES, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS, normalizeScheduleTarget } from '@mastra/core/storage';
-import crypto from 'crypto';
 import { MastraBase } from '@mastra/core/base';
 import { MessageList } from '@mastra/core/agent';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
@@ -275,6 +274,11 @@ var ConvexAdminClient = class {
     return result;
   }
 };
+
+// src/storage/types.ts
+var TABLE_OBSERVATIONAL_MEMORY2 = "mastra_observational_memory";
+
+// src/storage/db/index.ts
 var LOAD_MANY_REQUEST_BATCH_SIZE = 10;
 function resolveConvexConfig(config) {
   if ("client" in config) {
@@ -331,7 +335,10 @@ var ConvexDB = class extends MastraBase {
       record: this.normalizeRecord(tableName, record)
     });
   }
-  async batchInsert({ tableName, records }) {
+  async batchInsert({
+    tableName,
+    records
+  }) {
     if (records.length === 0) return;
     await this.client.callStorage({
       op: "batchInsert",
@@ -540,6 +547,67 @@ var ConvexDB = class extends MastraBase {
       hasMore = response.hasMore ?? false;
     }
   }
+  // ============================================
+  // Observational Memory Operations
+  // These always target TABLE_OBSERVATIONAL_MEMORY — the server rejects
+  // om* operations against any other table.
+  // ============================================
+  async omGetLatest(lookupKey) {
+    return this.client.callStorage({
+      op: "omGetLatest",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      lookupKey
+    });
+  }
+  async omGetHistory(args) {
+    return this.client.callStorage({
+      op: "omGetHistory",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
+  async omUpdateActive(args) {
+    await this.client.callStorage({
+      op: "omUpdateActive",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
+  async omAppendBufferedChunk(args) {
+    await this.client.callStorage({
+      op: "omAppendBufferedChunk",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
+  async omSwapBuffered(args) {
+    return this.client.callStorage({
+      op: "omSwapBuffered",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
+  async omUpdateBufferedReflection(args) {
+    await this.client.callStorage({
+      op: "omUpdateBufferedReflection",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
+  async omSwapBufferedReflection(args) {
+    return this.client.callStorage({
+      op: "omSwapBufferedReflection",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
+  async omUpdateConfig(args) {
+    await this.client.callStorage({
+      op: "omUpdateConfig",
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      ...args
+    });
+  }
   normalizeRecord(tableName, record) {
     const normalized = { ...record };
     if (tableName === TABLE_WORKFLOW_SNAPSHOT && !normalized.id) {
@@ -901,7 +969,70 @@ function parseStoredResource(record) {
     updatedAt: new Date(record.updatedAt)
   };
 }
+function toISO(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+function serializeOMChunk(chunk) {
+  return {
+    ...chunk,
+    lastObservedAt: toISO(chunk.lastObservedAt),
+    createdAt: toISO(chunk.createdAt)
+  };
+}
+function parseOMChunk(chunk) {
+  return {
+    ...chunk,
+    lastObservedAt: new Date(chunk.lastObservedAt),
+    createdAt: new Date(chunk.createdAt)
+  };
+}
+function parseStoredOMChunks(value) {
+  if (!value) return void 0;
+  const parsed = safelyParseJSON(value);
+  if (!Array.isArray(parsed)) return void 0;
+  return parsed.map((chunk) => parseOMChunk(chunk));
+}
+function parseStoredOMRecord(doc) {
+  const config = safelyParseJSON(doc.config);
+  const metadata = doc.metadata ? safelyParseJSON(doc.metadata) : void 0;
+  return {
+    id: doc.id,
+    scope: doc.scope,
+    threadId: doc.threadId || null,
+    resourceId: doc.resourceId,
+    createdAt: new Date(doc.createdAt),
+    updatedAt: new Date(doc.updatedAt),
+    lastObservedAt: doc.lastObservedAt ? new Date(doc.lastObservedAt) : void 0,
+    originType: doc.originType || "initial",
+    generationCount: Number(doc.generationCount || 0),
+    activeObservations: doc.activeObservations || "",
+    bufferedObservationChunks: parseStoredOMChunks(doc.bufferedObservationChunks),
+    // Deprecated fields (for backward compatibility)
+    bufferedObservations: doc.activeObservationsPendingUpdate || void 0,
+    bufferedObservationTokens: doc.bufferedObservationTokens ? Number(doc.bufferedObservationTokens) : void 0,
+    bufferedMessageIds: void 0,
+    // Use bufferedObservationChunks instead
+    bufferedReflection: doc.bufferedReflection || void 0,
+    bufferedReflectionTokens: doc.bufferedReflectionTokens ? Number(doc.bufferedReflectionTokens) : void 0,
+    bufferedReflectionInputTokens: doc.bufferedReflectionInputTokens ? Number(doc.bufferedReflectionInputTokens) : void 0,
+    reflectedObservationLineCount: doc.reflectedObservationLineCount ? Number(doc.reflectedObservationLineCount) : void 0,
+    totalTokensObserved: Number(doc.totalTokensObserved || 0),
+    observationTokenCount: Number(doc.observationTokenCount || 0),
+    pendingMessageTokens: Number(doc.pendingMessageTokens || 0),
+    isReflecting: Boolean(doc.isReflecting),
+    isObserving: Boolean(doc.isObserving),
+    isBufferingObservation: Boolean(doc.isBufferingObservation),
+    isBufferingReflection: Boolean(doc.isBufferingReflection),
+    lastBufferedAtTokens: Number(doc.lastBufferedAtTokens || 0),
+    lastBufferedAtTime: doc.lastBufferedAtTime ? new Date(doc.lastBufferedAtTime) : null,
+    config: config ?? {},
+    metadata: metadata ?? void 0,
+    observedMessageIds: doc.observedMessageIds || void 0,
+    observedTimezone: doc.observedTimezone || void 0
+  };
+}
 var MemoryConvex = class extends MemoryStorage {
+  supportsObservationalMemory = true;
   #db;
   constructor(config) {
     super();
@@ -914,6 +1045,7 @@ var MemoryConvex = class extends MemoryStorage {
     await this.#db.clearTable({ tableName: TABLE_THREADS });
     await this.#db.clearTable({ tableName: TABLE_MESSAGES });
     await this.#db.clearTable({ tableName: TABLE_RESOURCES });
+    await this.#db.clearTable({ tableName: TABLE_OBSERVATIONAL_MEMORY2 });
   }
   async getThreadById({
     threadId,
@@ -1107,6 +1239,51 @@ var MemoryConvex = class extends MemoryStorage {
       hasMore
     };
   }
+  async listMessagesByResourceId(args) {
+    const { resourceId, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+    const perPage = normalizePerPage(perPageInput, 40);
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CONVEX", "LIST_MESSAGES_BY_RESOURCE_ID", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("CONVEX", "LIST_MESSAGES_BY_RESOURCE_ID", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page, perPage }
+        },
+        new Error("page value too large")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    let rows = await this.#db.queryTable(TABLE_MESSAGES, [{ field: "resourceId", value: resourceId }]);
+    rows = filterByDateRange(rows, (row) => new Date(row.createdAt), filter?.dateRange);
+    rows = this._sortStoredMessages(rows, field, direction);
+    const total = rows.length;
+    const paginatedRows = rows.slice(offset, offset + perPage);
+    const list = new MessageList().add(
+      paginatedRows.map((row) => this.parseStoredMessage(row)),
+      "memory"
+    );
+    return {
+      messages: list.get.all.db(),
+      total,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + paginatedRows.length < total
+    };
+  }
   async listMessagesById({ messageIds }) {
     if (messageIds.length === 0) {
       return { messages: [] };
@@ -1246,6 +1423,16 @@ var MemoryConvex = class extends MemoryStorage {
     });
     return parseStoredResource(updated);
   }
+  _sortStoredMessages(rows, field, direction) {
+    return 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));
+    });
+  }
   _sortMessages(messages, field, direction) {
     return messages.sort((a, b) => {
       const aValue = field === "createdAt" || field === "updatedAt" ? new Date(a[field]).getTime() : a[field];
@@ -1352,6 +1539,357 @@ var MemoryConvex = class extends MemoryStorage {
       }
     }
   }
+  // ============================================
+  // Observational Memory Methods
+  // ============================================
+  getOMKey(threadId, resourceId) {
+    return threadId ? `thread:${threadId}` : `resource:${resourceId}`;
+  }
+  omRecordNotFound(operation, id) {
+    return new MastraError({
+      id: createStorageErrorId("CONVEX", operation, "NOT_FOUND"),
+      text: `Observational memory record not found: ${id}`,
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.THIRD_PARTY,
+      details: { id }
+    });
+  }
+  async getObservationalMemory(threadId, resourceId) {
+    const lookupKey = this.getOMKey(threadId, resourceId);
+    const doc = await this.#db.omGetLatest(lookupKey);
+    return doc ? parseStoredOMRecord(doc) : null;
+  }
+  async getObservationalMemoryHistory(threadId, resourceId, limit = 10, options) {
+    const lookupKey = this.getOMKey(threadId, resourceId);
+    const docs = await this.#db.omGetHistory({
+      lookupKey,
+      limit,
+      from: options?.from ? options.from.toISOString() : void 0,
+      to: options?.to ? options.to.toISOString() : void 0,
+      offset: options?.offset ?? void 0
+    });
+    return docs.map((doc) => parseStoredOMRecord(doc));
+  }
+  async initializeObservationalMemory(input) {
+    const id = crypto.randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const lookupKey = this.getOMKey(input.threadId, input.resourceId);
+    const record = {
+      id,
+      scope: input.scope,
+      threadId: input.threadId,
+      resourceId: input.resourceId,
+      createdAt: now,
+      updatedAt: now,
+      // lastObservedAt starts undefined - all messages are "unobserved" initially
+      lastObservedAt: void 0,
+      originType: "initial",
+      generationCount: 0,
+      activeObservations: "",
+      totalTokensObserved: 0,
+      observationTokenCount: 0,
+      pendingMessageTokens: 0,
+      isReflecting: false,
+      isObserving: false,
+      isBufferingObservation: false,
+      isBufferingReflection: false,
+      lastBufferedAtTokens: 0,
+      lastBufferedAtTime: null,
+      config: input.config,
+      observedTimezone: input.observedTimezone
+    };
+    await this.#db.insert({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      record: {
+        id,
+        lookupKey,
+        scope: input.scope,
+        resourceId: input.resourceId,
+        threadId: input.threadId || null,
+        activeObservations: "",
+        activeObservationsPendingUpdate: null,
+        originType: "initial",
+        config: JSON.stringify(input.config ?? {}),
+        generationCount: 0,
+        lastObservedAt: null,
+        lastReflectionAt: null,
+        pendingMessageTokens: 0,
+        totalTokensObserved: 0,
+        observationTokenCount: 0,
+        isObserving: false,
+        isReflecting: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
+        observedTimezone: input.observedTimezone || null,
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString()
+      }
+    });
+    return record;
+  }
+  async insertObservationalMemoryRecord(record) {
+    const lookupKey = this.getOMKey(record.threadId, record.resourceId);
+    await this.#db.insert({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      record: {
+        id: record.id,
+        lookupKey,
+        scope: record.scope,
+        resourceId: record.resourceId,
+        threadId: record.threadId || null,
+        activeObservations: record.activeObservations || "",
+        activeObservationsPendingUpdate: null,
+        originType: record.originType || "initial",
+        config: JSON.stringify(record.config ?? {}),
+        generationCount: record.generationCount || 0,
+        lastObservedAt: record.lastObservedAt ? toISO(record.lastObservedAt) : null,
+        lastReflectionAt: null,
+        pendingMessageTokens: record.pendingMessageTokens || 0,
+        totalTokensObserved: record.totalTokensObserved || 0,
+        observationTokenCount: record.observationTokenCount || 0,
+        observedMessageIds: record.observedMessageIds || null,
+        bufferedObservationChunks: JSON.stringify(
+          (Array.isArray(record.bufferedObservationChunks) ? record.bufferedObservationChunks : []).map(
+            (chunk) => serializeOMChunk(chunk)
+          )
+        ),
+        bufferedReflection: record.bufferedReflection || null,
+        bufferedReflectionTokens: record.bufferedReflectionTokens ?? null,
+        bufferedReflectionInputTokens: record.bufferedReflectionInputTokens ?? null,
+        reflectedObservationLineCount: record.reflectedObservationLineCount ?? null,
+        isObserving: record.isObserving || false,
+        isReflecting: record.isReflecting || false,
+        isBufferingObservation: record.isBufferingObservation || false,
+        isBufferingReflection: record.isBufferingReflection || false,
+        lastBufferedAtTokens: record.lastBufferedAtTokens || 0,
+        lastBufferedAtTime: record.lastBufferedAtTime ? toISO(record.lastBufferedAtTime) : null,
+        observedTimezone: record.observedTimezone || null,
+        metadata: record.metadata ? JSON.stringify(record.metadata) : null,
+        createdAt: toISO(record.createdAt),
+        updatedAt: toISO(record.updatedAt)
+      }
+    });
+  }
+  async updateActiveObservations(input) {
+    await this.#db.omUpdateActive({
+      id: input.id,
+      observations: input.observations,
+      tokenCount: input.tokenCount,
+      lastObservedAt: toISO(input.lastObservedAt),
+      observedMessageIds: input.observedMessageIds ?? null,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async updateBufferedObservations(input) {
+    const chunk = {
+      id: `ombuf-${crypto.randomUUID()}`,
+      cycleId: input.chunk.cycleId,
+      observations: input.chunk.observations,
+      tokenCount: input.chunk.tokenCount,
+      messageIds: input.chunk.messageIds,
+      messageTokens: input.chunk.messageTokens,
+      lastObservedAt: toISO(input.chunk.lastObservedAt),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      suggestedContinuation: input.chunk.suggestedContinuation,
+      currentTask: input.chunk.currentTask,
+      threadTitle: input.chunk.threadTitle,
+      extractedValues: input.chunk.extractedValues,
+      extractionFailures: input.chunk.extractionFailures
+    };
+    await this.#db.omAppendBufferedChunk({
+      id: input.id,
+      chunk,
+      lastBufferedAtTime: input.lastBufferedAtTime ? toISO(input.lastBufferedAtTime) : void 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async swapBufferedToActive(input) {
+    return this.#db.omSwapBuffered({
+      id: input.id,
+      activationRatio: input.activationRatio,
+      messageTokensThreshold: input.messageTokensThreshold,
+      currentPendingTokens: input.currentPendingTokens,
+      forceMaxActivation: input.forceMaxActivation,
+      lastObservedAt: input.lastObservedAt ? toISO(input.lastObservedAt) : void 0,
+      bufferedChunks: Array.isArray(input.bufferedChunks) ? input.bufferedChunks.map((chunk) => serializeOMChunk(chunk)) : void 0,
+      now: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async createReflectionGeneration(input) {
+    const id = crypto.randomUUID();
+    const now = /* @__PURE__ */ new Date();
+    const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
+    const record = {
+      id,
+      scope: input.currentRecord.scope,
+      threadId: input.currentRecord.threadId,
+      resourceId: input.currentRecord.resourceId,
+      createdAt: now,
+      updatedAt: now,
+      lastObservedAt: input.currentRecord.lastObservedAt,
+      originType: "reflection",
+      generationCount: input.currentRecord.generationCount + 1,
+      activeObservations: input.reflection,
+      totalTokensObserved: input.currentRecord.totalTokensObserved,
+      observationTokenCount: input.tokenCount,
+      pendingMessageTokens: 0,
+      isReflecting: false,
+      isObserving: false,
+      isBufferingObservation: false,
+      isBufferingReflection: false,
+      lastBufferedAtTokens: 0,
+      lastBufferedAtTime: null,
+      config: input.currentRecord.config,
+      metadata: input.currentRecord.metadata,
+      observedTimezone: input.currentRecord.observedTimezone
+    };
+    await this.#db.insert({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      record: {
+        id,
+        lookupKey,
+        scope: record.scope,
+        resourceId: record.resourceId,
+        threadId: record.threadId || null,
+        activeObservations: input.reflection,
+        activeObservationsPendingUpdate: null,
+        originType: "reflection",
+        config: JSON.stringify(record.config ?? {}),
+        generationCount: record.generationCount,
+        lastObservedAt: record.lastObservedAt ? toISO(record.lastObservedAt) : null,
+        lastReflectionAt: now.toISOString(),
+        pendingMessageTokens: 0,
+        totalTokensObserved: record.totalTokensObserved,
+        observationTokenCount: record.observationTokenCount,
+        isObserving: false,
+        isReflecting: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
+        observedTimezone: record.observedTimezone || null,
+        metadata: record.metadata ? JSON.stringify(record.metadata) : null,
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString()
+      }
+    });
+    return record;
+  }
+  async updateBufferedReflection(input) {
+    await this.#db.omUpdateBufferedReflection({
+      id: input.id,
+      reflection: input.reflection,
+      tokenCount: input.tokenCount,
+      inputTokenCount: input.inputTokenCount,
+      reflectedObservationLineCount: input.reflectedObservationLineCount,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async swapBufferedReflectionToActive(input) {
+    const { currentRecord } = input;
+    const serializedCurrentRecord = {
+      id: currentRecord.id,
+      lookupKey: this.getOMKey(currentRecord.threadId, currentRecord.resourceId),
+      scope: currentRecord.scope,
+      threadId: currentRecord.threadId || null,
+      resourceId: currentRecord.resourceId,
+      config: JSON.stringify(currentRecord.config ?? {}),
+      metadata: currentRecord.metadata ? JSON.stringify(currentRecord.metadata) : null,
+      observedTimezone: currentRecord.observedTimezone || null,
+      lastObservedAt: currentRecord.lastObservedAt ? toISO(currentRecord.lastObservedAt) : null,
+      totalTokensObserved: currentRecord.totalTokensObserved,
+      generationCount: currentRecord.generationCount
+    };
+    const doc = await this.#db.omSwapBufferedReflection({
+      currentRecord: serializedCurrentRecord,
+      newId: crypto.randomUUID(),
+      tokenCount: input.tokenCount,
+      now: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return parseStoredOMRecord(doc);
+  }
+  async setReflectingFlag(id, isReflecting) {
+    const found = await this.#db.patch({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      id,
+      record: { isReflecting, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    if (!found) {
+      throw this.omRecordNotFound("SET_REFLECTING_FLAG", id);
+    }
+  }
+  async setObservingFlag(id, isObserving) {
+    const found = await this.#db.patch({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      id,
+      record: { isObserving, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    if (!found) {
+      throw this.omRecordNotFound("SET_OBSERVING_FLAG", id);
+    }
+  }
+  async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
+    const found = await this.#db.patch({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      id,
+      record: {
+        isBufferingObservation: isBuffering,
+        ...lastBufferedAtTokens !== void 0 ? { lastBufferedAtTokens } : {},
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (!found) {
+      throw this.omRecordNotFound("SET_BUFFERING_OBSERVATION_FLAG", id);
+    }
+  }
+  async setBufferingReflectionFlag(id, isBuffering) {
+    const found = await this.#db.patch({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      id,
+      record: { isBufferingReflection: isBuffering, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    if (!found) {
+      throw this.omRecordNotFound("SET_BUFFERING_REFLECTION_FLAG", id);
+    }
+  }
+  async setPendingMessageTokens(id, tokenCount) {
+    if (typeof tokenCount !== "number" || !Number.isFinite(tokenCount) || tokenCount < 0) {
+      throw new MastraError({
+        id: createStorageErrorId("CONVEX", "SET_PENDING_MESSAGE_TOKENS", "INVALID_INPUT"),
+        text: `Invalid tokenCount: must be a finite non-negative number, got ${tokenCount}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        details: { id, tokenCount }
+      });
+    }
+    const found = await this.#db.patch({
+      tableName: TABLE_OBSERVATIONAL_MEMORY2,
+      id,
+      record: { pendingMessageTokens: tokenCount, updatedAt: /* @__PURE__ */ new Date() }
+    });
+    if (!found) {
+      throw this.omRecordNotFound("SET_PENDING_MESSAGE_TOKENS", id);
+    }
+  }
+  async clearObservationalMemory(threadId, resourceId) {
+    const lookupKey = this.getOMKey(threadId, resourceId);
+    const docs = await this.#db.queryTable(TABLE_OBSERVATIONAL_MEMORY2, [
+      { field: "lookupKey", value: lookupKey }
+    ]);
+    await this.#db.deleteMany(
+      TABLE_OBSERVATIONAL_MEMORY2,
+      docs.map((doc) => doc.id)
+    );
+  }
+  async updateObservationalMemoryConfig(input) {
+    await this.#db.omUpdateConfig({
+      id: input.id,
+      config: JSON.stringify(input.config ?? {}),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
 };
 var SCHEDULE_LIST_LIMIT = 8e3;
 function serializeJson2(value) {