opencode-mastra-om 0.1.4 → 0.1.6

package/dist/index.js

@@ -179825,38 +179825,75 @@ var MastraPlugin = async (ctx) => {
   }
   const om = new ObservationalMemory(omOptions);
   omLog(`[init] ObservationalMemory created, model=${config2.model ?? "default"}`);
-  const backupObservations = async (threadId, label) => {
+  const backupObservations = async (threadId, trigger) => {
     try {
       const record3 = await om.getRecord(threadId);
       const observations = record3?.activeObservations;
       if (!observations)
         return;
-      const generationCount = record3?.generationCount ?? 0;
-      const lookupKey = threadId;
-      const savedAt = new Date().toISOString();
       const db = store.turso;
       if (!db)
         return;
+      const snap = {
+        lookupKey: threadId,
+        generationCount: record3.generationCount ?? 0,
+        observations,
+        observationTokenCount: record3.observationTokenCount ?? 0,
+        lastObservedAt: record3.lastObservedAt ?? null,
+        lastReflectionAt: record3.lastReflectionAt ?? null,
+        pendingMessageTokens: record3.pendingMessageTokens ?? 0,
+        observedMessageIds: record3.observedMessageIds ?? "[]",
+        trigger,
+        savedAt: new Date().toISOString()
+      };
       await db.execute({
-        sql: `INSERT INTO mastra_om_backups (id, lookupKey, slot, generationCount, observations, savedAt)
-              SELECT hex(randomblob(16)), lookupKey, 2, generationCount, observations, savedAt
+        sql: `INSERT INTO mastra_om_backups
+                (id, lookupKey, slot, generationCount, observations, observationTokenCount,
+                 lastObservedAt, lastReflectionAt, pendingMessageTokens, observedMessageIds, trigger, savedAt)
+              SELECT hex(randomblob(16)), lookupKey, 2, generationCount, observations, observationTokenCount,
+                     lastObservedAt, lastReflectionAt, pendingMessageTokens, observedMessageIds, trigger, savedAt
               FROM mastra_om_backups WHERE lookupKey = ? AND slot = 1
               ON CONFLICT(lookupKey, slot) DO UPDATE SET
                 generationCount = excluded.generationCount,
                 observations = excluded.observations,
+                observationTokenCount = excluded.observationTokenCount,
+                lastObservedAt = excluded.lastObservedAt,
+                lastReflectionAt = excluded.lastReflectionAt,
+                pendingMessageTokens = excluded.pendingMessageTokens,
+                observedMessageIds = excluded.observedMessageIds,
+                trigger = excluded.trigger,
                 savedAt = excluded.savedAt`,
-        args: [lookupKey]
+        args: [threadId]
       });
       await db.execute({
-        sql: `INSERT INTO mastra_om_backups (id, lookupKey, slot, generationCount, observations, savedAt)
-              VALUES (hex(randomblob(16)), ?, 1, ?, ?, ?)
+        sql: `INSERT INTO mastra_om_backups
+                (id, lookupKey, slot, generationCount, observations, observationTokenCount,
+                 lastObservedAt, lastReflectionAt, pendingMessageTokens, observedMessageIds, trigger, savedAt)
+              VALUES (hex(randomblob(16)), ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?)
               ON CONFLICT(lookupKey, slot) DO UPDATE SET
                 generationCount = excluded.generationCount,
                 observations = excluded.observations,
+                observationTokenCount = excluded.observationTokenCount,
+                lastObservedAt = excluded.lastObservedAt,
+                lastReflectionAt = excluded.lastReflectionAt,
+                pendingMessageTokens = excluded.pendingMessageTokens,
+                observedMessageIds = excluded.observedMessageIds,
+                trigger = excluded.trigger,
                 savedAt = excluded.savedAt`,
-        args: [lookupKey, generationCount, observations, savedAt]
+        args: [
+          threadId,
+          snap.generationCount,
+          snap.observations,
+          snap.observationTokenCount,
+          snap.lastObservedAt,
+          snap.lastReflectionAt,
+          snap.pendingMessageTokens,
+          snap.observedMessageIds,
+          snap.trigger,
+          snap.savedAt
+        ]
       });
-      omLog(`[backup] ${label} — saved gen ${generationCount} to slot 1, rotated old slot 1 → slot 2`);
+      omLog(`[backup] ${trigger} — saved gen ${snap.generationCount} to slot 1, rotated old slot 1 → slot 2`);
     } catch (err) {
       omLog(`[backup] failed: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -180008,7 +180045,7 @@ ${OBSERVATION_CONTINUATION_HINT}`);
         }
       }),
       om_observe: tool5({
-        description: "Manually trigger an observation cycle right now, without waiting for the token threshold.",
+        description: "Manually trigger an observation cycle right now, without waiting for the token threshold. Automatically chunks large message sets if chunkTokens is configured.",
         args: {},
         async execute(_args, context2) {
           const threadId = context2.sessionID;
@@ -180019,8 +180056,54 @@ ${OBSERVATION_CONTINUATION_HINT}`);
               return "No messages to observe.";
             const mastraMessages = convertMessages2(resp.data, threadId);
             await backupObservations(threadId, "pre-observe");
-            await runObserve(threadId, mastraMessages);
-            return "Observation cycle triggered. Check memory_status for results.";
+            const chunkTokens = config2.chunkTokens;
+            if (!chunkTokens) {
+              await runObserve(threadId, mastraMessages);
+              return "Observation cycle triggered. Check om_status for results.";
+            }
+            const tokenCounter = new TokenCounter;
+            const chunks = [];
+            let currentChunk = [];
+            let currentTokens = 0;
+            for (const msg of mastraMessages) {
+              const msgTokens = tokenCounter.countMessages([msg]);
+              if (currentTokens + msgTokens > chunkTokens && currentChunk.length > 0) {
+                chunks.push(currentChunk);
+                currentChunk = [msg];
+                currentTokens = msgTokens;
+              } else {
+                currentChunk.push(msg);
+                currentTokens += msgTokens;
+              }
+            }
+            if (currentChunk.length > 0)
+              chunks.push(currentChunk);
+            if (chunks.length === 1) {
+              await runObserve(threadId, mastraMessages);
+              return "Observation cycle triggered (single chunk). Check om_status for results.";
+            }
+            omLog(`[observe] chunked into ${chunks.length} chunks of ~${chunkTokens} tokens each`);
+            ctx.client.tui.showToast({
+              body: { title: "Mastra OM", message: `Observing in ${chunks.length} chunks...`, variant: "info", duration: 5000 }
+            });
+            const refThreshold = resolveThreshold(omOptions.reflection?.observationTokens ?? 60000);
+            const reflectAt = Math.floor(refThreshold * 0.8);
+            for (let i = 0;i < chunks.length; i++) {
+              omLog(`[observe] processing chunk ${i + 1}/${chunks.length} (${chunks[i].length} messages)`);
+              await runObserve(threadId, chunks[i]);
+              if (i < chunks.length - 1) {
+                const record3 = await om.getRecord(threadId);
+                const obsTokens = record3?.observationTokenCount ?? 0;
+                if (obsTokens >= reflectAt) {
+                  omLog(`[observe] observations at ${obsTokens} tokens (>= ${reflectAt}), reflecting before next chunk`);
+                  ctx.client.tui.showToast({
+                    body: { title: "Mastra OM", message: `Reflecting between chunks (${i + 1}/${chunks.length})...`, variant: "info", duration: 5000 }
+                  });
+                  await om.reflect(threadId);
+                }
+              }
+            }
+            return `Observation complete — processed ${chunks.length} chunks, ${mastraMessages.length} messages total. Check om_status for results.`;
           } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             lastError = msg;
@@ -180063,6 +180146,98 @@ ${OBSERVATION_CONTINUATION_HINT}`);
           }
         }
       }),
+      om_restore: tool5({
+        description: "Restore observational memory from backup slot 1 (most recent) or slot 2 (one generation older).",
+        args: { slot: { type: "number", description: "1 = most recent backup, 2 = one generation older" } },
+        async execute(args, context2) {
+          const threadId = context2.sessionID;
+          const slot = args.slot === 2 ? 2 : 1;
+          try {
+            const db = store.turso;
+            if (!db)
+              return "Raw DB access unavailable.";
+            const result = await db.execute({
+              sql: `SELECT * FROM mastra_om_backups WHERE lookupKey = ? AND slot = ?`,
+              args: [threadId, slot]
+            });
+            const row = result.rows?.[0];
+            if (!row)
+              return `No backup found in slot ${slot}.`;
+            await db.execute({
+              sql: `UPDATE mastra_observational_memory SET
+                      activeObservations = ?,
+                      generationCount = ?,
+                      observationTokenCount = ?,
+                      lastObservedAt = ?,
+                      lastReflectionAt = ?,
+                      pendingMessageTokens = ?,
+                      observedMessageIds = ?
+                    WHERE lookupKey = ?`,
+              args: [
+                row.observations,
+                row.generationCount,
+                row.observationTokenCount,
+                row.lastObservedAt,
+                row.lastReflectionAt,
+                row.pendingMessageTokens,
+                row.observedMessageIds,
+                threadId
+              ]
+            });
+            omLog(`[restore] restored slot ${slot} — gen ${row.generationCount}, saved at ${row.savedAt}, trigger=${row.trigger}`);
+            return [
+              `✅ Restored from slot ${slot}`,
+              `  Generation: ${row.generationCount}`,
+              `  Saved at: ${row.savedAt}`,
+              `  Trigger: ${row.trigger}`,
+              `  Observation tokens: ${row.observationTokenCount}`,
+              `  Last observed: ${row.lastObservedAt ?? "never"}`,
+              `  Last reflection: ${row.lastReflectionAt ?? "never"}`
+            ].join(`
+`);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `Restore failed: ${msg}`;
+          }
+        }
+      }),
+      om_reset: tool5({
+        description: "Reset observational memory for this session to a clean slate. Backs up current state first so it can be restored via om_restore.",
+        args: {},
+        async execute(_args, context2) {
+          const threadId = context2.sessionID;
+          try {
+            const db = store.turso;
+            if (!db)
+              return "Raw DB access unavailable.";
+            await backupObservations(threadId, "pre-reset");
+            await db.execute({
+              sql: `UPDATE mastra_observational_memory SET
+                      activeObservations = '',
+                      generationCount = 0,
+                      observationTokenCount = 0,
+                      lastObservedAt = NULL,
+                      lastReflectionAt = NULL,
+                      pendingMessageTokens = 0,
+                      observedMessageIds = '[]',
+                      bufferedObservations = NULL,
+                      bufferedObservationTokens = 0,
+                      bufferedMessageIds = NULL,
+                      bufferedReflection = NULL,
+                      bufferedReflectionTokens = 0,
+                      bufferedReflectionInputTokens = 0,
+                      reflectedObservationLineCount = 0
+                    WHERE lookupKey = ?`,
+              args: [threadId]
+            });
+            omLog(`[reset] observations cleared for ${threadId}`);
+            return "✅ Observational memory reset. Previous state saved to backup slot 1 — use om_restore to recover if needed.";
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `Reset failed: ${msg}`;
+          }
+        }
+      }),
       om_config: tool5({
         description: "Show the current Mastra Observational Memory configuration.",
         args: {},

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-mastra-om",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "license": "MIT",
   "description": "Enhanced Mastra Observational Memory plugin for OpenCode — persistent cross-session memory with observation, reflection, and manual trigger tools",