@smithers-orchestrator/memory 0.24.2 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/memory",
-  "version": "0.24.2",
+  "version": "0.25.0",
   "description": "Persistent and semantic memory services for Smithers",
   "type": "module",
   "sideEffects": false,
@@ -38,11 +38,11 @@
     "drizzle-orm": "^0.45.2",
     "effect": "^3.21.1",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/db": "0.24.2",
-    "@smithers-orchestrator/errors": "0.24.2",
-    "@smithers-orchestrator/graph": "0.24.2",
-    "@smithers-orchestrator/scheduler": "0.24.2",
-    "@smithers-orchestrator/observability": "0.24.2"
+    "@smithers-orchestrator/db": "0.25.0",
+    "@smithers-orchestrator/errors": "0.25.0",
+    "@smithers-orchestrator/observability": "0.25.0",
+    "@smithers-orchestrator/scheduler": "0.25.0",
+    "@smithers-orchestrator/graph": "0.25.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/Summarizer.js

@@ -1,21 +1,92 @@
 import { Effect } from "effect";
 /** @typedef {import("./MemoryProcessor.ts").MemoryProcessor} MemoryProcessor */
 
+const RECENT_MESSAGE_COUNT = 2;
+
+/**
+ * @param {import("./MemoryMessage.ts").MemoryMessage} message
+ * @returns {string}
+ */
+function renderMessage(message) {
+    let content = message.contentJson;
+    try {
+        const parsed = JSON.parse(message.contentJson);
+        content = typeof parsed === "string" ? parsed : JSON.stringify(parsed);
+    }
+    catch {
+        // Preserve raw content when it is not JSON.
+    }
+    return `${message.role}: ${content}`;
+}
+
+/**
+ * @param {unknown} result
+ * @returns {string}
+ */
+function extractSummary(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (result && typeof result === "object") {
+        if ("text" in result && typeof result.text === "string") {
+            return result.text;
+        }
+        if ("output" in result && typeof result.output === "string") {
+            return result.output;
+        }
+    }
+    return JSON.stringify(result);
+}
+
 /**
  * @param {{ run: (prompt: string) => Promise<any> }} agent
  * @returns {MemoryProcessor}
  */
-export function Summarizer(_agent) {
+export function Summarizer(agent) {
     /**
    * @param {MemoryStore} store
    * @returns {Effect.Effect<void, SmithersError>}
    */
-    function processEffect(_store) {
+    function processEffect(store) {
         return Effect.gen(function* () {
-            // Summarizer operates on a specific thread's messages, compressing
-            // older messages into a summary. Without a thread context, it logs
-            // and returns. This is a structural placeholder.
-            yield* Effect.logInfo("Summarizer: configured — operates at thread level");
+            const threads = yield* store.listThreadsEffect();
+            let summarized = 0;
+            for (const thread of threads) {
+                const messages = yield* store.listMessagesEffect(thread.threadId);
+                if (messages.length <= RECENT_MESSAGE_COUNT) {
+                    continue;
+                }
+                const oldMessages = messages.slice(0, -RECENT_MESSAGE_COUNT);
+                const recentMessages = messages.slice(-RECENT_MESSAGE_COUNT);
+                if (oldMessages.length === 1 && oldMessages[0].role === "system") {
+                    continue;
+                }
+                const prompt = [
+                    "Summarize these older conversation messages for future context.",
+                    "Keep durable user preferences, decisions, facts, and unresolved tasks.",
+                    "",
+                    oldMessages.map(renderMessage).join("\n"),
+                ].join("\n");
+                const result = yield* Effect.tryPromise(() => agent.run(prompt));
+                const summary = extractSummary(result);
+                // Save the summary BEFORE deleting the old messages so there is no
+                // data-loss window: if the summary write fails the originals are
+                // still present (recoverable), and if the delete fails afterwards
+                // the originals plus the summary coexist (harmless — the next run
+                // re-summarizes and deletes them). The state where the old
+                // messages are gone and no summary exists is never reachable.
+                yield* store.saveMessageEffect({
+                    id: `summary-${crypto.randomUUID()}`,
+                    threadId: thread.threadId,
+                    role: "system",
+                    contentJson: JSON.stringify({ type: "summary", text: summary }),
+                    createdAtMs: oldMessages[0].createdAtMs,
+                });
+                yield* store.deleteMessagesEffect(thread.threadId, oldMessages.map((message) => message.id));
+                yield* Effect.logInfo(`Summarizer: compressed ${oldMessages.length} messages before ${recentMessages[0]?.id ?? "end"}`);
+                summarized += 1;
+            }
+            yield* Effect.logInfo(`Summarizer: summarized ${summarized} threads`);
         }).pipe(Effect.annotateLogs({ processor: "Summarizer" }), Effect.withLogSpan("memory:processor:summarizer"));
     }
     return {

package/src/TokenLimiter.js

@@ -12,13 +12,24 @@ export function TokenLimiter(maxTokens) {
    * @param {MemoryStore} store
    * @returns {Effect.Effect<void, SmithersError>}
    */
-    function processEffect(_store) {
+    function processEffect(store) {
         return Effect.gen(function* () {
-            // Token limiter operates at the thread level; without a specific thread
-            // context it logs and returns. In practice, this processor is invoked
-            // with a store that wraps a specific thread. For now, this is a no-op
-            // placeholder that documents the intended behaviour.
-            yield* Effect.logInfo(`TokenLimiter: configured for ${maxTokens} tokens (${charBudget} chars) — operates at thread level`);
+            const threads = yield* store.listThreadsEffect();
+            let deleted = 0;
+            for (const thread of threads) {
+                const messages = yield* store.listMessagesEffect(thread.threadId);
+                let charCount = messages.reduce((total, message) => total + message.contentJson.length, 0);
+                const deleteIds = [];
+                for (const message of messages) {
+                    if (charCount <= charBudget) {
+                        break;
+                    }
+                    deleteIds.push(message.id);
+                    charCount -= message.contentJson.length;
+                }
+                deleted += yield* store.deleteMessagesEffect(thread.threadId, deleteIds);
+            }
+            yield* Effect.logInfo(`TokenLimiter: deleted ${deleted} messages to enforce ${maxTokens} token budget`);
         }).pipe(Effect.annotateLogs({ processor: "TokenLimiter", maxTokens }), Effect.withLogSpan("memory:processor:token-limiter"));
     }
     return {

package/src/index.d.ts

@@ -83,12 +83,14 @@ type MemoryStore$2 = {
     listFacts: (ns: MemoryNamespace$3) => Promise<MemoryFact$1[]>;
     createThread: (ns: MemoryNamespace$3, title?: string) => Promise<MemoryThread$1>;
     getThread: (threadId: string) => Promise<MemoryThread$1 | undefined>;
+    listThreads: () => Promise<MemoryThread$1[]>;
     deleteThread: (threadId: string) => Promise<void>;
     saveMessage: (msg: Omit<MemoryMessage$1, "createdAtMs"> & {
         createdAtMs?: number;
     }) => Promise<void>;
     listMessages: (threadId: string, limit?: number) => Promise<MemoryMessage$1[]>;
     countMessages: (threadId: string) => Promise<number>;
+    deleteMessages: (threadId: string, messageIds: string[]) => Promise<number>;
     deleteExpiredFacts: () => Promise<number>;
     getFactEffect: (ns: MemoryNamespace$3, key: string) => Effect.Effect<MemoryFact$1 | undefined, SmithersError>;
     setFactEffect: (ns: MemoryNamespace$3, key: string, value: unknown, ttlMs?: number) => Effect.Effect<void, SmithersError>;
@@ -96,12 +98,14 @@ type MemoryStore$2 = {
     listFactsEffect: (ns: MemoryNamespace$3) => Effect.Effect<MemoryFact$1[], SmithersError>;
     createThreadEffect: (ns: MemoryNamespace$3, title?: string) => Effect.Effect<MemoryThread$1, SmithersError>;
     getThreadEffect: (threadId: string) => Effect.Effect<MemoryThread$1 | undefined, SmithersError>;
+    listThreadsEffect: () => Effect.Effect<MemoryThread$1[], SmithersError>;
     deleteThreadEffect: (threadId: string) => Effect.Effect<void, SmithersError>;
     saveMessageEffect: (msg: Omit<MemoryMessage$1, "createdAtMs"> & {
         createdAtMs?: number;
     }) => Effect.Effect<void, SmithersError>;
     listMessagesEffect: (threadId: string, limit?: number) => Effect.Effect<MemoryMessage$1[], SmithersError>;
     countMessagesEffect: (threadId: string) => Effect.Effect<number, SmithersError>;
+    deleteMessagesEffect: (threadId: string, messageIds: string[]) => Effect.Effect<number, SmithersError>;
     deleteExpiredFactsEffect: () => Effect.Effect<number, SmithersError>;
 };
 

package/src/store/MemoryStore.ts

@@ -20,12 +20,14 @@ export type MemoryStore = {
   listFacts: (ns: MemoryNamespace) => Promise<MemoryFact[]>;
   createThread: (ns: MemoryNamespace, title?: string) => Promise<MemoryThread>;
   getThread: (threadId: string) => Promise<MemoryThread | undefined>;
+  listThreads: () => Promise<MemoryThread[]>;
   deleteThread: (threadId: string) => Promise<void>;
   saveMessage: (
     msg: Omit<MemoryMessage, "createdAtMs"> & { createdAtMs?: number },
   ) => Promise<void>;
   listMessages: (threadId: string, limit?: number) => Promise<MemoryMessage[]>;
   countMessages: (threadId: string) => Promise<number>;
+  deleteMessages: (threadId: string, messageIds: string[]) => Promise<number>;
   deleteExpiredFacts: () => Promise<number>;
   getFactEffect: (
     ns: MemoryNamespace,
@@ -51,6 +53,7 @@ export type MemoryStore = {
   getThreadEffect: (
     threadId: string,
   ) => Effect.Effect<MemoryThread | undefined, SmithersError>;
+  listThreadsEffect: () => Effect.Effect<MemoryThread[], SmithersError>;
   deleteThreadEffect: (
     threadId: string,
   ) => Effect.Effect<void, SmithersError>;
@@ -64,5 +67,9 @@ export type MemoryStore = {
   countMessagesEffect: (
     threadId: string,
   ) => Effect.Effect<number, SmithersError>;
+  deleteMessagesEffect: (
+    threadId: string,
+    messageIds: string[],
+  ) => Effect.Effect<number, SmithersError>;
   deleteExpiredFactsEffect: () => Effect.Effect<number, SmithersError>;
 };

package/src/store/MemoryStoreLive.js

@@ -1,4 +1,4 @@
-import { and, eq, sql } from "drizzle-orm";
+import { and, eq, inArray, sql } from "drizzle-orm";
 import { Effect, Layer, Metric } from "effect";
 import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
 import { dbQueryDuration } from "@smithers-orchestrator/observability/metrics";
@@ -194,20 +194,38 @@ function makeMemoryStore(db) {
             .limit(1)).pipe(Effect.map((rows) => rows[0]));
     }
     /**
+   * @returns {Effect.Effect<MemoryThread[], SmithersError>}
+   */
+    function listThreadsEffect() {
+        return readEffect("memory listThreads", () => db
+            .select()
+            .from(smithersMemoryThreads)
+            .orderBy(smithersMemoryThreads.createdAtMs)).pipe(Effect.map((rows) => rows.map((row) => ({
+            threadId: row.threadId,
+            namespace: row.namespace,
+            title: row.title,
+            metadataJson: row.metadataJson,
+            createdAtMs: row.createdAtMs,
+            updatedAtMs: row.updatedAtMs,
+        }))));
+    }
+    /**
    * @param {string} threadId
    * @returns {Effect.Effect<void, SmithersError>}
    */
     function deleteThreadEffect(threadId) {
-        return Effect.gen(function* () {
-            // Delete messages first
-            yield* writeEffect("memory deleteThreadMessages", () => db
-                .delete(smithersMemoryMessages)
-                .where(eq(smithersMemoryMessages.threadId, threadId)));
-            // Delete the thread
-            yield* writeEffect("memory deleteThread", () => db
-                .delete(smithersMemoryThreads)
-                .where(eq(smithersMemoryThreads.threadId, threadId)));
-        });
+        // Delete the messages and the thread row atomically so a failure on the
+        // second write can't leave the thread without its messages (or vice versa).
+        return writeEffect("memory deleteThread", () => Promise.resolve(
+            db.transaction((tx) => {
+                tx.delete(smithersMemoryMessages)
+                    .where(eq(smithersMemoryMessages.threadId, threadId))
+                    .run();
+                tx.delete(smithersMemoryThreads)
+                    .where(eq(smithersMemoryThreads.threadId, threadId))
+                    .run();
+            }),
+        ));
     }
     // --- Message Effects ---
     /**
@@ -217,14 +235,32 @@ function makeMemoryStore(db) {
     function saveMessageEffect(msg) {
         return Effect.gen(function* () {
             yield* Metric.increment(memoryMessageSaves);
-            yield* writeEffect("memory saveMessage", () => db.insert(smithersMemoryMessages).values({
+            const createdAtMs = msg.createdAtMs ?? nowMs();
+            // Idempotent: re-saving a message with the same id (e.g. on
+            // crash-resume, deterministic replay, or fork/restore where ids are
+            // derived deterministically) must be a safe no-op upsert rather than
+            // a UNIQUE-constraint crash. Mirrors setFact's onConflictDoUpdate.
+            yield* writeEffect("memory saveMessage", () => db
+                .insert(smithersMemoryMessages)
+                .values({
                 id: msg.id,
                 threadId: msg.threadId,
                 role: msg.role,
                 contentJson: msg.contentJson,
                 runId: msg.runId ?? null,
                 nodeId: msg.nodeId ?? null,
-                createdAtMs: msg.createdAtMs ?? nowMs(),
+                createdAtMs,
+            })
+                .onConflictDoUpdate({
+                target: smithersMemoryMessages.id,
+                set: {
+                    threadId: msg.threadId,
+                    role: msg.role,
+                    contentJson: msg.contentJson,
+                    runId: msg.runId ?? null,
+                    nodeId: msg.nodeId ?? null,
+                    createdAtMs,
+                },
             }));
         });
     }
@@ -240,7 +276,7 @@ function makeMemoryStore(db) {
                 .from(smithersMemoryMessages)
                 .where(eq(smithersMemoryMessages.threadId, threadId))
                 .orderBy(smithersMemoryMessages.createdAtMs);
-            if (limit) {
+            if (limit !== undefined) {
                 query = query.limit(limit);
             }
             return query;
@@ -264,6 +300,19 @@ function makeMemoryStore(db) {
             .from(smithersMemoryMessages)
             .where(eq(smithersMemoryMessages.threadId, threadId))).pipe(Effect.map((rows) => rows[0]?.count ?? 0));
     }
+    /**
+   * @param {string} threadId
+   * @param {string[]} messageIds
+   * @returns {Effect.Effect<number, SmithersError>}
+   */
+    function deleteMessagesEffect(threadId, messageIds) {
+        if (messageIds.length === 0) {
+            return Effect.succeed(0);
+        }
+        return writeEffect("memory deleteMessages", () => db
+            .delete(smithersMemoryMessages)
+            .where(and(eq(smithersMemoryMessages.threadId, threadId), inArray(smithersMemoryMessages.id, messageIds)))).pipe(Effect.map((result) => result?.changes ?? result?.rowsAffected ?? 0));
+    }
     // --- Maintenance ---
     /**
    * @returns {Effect.Effect<number, SmithersError>}
@@ -283,10 +332,12 @@ function makeMemoryStore(db) {
         listFacts: (ns) => Effect.runPromise(listFactsEffect(ns)),
         createThread: (ns, title) => Effect.runPromise(createThreadEffect(ns, title)),
         getThread: (threadId) => Effect.runPromise(getThreadEffect(threadId)),
+        listThreads: () => Effect.runPromise(listThreadsEffect()),
         deleteThread: (threadId) => Effect.runPromise(deleteThreadEffect(threadId)),
         saveMessage: (msg) => Effect.runPromise(saveMessageEffect(msg)),
         listMessages: (threadId, limit) => Effect.runPromise(listMessagesEffect(threadId, limit)),
         countMessages: (threadId) => Effect.runPromise(countMessagesEffect(threadId)),
+        deleteMessages: (threadId, messageIds) => Effect.runPromise(deleteMessagesEffect(threadId, messageIds)),
         deleteExpiredFacts: () => Effect.runPromise(deleteExpiredFactsEffect()),
         // Effect variants
         getFactEffect,
@@ -295,10 +346,12 @@ function makeMemoryStore(db) {
         listFactsEffect,
         createThreadEffect,
         getThreadEffect,
+        listThreadsEffect,
         deleteThreadEffect,
         saveMessageEffect,
         listMessagesEffect,
         countMessagesEffect,
+        deleteMessagesEffect,
         deleteExpiredFactsEffect,
     };
 }

package/src/react-types.ts

@@ -1 +0,0 @@
-export type { TaskMemoryConfig } from "@smithers-orchestrator/graph/types";