@mastra/convex 1.3.2 → 1.4.0

package/dist/{chunk-77UWNT5X.js → chunk-MC2EQATP.js}

@@ -265,6 +265,10 @@ var TABLE_INDEX_MAP = {
   mastra_vector_indexes: [
     { name: "by_name", fields: ["indexName"] },
     { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_observational_memory: [
+    { name: "by_lookup_key", fields: ["lookupKey", "generationCount"] },
+    { name: "by_record_id", fields: ["id"] }
   ]
 };
 function findBestIndex(convexTable, filters) {
@@ -294,6 +298,299 @@ function findBestIndex(convexTable, filters) {
   return best ? { indexName: best.indexName, indexedFilters: best.indexedFilters } : null;
 }
 
+// src/server/observational-memory.ts
+var OM_QUERY_MAX_DOCS = 1e4;
+function parseStoredChunks(value) {
+  if (typeof value !== "string" || !value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function selectActivationBoundary(chunks, opts) {
+  const retentionFloor = opts.messageTokensThreshold * (1 - opts.activationRatio);
+  const targetMessageTokens = Math.max(0, opts.currentPendingTokens - retentionFloor);
+  let cumulativeMessageTokens = 0;
+  let bestOverBoundary = 0;
+  let bestOverTokens = 0;
+  let bestUnderBoundary = 0;
+  let bestUnderTokens = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
+    const boundary = i + 1;
+    if (cumulativeMessageTokens >= targetMessageTokens) {
+      if (bestOverBoundary === 0 || cumulativeMessageTokens < bestOverTokens) {
+        bestOverBoundary = boundary;
+        bestOverTokens = cumulativeMessageTokens;
+      }
+    } else {
+      if (cumulativeMessageTokens > bestUnderTokens) {
+        bestUnderBoundary = boundary;
+        bestUnderTokens = cumulativeMessageTokens;
+      }
+    }
+  }
+  const maxOvershoot = retentionFloor * 0.95;
+  const overshoot = bestOverTokens - targetMessageTokens;
+  const remainingAfterOver = opts.currentPendingTokens - bestOverTokens;
+  const remainingAfterUnder = opts.currentPendingTokens - bestUnderTokens;
+  const minRemaining = Math.min(1e3, retentionFloor);
+  if (opts.forceMaxActivation && bestOverBoundary > 0 && remainingAfterOver >= minRemaining) {
+    return bestOverBoundary;
+  }
+  if (bestOverBoundary > 0 && overshoot <= maxOvershoot && remainingAfterOver >= minRemaining) {
+    return bestOverBoundary;
+  }
+  if (bestUnderBoundary > 0 && remainingAfterUnder >= minRemaining) {
+    return bestUnderBoundary;
+  }
+  if (bestOverBoundary > 0) {
+    return bestOverBoundary;
+  }
+  return 1;
+}
+function mergeReflectionWithUnreflected(activeObservations, bufferedReflection, reflectedLineCount) {
+  const allLines = (activeObservations || "").split("\n");
+  const unreflectedLines = allLines.slice(reflectedLineCount);
+  const unreflectedContent = unreflectedLines.join("\n").trim();
+  return unreflectedContent ? `${bufferedReflection}
+
+${unreflectedContent}` : bufferedReflection;
+}
+function isPlainObj(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMergeOMConfig(target, source) {
+  const output = { ...target };
+  for (const key of Object.keys(source)) {
+    const tVal = target[key];
+    const sVal = source[key];
+    if (isPlainObj(tVal) && isPlainObj(sVal)) {
+      output[key] = deepMergeOMConfig(tVal, sVal);
+    } else if (sVal !== void 0) {
+      output[key] = sVal;
+    }
+  }
+  return output;
+}
+function parseJsonObject(value) {
+  if (typeof value !== "string" || !value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return isPlainObj(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function findRecordById(ctx, convexTable, id) {
+  return await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+}
+function requireRecord(doc, id) {
+  if (!doc) {
+    throw new Error(`Observational memory record not found: ${id}`);
+  }
+  return doc;
+}
+var EMPTY_SWAP_RESULT = {
+  chunksActivated: 0,
+  messageTokensActivated: 0,
+  observationTokensActivated: 0,
+  messagesActivated: 0,
+  activatedCycleIds: [],
+  activatedMessageIds: []
+};
+async function handleObservationalMemoryOperation(ctx, convexTable, request) {
+  switch (request.op) {
+    case "omGetLatest": {
+      const doc = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").first();
+      return { ok: true, result: doc ?? null };
+    }
+    case "omGetHistory": {
+      let docs = await ctx.db.query(convexTable).withIndex("by_lookup_key", (q) => q.eq("lookupKey", request.lookupKey)).order("desc").take(OM_QUERY_MAX_DOCS);
+      if (request.from) {
+        docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt >= request.from);
+      }
+      if (request.to) {
+        docs = docs.filter((doc) => typeof doc.createdAt === "string" && doc.createdAt <= request.to);
+      }
+      if (request.offset != null) {
+        docs = docs.slice(request.offset);
+      }
+      return { ok: true, result: docs.slice(0, request.limit) };
+    }
+    case "omUpdateActive": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const safeTokenCount = Number.isFinite(request.tokenCount) && request.tokenCount >= 0 ? request.tokenCount : 0;
+      await ctx.db.patch(doc._id, {
+        activeObservations: request.observations,
+        lastObservedAt: request.lastObservedAt,
+        // Reset pending tokens since we've now observed them
+        pendingMessageTokens: 0,
+        observationTokenCount: safeTokenCount,
+        totalTokensObserved: Number(doc.totalTokensObserved || 0) + safeTokenCount,
+        observedMessageIds: request.observedMessageIds,
+        updatedAt: request.updatedAt
+      });
+      return { ok: true };
+    }
+    case "omAppendBufferedChunk": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const chunks = parseStoredChunks(doc.bufferedObservationChunks);
+      chunks.push(request.chunk);
+      const patch = {
+        bufferedObservationChunks: JSON.stringify(chunks),
+        updatedAt: request.updatedAt
+      };
+      if (request.lastBufferedAtTime) {
+        patch.lastBufferedAtTime = request.lastBufferedAtTime;
+      }
+      await ctx.db.patch(doc._id, patch);
+      return { ok: true };
+    }
+    case "omSwapBuffered": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const persistedChunks = parseStoredChunks(doc.bufferedObservationChunks);
+      if (persistedChunks.length === 0) {
+        return { ok: true, result: EMPTY_SWAP_RESULT };
+      }
+      const chunks = Array.isArray(request.bufferedChunks) ? request.bufferedChunks : persistedChunks;
+      if (chunks.length === 0) {
+        return { ok: true, result: EMPTY_SWAP_RESULT };
+      }
+      const chunksToActivate = selectActivationBoundary(chunks, {
+        activationRatio: request.activationRatio,
+        messageTokensThreshold: request.messageTokensThreshold,
+        currentPendingTokens: request.currentPendingTokens,
+        forceMaxActivation: request.forceMaxActivation
+      });
+      const activatedChunks = chunks.slice(0, chunksToActivate);
+      const remainingChunks = chunks.slice(chunksToActivate);
+      const activatedContent = activatedChunks.map((c) => c.observations).join("\n\n");
+      const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
+      const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
+      const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + (c.messageIds?.length ?? 0), 0);
+      const activatedCycleIds = activatedChunks.map((c) => c.cycleId).filter((id) => !!id);
+      const activatedMessageIds = activatedChunks.flatMap((c) => c.messageIds ?? []);
+      const latestChunk = activatedChunks[activatedChunks.length - 1];
+      const lastObservedAt = request.lastObservedAt ?? latestChunk?.lastObservedAt ?? request.now;
+      const existingActive = doc.activeObservations || "";
+      const boundary = `
+
+--- message boundary (${lastObservedAt}) ---
+
+`;
+      const newActive = existingActive ? `${existingActive}${boundary}${activatedContent}` : activatedContent;
+      await ctx.db.patch(doc._id, {
+        activeObservations: newActive,
+        observationTokenCount: Number(doc.observationTokenCount || 0) + activatedTokens,
+        // Decrement pending message tokens (clamped to zero)
+        pendingMessageTokens: Math.max(0, Number(doc.pendingMessageTokens || 0) - activatedMessageTokens),
+        bufferedObservationChunks: remainingChunks.length > 0 ? JSON.stringify(remainingChunks) : null,
+        lastObservedAt,
+        updatedAt: request.now
+      });
+      const latestChunkHints = activatedChunks[activatedChunks.length - 1];
+      return {
+        ok: true,
+        result: {
+          chunksActivated: activatedChunks.length,
+          messageTokensActivated: activatedMessageTokens,
+          observationTokensActivated: activatedTokens,
+          messagesActivated: activatedMessageCount,
+          activatedCycleIds,
+          activatedMessageIds,
+          observations: activatedContent,
+          perChunk: activatedChunks.map((c) => ({
+            cycleId: c.cycleId ?? "",
+            messageTokens: c.messageTokens ?? 0,
+            observationTokens: c.tokenCount,
+            messageCount: c.messageIds?.length ?? 0,
+            observations: c.observations
+          })),
+          suggestedContinuation: latestChunkHints?.suggestedContinuation ?? void 0,
+          currentTask: latestChunkHints?.currentTask ?? void 0
+        }
+      };
+    }
+    case "omUpdateBufferedReflection": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const existingContent = doc.bufferedReflection || "";
+      await ctx.db.patch(doc._id, {
+        bufferedReflection: existingContent ? `${existingContent}
+
+${request.reflection}` : request.reflection,
+        bufferedReflectionTokens: Number(doc.bufferedReflectionTokens || 0) + request.tokenCount,
+        bufferedReflectionInputTokens: Number(doc.bufferedReflectionInputTokens || 0) + request.inputTokenCount,
+        reflectedObservationLineCount: request.reflectedObservationLineCount,
+        updatedAt: request.updatedAt
+      });
+      return { ok: true };
+    }
+    case "omSwapBufferedReflection": {
+      const { currentRecord, newId, tokenCount, now } = request;
+      const doc = requireRecord(await findRecordById(ctx, convexTable, currentRecord.id), currentRecord.id);
+      const bufferedReflection = doc.bufferedReflection || "";
+      if (!bufferedReflection) {
+        throw new Error("No buffered reflection to swap");
+      }
+      const newObservations = mergeReflectionWithUnreflected(
+        doc.activeObservations || "",
+        bufferedReflection,
+        Number(doc.reflectedObservationLineCount || 0)
+      );
+      const newRecord = {
+        id: newId,
+        lookupKey: currentRecord.lookupKey,
+        scope: currentRecord.scope,
+        resourceId: currentRecord.resourceId,
+        threadId: currentRecord.threadId,
+        activeObservations: newObservations,
+        activeObservationsPendingUpdate: null,
+        originType: "reflection",
+        config: currentRecord.config,
+        generationCount: currentRecord.generationCount + 1,
+        lastObservedAt: currentRecord.lastObservedAt,
+        lastReflectionAt: now,
+        pendingMessageTokens: 0,
+        totalTokensObserved: currentRecord.totalTokensObserved,
+        observationTokenCount: tokenCount,
+        isObserving: false,
+        isReflecting: false,
+        isBufferingObservation: false,
+        isBufferingReflection: false,
+        lastBufferedAtTokens: 0,
+        lastBufferedAtTime: null,
+        observedTimezone: currentRecord.observedTimezone,
+        metadata: currentRecord.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      await ctx.db.insert(convexTable, newRecord);
+      await ctx.db.patch(doc._id, {
+        bufferedReflection: null,
+        bufferedReflectionTokens: null,
+        bufferedReflectionInputTokens: null,
+        reflectedObservationLineCount: null,
+        updatedAt: now
+      });
+      return { ok: true, result: newRecord };
+    }
+    case "omUpdateConfig": {
+      const doc = requireRecord(await findRecordById(ctx, convexTable, request.id), request.id);
+      const existing = parseJsonObject(doc.config);
+      const incoming = parseJsonObject(request.config);
+      const merged = deepMergeOMConfig(existing, incoming);
+      await ctx.db.patch(doc._id, {
+        config: JSON.stringify(merged),
+        updatedAt: request.updatedAt
+      });
+      return { ok: true };
+    }
+  }
+}
+
 // src/server/workflow-snapshot.ts
 var PENDING_MARKER_KEY = "__mastra_pending__";
 function isPendingMarker(val) {
@@ -373,6 +670,7 @@ 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 CONVEX_TABLE_OBSERVATIONAL_MEMORY = "mastra_observational_memory";
 var STORAGE_MUTATION_BATCH_SIZE = 25;
 var LOAD_MANY_MAX_IDS_PER_REQUEST = 10;
 var DEFAULT_SCHEDULE_QUERY_LIMIT = 100;
@@ -525,6 +823,8 @@ function resolveTable(tableName) {
       return { convexTable: CONVEX_TABLE_BACKGROUND_TASKS, isTyped: true };
     case TABLE_VECTOR_INDEXES:
       return { convexTable: "mastra_vector_indexes", isTyped: true };
+    case CONVEX_TABLE_OBSERVATIONAL_MEMORY:
+      return { convexTable: CONVEX_TABLE_OBSERVATIONAL_MEMORY, isTyped: true };
     default:
       if (tableName.startsWith(VECTOR_TABLE_PREFIX)) {
         return { convexTable: "mastra_vectors", isTyped: true };
@@ -585,6 +885,19 @@ function mergeMetadata(existing, update) {
 }
 async function handleTypedOperation(ctx, convexTable, request) {
   switch (request.op) {
+    case "omGetLatest":
+    case "omGetHistory":
+    case "omUpdateActive":
+    case "omAppendBufferedChunk":
+    case "omSwapBuffered":
+    case "omUpdateBufferedReflection":
+    case "omSwapBufferedReflection":
+    case "omUpdateConfig": {
+      if (convexTable !== CONVEX_TABLE_OBSERVATIONAL_MEMORY) {
+        throw new Error(`${request.op} is only supported for ${CONVEX_TABLE_OBSERVATIONAL_MEMORY}`);
+      }
+      return handleObservationalMemoryOperation(ctx, convexTable, request);
+    }
     case "createSchedule": {
       if (convexTable !== "mastra_schedules") {
         throw new Error(`createSchedule is only supported for mastra_schedules`);
@@ -1453,5 +1766,5 @@ var mastraNativeVectorMutation = mutationGeneric({
 });
 
 export { mastraCache, mastraNativeVectorAction, mastraNativeVectorMutation, mastraNativeVectorQuery, mastraStorage };
-//# sourceMappingURL=chunk-77UWNT5X.js.map
-//# sourceMappingURL=chunk-77UWNT5X.js.map
+//# sourceMappingURL=chunk-MC2EQATP.js.map
+//# sourceMappingURL=chunk-MC2EQATP.js.map