@mastra/convex 1.3.2 → 1.4.0

package/dist/index.cjs

@@ -1,19 +1,14 @@
 'use strict';
 
-var chunk6P3LEDHY_cjs = require('./chunk-6P3LEDHY.cjs');
-var chunkSFRHJGSM_cjs = require('./chunk-SFRHJGSM.cjs');
+var chunk2KILIA33_cjs = require('./chunk-2KILIA33.cjs');
+var chunkZCCKLZQH_cjs = require('./chunk-ZCCKLZQH.cjs');
 var cache = require('@mastra/core/cache');
 var storage = require('@mastra/core/storage');
-var crypto = require('crypto');
 var base = require('@mastra/core/base');
 var agent = require('@mastra/core/agent');
 var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-
 // src/cache/client.ts
 var DEFAULT_CACHE_FUNCTION = "mastra/cache:handle";
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
@@ -281,6 +276,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) {
@@ -337,7 +337,10 @@ var ConvexDB = class extends base.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",
@@ -546,6 +549,67 @@ var ConvexDB = class extends base.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 === storage.TABLE_WORKFLOW_SNAPSHOT && !normalized.id) {
@@ -554,7 +618,7 @@ var ConvexDB = class extends base.MastraBase {
       normalized.id = workflowName ? `${workflowName}-${runId}` : runId;
     }
     if (!normalized.id) {
-      normalized.id = crypto__default.default.randomUUID();
+      normalized.id = crypto.randomUUID();
     }
     for (const [key, value] of Object.entries(normalized)) {
       if (value instanceof Date) {
@@ -907,7 +971,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 = storage.safelyParseJSON(value);
+  if (!Array.isArray(parsed)) return void 0;
+  return parsed.map((chunk) => parseOMChunk(chunk));
+}
+function parseStoredOMRecord(doc) {
+  const config = storage.safelyParseJSON(doc.config);
+  const metadata = doc.metadata ? storage.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 storage.MemoryStorage {
+  supportsObservationalMemory = true;
   #db;
   constructor(config) {
     super();
@@ -920,6 +1047,7 @@ var MemoryConvex = class extends storage.MemoryStorage {
     await this.#db.clearTable({ tableName: storage.TABLE_THREADS });
     await this.#db.clearTable({ tableName: storage.TABLE_MESSAGES });
     await this.#db.clearTable({ tableName: storage.TABLE_RESOURCES });
+    await this.#db.clearTable({ tableName: TABLE_OBSERVATIONAL_MEMORY2 });
   }
   async getThreadById({
     threadId,
@@ -1113,6 +1241,51 @@ var MemoryConvex = class extends storage.MemoryStorage {
       hasMore
     };
   }
+  async listMessagesByResourceId(args) {
+    const { resourceId, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    if (page < 0) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CONVEX", "LIST_MESSAGES_BY_RESOURCE_ID", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("CONVEX", "LIST_MESSAGES_BY_RESOURCE_ID", "INVALID_PAGE"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { page, perPage }
+        },
+        new Error("page value too large")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    let rows = await this.#db.queryTable(storage.TABLE_MESSAGES, [{ field: "resourceId", value: resourceId }]);
+    rows = storage.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 agent.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: [] };
@@ -1252,6 +1425,16 @@ var MemoryConvex = class extends storage.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];
@@ -1358,6 +1541,357 @@ var MemoryConvex = class extends storage.MemoryStorage {
       }
     }
   }
+  // ============================================
+  // Observational Memory Methods
+  // ============================================
+  getOMKey(threadId, resourceId) {
+    return threadId ? `thread:${threadId}` : `resource:${resourceId}`;
+  }
+  omRecordNotFound(operation, id) {
+    return new error.MastraError({
+      id: storage.createStorageErrorId("CONVEX", operation, "NOT_FOUND"),
+      text: `Observational memory record not found: ${id}`,
+      domain: error.ErrorDomain.STORAGE,
+      category: error.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 error.MastraError({
+        id: storage.createStorageErrorId("CONVEX", "SET_PENDING_MESSAGE_TOKENS", "INVALID_INPUT"),
+        text: `Invalid tokenCount: must be a finite non-negative number, got ${tokenCount}`,
+        domain: error.ErrorDomain.STORAGE,
+        category: error.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) {
@@ -1423,7 +1957,7 @@ function recordToSchedule(record) {
 }
 function triggerToRecord(trigger) {
   return {
-    id: trigger.id ?? crypto__default.default.randomUUID(),
+    id: trigger.id ?? crypto.randomUUID(),
     schedule_id: trigger.scheduleId,
     run_id: trigger.runId,
     scheduled_fire_at: trigger.scheduledFireAt,
@@ -1623,7 +2157,7 @@ var ScoresConvex = class extends storage.ScoresStorage {
     const now = /* @__PURE__ */ new Date();
     const record = {
       ...score,
-      id: crypto__default.default.randomUUID(),
+      id: crypto.randomUUID(),
       createdAt: now.toISOString(),
       updatedAt: now.toISOString()
     };
@@ -1947,7 +2481,7 @@ var ConvexVector = class extends vector.MastraVector {
     };
   }
   async upsert({ indexName, vectors, ids, metadata }) {
-    const vectorIds = ids ?? vectors.map(() => crypto__default.default.randomUUID());
+    const vectorIds = ids ?? vectors.map(() => crypto.randomUUID());
     const records = vectors.map((vector, i) => ({
       id: vectorIds[i],
       embedding: vector,
@@ -2299,7 +2833,7 @@ var ConvexNativeVector = class extends vector.MastraVector {
     if (metadata && !metadata.every(isMetadataRecord)) {
       throw new Error("ConvexNativeVector.upsert: metadata entries must be objects when provided");
     }
-    const vectorIds = ids ?? vectors.map(() => crypto__default.default.randomUUID());
+    const vectorIds = ids ?? vectors.map(() => crypto.randomUUID());
     if (new Set(vectorIds).size !== vectorIds.length) {
       throw new Error("ConvexNativeVector.upsert: ids must be unique");
     }
@@ -2452,127 +2986,135 @@ var ConvexNativeVector = class extends vector.MastraVector {
 
 Object.defineProperty(exports, "mastraCache", {
   enumerable: true,
-  get: function () { return chunk6P3LEDHY_cjs.mastraCache; }
+  get: function () { return chunk2KILIA33_cjs.mastraCache; }
 });
 Object.defineProperty(exports, "mastraNativeVectorAction", {
   enumerable: true,
-  get: function () { return chunk6P3LEDHY_cjs.mastraNativeVectorAction; }
+  get: function () { return chunk2KILIA33_cjs.mastraNativeVectorAction; }
 });
 Object.defineProperty(exports, "mastraNativeVectorMutation", {
   enumerable: true,
-  get: function () { return chunk6P3LEDHY_cjs.mastraNativeVectorMutation; }
+  get: function () { return chunk2KILIA33_cjs.mastraNativeVectorMutation; }
 });
 Object.defineProperty(exports, "mastraNativeVectorQuery", {
   enumerable: true,
-  get: function () { return chunk6P3LEDHY_cjs.mastraNativeVectorQuery; }
+  get: function () { return chunk2KILIA33_cjs.mastraNativeVectorQuery; }
 });
 Object.defineProperty(exports, "mastraStorage", {
   enumerable: true,
-  get: function () { return chunk6P3LEDHY_cjs.mastraStorage; }
+  get: function () { return chunk2KILIA33_cjs.mastraStorage; }
 });
 Object.defineProperty(exports, "TABLE_BACKGROUND_TASKS", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_BACKGROUND_TASKS; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_BACKGROUND_TASKS; }
 });
 Object.defineProperty(exports, "TABLE_CHANNEL_CONFIG", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_CHANNEL_CONFIG; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_CHANNEL_CONFIG; }
 });
 Object.defineProperty(exports, "TABLE_CHANNEL_INSTALLATIONS", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_CHANNEL_INSTALLATIONS; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_CHANNEL_INSTALLATIONS; }
 });
 Object.defineProperty(exports, "TABLE_MESSAGES", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_MESSAGES; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_MESSAGES; }
+});
+Object.defineProperty(exports, "TABLE_OBSERVATIONAL_MEMORY", {
+  enumerable: true,
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_OBSERVATIONAL_MEMORY; }
 });
 Object.defineProperty(exports, "TABLE_RESOURCES", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_RESOURCES; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_RESOURCES; }
 });
 Object.defineProperty(exports, "TABLE_SCHEDULES", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_SCHEDULES; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_SCHEDULES; }
 });
 Object.defineProperty(exports, "TABLE_SCHEDULE_TRIGGERS", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_SCHEDULE_TRIGGERS; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_SCHEDULE_TRIGGERS; }
 });
 Object.defineProperty(exports, "TABLE_SCORERS", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_SCORERS; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_SCORERS; }
 });
 Object.defineProperty(exports, "TABLE_THREADS", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_THREADS; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_THREADS; }
 });
 Object.defineProperty(exports, "TABLE_WORKFLOW_SNAPSHOT", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.TABLE_WORKFLOW_SNAPSHOT; }
+  get: function () { return chunkZCCKLZQH_cjs.TABLE_WORKFLOW_SNAPSHOT; }
 });
 Object.defineProperty(exports, "defineMastraNativeVectorTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.defineMastraNativeVectorTable; }
+  get: function () { return chunkZCCKLZQH_cjs.defineMastraNativeVectorTable; }
 });
 Object.defineProperty(exports, "mastraBackgroundTasksTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraBackgroundTasksTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraBackgroundTasksTable; }
 });
 Object.defineProperty(exports, "mastraCacheListItemsTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraCacheListItemsTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraCacheListItemsTable; }
 });
 Object.defineProperty(exports, "mastraCacheTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraCacheTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraCacheTable; }
 });
 Object.defineProperty(exports, "mastraChannelConfigTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraChannelConfigTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraChannelConfigTable; }
 });
 Object.defineProperty(exports, "mastraChannelInstallationsTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraChannelInstallationsTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraChannelInstallationsTable; }
 });
 Object.defineProperty(exports, "mastraDocumentsTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraDocumentsTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraDocumentsTable; }
 });
 Object.defineProperty(exports, "mastraMessagesTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraMessagesTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraMessagesTable; }
+});
+Object.defineProperty(exports, "mastraObservationalMemoryTable", {
+  enumerable: true,
+  get: function () { return chunkZCCKLZQH_cjs.mastraObservationalMemoryTable; }
 });
 Object.defineProperty(exports, "mastraResourcesTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraResourcesTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraResourcesTable; }
 });
 Object.defineProperty(exports, "mastraScheduleTriggersTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraScheduleTriggersTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraScheduleTriggersTable; }
 });
 Object.defineProperty(exports, "mastraSchedulesTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraSchedulesTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraSchedulesTable; }
 });
 Object.defineProperty(exports, "mastraScoresTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraScoresTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraScoresTable; }
 });
 Object.defineProperty(exports, "mastraThreadsTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraThreadsTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraThreadsTable; }
 });
 Object.defineProperty(exports, "mastraVectorIndexesTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraVectorIndexesTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraVectorIndexesTable; }
 });
 Object.defineProperty(exports, "mastraVectorsTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraVectorsTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraVectorsTable; }
 });
 Object.defineProperty(exports, "mastraWorkflowSnapshotsTable", {
   enumerable: true,
-  get: function () { return chunkSFRHJGSM_cjs.mastraWorkflowSnapshotsTable; }
+  get: function () { return chunkZCCKLZQH_cjs.mastraWorkflowSnapshotsTable; }
 });
 exports.ConvexCacheClient = ConvexCacheClient;
 exports.ConvexNativeVector = ConvexNativeVector;