saico 2.8.0 → 2.9.0

package/README.md

@@ -1,13 +1,13 @@
 # Saico - Hierarchical AI Conversation Orchestrator
 
-Saico is a Node.js library for building AI agents with hierarchical conversations, automatic context aggregation, and enterprise-grade tool calling. It manages nested task trees where each node can have its own conversation context, system prompt, tools, and state — and the library automatically assembles the full payload sent to the LLM by walking the tree.
+Saico is a Node.js library for building AI agents with hierarchical conversations, automatic context aggregation, and enterprise-grade tool calling. It manages nested task trees where each node can have its own message queue, system prompt, tools, and state — and the library automatically assembles the full payload sent to the LLM by walking the tree.
 
 ## Features
 
 - **Hierarchical conversations** — Parent-child task trees with automatic prompt, tool, and state summary aggregation
 - **Token-aware summarization** — Automatic summarization when message history approaches token limits
 - **Tool calling** — Depth control, deferred execution, duplicate detection, repetition prevention, and timeout handling
-- **Pluggable storage** — Optional Redis persistence (auto-save via proxy) and pluggable DB backends (DynamoDB adapter included)
+- **Pluggable storage** — Optional Redis persistence (auto-save via proxy), library-level backend registration (`Saico.registerBackend`), and pluggable DB backends (DynamoDB adapter included)
 - **Isolation boundaries** — `opt.isolate` stops ancestor aggregation at any node in the tree
 - **Serialization** — Full state save/restore for long-running agents
 
@@ -54,7 +54,7 @@ agent.activate({ createQ: true });
 // Backend message (prefixed with [BACKEND] automatically)
 const reply = await agent.sendMessage('What is the weather in Tokyo?');
 
-// User-facing chat message (routed to deepest active context)
+// User-facing chat message (routed to deepest active msgs Q)
 const chatReply = await agent.recvChatMessage('Hello!');
 ```
 
@@ -83,7 +83,7 @@ agent.activate();
 await agent.sendMessage('Do something');
 await agent.recvChatMessage('User says hello');
 
-// 4. Deactivate — bubbles cleaned messages to parent, closes context
+// 4. Deactivate — bubbles cleaned messages to parent, closes msgs Q
 await agent.deactivate();
 ```
 
@@ -124,7 +124,7 @@ Root Saico (prompt: "You are a manager")
     Functions aggregated from all levels.
 ```
 
-- **`sendMessage(content, functions, opts)`** — Sends a backend message (auto-prefixed `[BACKEND]`). Uses the current or nearest ancestor context.
+- **`sendMessage(content, functions, opts)`** — Sends a backend message (auto-prefixed `[BACKEND]`). Uses the current or nearest ancestor msgs Q.
 - **`recvChatMessage(content, opts)`** — Routes a user chat message DOWN to the deepest descendant with a message queue.
 
 ### Isolation
@@ -151,12 +151,12 @@ class OrderAgent extends Saico {
 }
 ```
 
-When a Saico's context is not the deepest active one, its last 5 user/assistant messages are also included in the state summary automatically.
+When a Saico's msgs Q is not the deepest active one, its last 5 user/assistant messages are also included in the state summary automatically.
 
 ### Spawning Child Saico Instances
 
 ```js
-// Child with its own conversation context (auto-activated by spawn)
+// Child with its own msgs Q (auto-activated by spawn)
 const child = new Saico({
     name: 'subtask',
     prompt: 'Handle this specific sub-task',
@@ -166,7 +166,7 @@ const child = new Saico({
 agent.spawn(child);
 await child.sendMessage('Working on subtask...');
 
-// Child without context (uses parent's via findContext())
+// Child without msgs Q (uses parent's via findMsgs())
 const simple = new Saico({ name: 'simple' });
 agent.spawn(simple);
 await simple.sendMessage('Quick operation');
@@ -210,7 +210,8 @@ new Saico({
     // Storage
     redis: true,               // Set false to skip Redis proxy
     key: 'custom-redis-key',
-    dynamodb: {                // DynamoDB config (creates adapter)
+    store: 'my-table',         // Table name for instance persistence (closeSession/rehydrate)
+    dynamodb: {                // DynamoDB config (creates instance-level adapter)
         region: 'us-east-1',
         credentials: { accessKeyId: '...', secretAccessKey: '...' },
     },
@@ -257,15 +258,15 @@ agent.getSessionInfo();
 //   userData, uptime
 // }
 
-await agent.closeSession();  // Saves full state to Store, cancels task
+await agent.closeSession();  // prepareForStorage + save to registered backend, cancels task
 
-// Restore from Store
-const restored = await Saico.rehydrate(agent._id, { store });
+// Restore from registered backend
+const restored = await Saico.rehydrate(agent.id, { store: 'sessions' });
 ```
 
 ## Database Access
 
-Saico provides backend-agnostic DB methods. Configure via `opt.dynamodb` (auto-creates DynamoDB adapter) or `opt.db` (any adapter). Table name is required on every call. Child Saico instances without their own DB inherit the parent's adapter automatically via `_getDb()`.
+Saico provides backend-agnostic DB methods. Configure via `Saico.registerBackend('dynamodb', config)` (library-level), `opt.dynamodb` (instance-level auto-creates adapter), or `opt.db` (any adapter). Table name is required on every call. Child Saico instances without their own DB inherit the parent's adapter automatically via `_getDb()`, which also falls back to the registered backend.
 
 ```js
 // CRUD — table name required on every call
@@ -300,28 +301,42 @@ class MyAgent extends Saico {
 
 ## Serialization
 
+Both `serialize()` and `Saico.deserialize()` are async. `serialize()` calls `prepareForStorage()` first (strips `_` props, skips functions/states, compresses msgs) then `JSON.stringify`s the result.
+
 ```js
-// In-memory snapshot (raw msgs, used by Redis proxy)
-const json = agent.serialize();
-const restored = Saico.deserialize(json);
+// prepareForStorage — clean snapshot
+const data = await agent.prepareForStorage();
+
+// serialize/deserialize
+const json = await agent.serialize();
+const restored = await Saico.deserialize(json);
 
-// Durable persistence (compressed msgs, saved to Store)
+// Durable persistence (uses registered backend + opt.store table name)
 await agent.closeSession();
-const restored2 = await Saico.rehydrate(agent._id, { store });
+const restored2 = await Saico.rehydrate(agent.id, { store: 'sessions' });
 ```
 
-`serialize()` includes: id, name, prompt, userData, sessionConfig, tm_create, isolate, and full context state (raw messages, tool_digest). `closeSession()` saves the same shape but with compressed messages for durable storage.
-
-## Redis Persistence
+`prepareForStorage()` automatically picks up all non-underscore properties (id, name, prompt, userData, sessionConfig, tm_create, isolate, etc.) and produces compressed chat_history for the msgs Q.
 
-When Redis is initialized, Saico instances are automatically wrapped in an observable proxy. Any property change triggers a debounced save to Redis.
+## Initialization
 
 ```js
-const { init } = require('saico');
+const { Saico, init } = require('saico');
+
+// Initialize Redis (default: enabled) and register DynamoDB backend
+await init({
+    dynamodb: { region: 'us-east-1', credentials: { accessKeyId: 'AK', secretAccessKey: 'SK' } },
+});
+
+// Or register backend directly
+Saico.registerBackend('dynamodb', { region: 'us-east-1', credentials: { ... } });
+```
 
-// Initialize with Redis
-await init({ redis: true });
+## Redis Persistence
+
+When Redis is initialized (default: enabled via `init()`), Saico instances are automatically wrapped in an observable proxy. Any property change triggers a debounced save to Redis.
 
+```js
 const agent = new Saico({ name: 'persistent-agent' });
 agent.someProperty = 'value';  // Auto-saved to Redis
 ```
@@ -330,7 +345,7 @@ Properties prefixed with `_` are internal and not persisted.
 
 ## Tool Implementation (TOOL_ methods)
 
-Define tool implementations as `TOOL_`-prefixed methods on your Saico subclass. When the LLM returns a tool call, Context automatically searches the Saico hierarchy (current → up parents → down children) to find and invoke the matching method with parsed arguments.
+Define tool implementations as `TOOL_`-prefixed methods on your Saico subclass. When the LLM returns a tool call, Saico automatically searches the task hierarchy (current → up parents → down children) to find and invoke the matching method with parsed arguments.
 
 ```js
 class MyAgent extends Saico {
@@ -359,13 +374,13 @@ Return a string or `{ content: string, functions?: [] }`.
 
 ## Low-Level API
 
-For cases where you need a standalone context without the Saico master class:
+For cases where you need a standalone message queue without the Saico master class:
 
 ```js
-const { createContext } = require('saico');
+const { createMsgs } = require('saico');
 
-// Standalone context
-const ctx = createContext('System prompt', null, { tag: 'my-tag', token_limit: 4000 });
+// Standalone message queue
+const ctx = createMsgs('System prompt', { tag: 'my-tag', token_limit: 4000 });
 const reply = await ctx.sendMessage('user', 'Hello', functions);
 ```
 
@@ -374,11 +389,11 @@ const reply = await ctx.sendMessage('user', 'Hello', functions);
 ```
 saico/
 +-- index.js      # Thin barrel file, exports all components
-+-- saico.js      # Saico master class — owns context, spawn, DB, orchestration
++-- saico.js      # Saico master class — owns msgs Q, spawn, DB, orchestration
 +-- itask.js      # Pure task runner — hierarchy, states, cancellation, promises
 +-- msgs.js       # Conversation context (message queue, tool calls, summarization)
 +-- dynamo.js     # DynamoDB storage adapter
-+-- store.js      # Storage abstraction (Redis + pluggable backends)
++-- store.js      # Minimal storage shell (Redis helper + ID generation)
 +-- openai.js     # OpenAI API wrapper with retry logic
 +-- redis.js      # Redis persistence with observable proxy
 +-- util.js       # Utilities (token counting, logging)
@@ -390,7 +405,7 @@ saico/
 npm test
 ```
 
-296 tests covering Saico lifecycle, context ownership, spawn/spawnAndRun, task hierarchy, message handling, tool calls, DB adapters, serialization, persistence (closeSession/rehydrate), and integration flows.
+300 tests covering Saico lifecycle, msgs Q ownership, spawn/spawnAndRun, task hierarchy, message handling, tool calls, DB adapters, async serialization, prepareForStorage, backend registration, persistence (closeSession/rehydrate via registered backend), storage integration, and full hierarchy flows.
 
 ## Requirements
 

package/index.js

@@ -1,29 +1,31 @@
 'use strict';
 
 const Itask = require('./itask.js');
-const { Context, createContext } = require('./msgs.js');
-const { Store, DynamoBackend } = require('./store.js');
+const { Msgs, createMsgs } = require('./msgs.js');
+const { Store } = require('./store.js');
 const { Saico } = require('./saico.js');
 const { DynamoDBAdapter } = require('./dynamo.js');
 
 /**
  * Initialize Saico with storage configuration.
- * Sets up the Store singleton and optionally initializes Redis.
+ * Registers the backend and optionally initializes Redis.
  *
  * @param {Object} config - Configuration options
- * @param {boolean} config.redis - Whether to initialize Redis
- * @param {Object} config.dynamodb - DynamoDB backend config {table, aws}
+ * @param {boolean} [config.redis=true] - Set false to skip Redis init
+ * @param {Object} [config.dynamodb] - DynamoDB config { region, credentials, client }
  * @returns {Store} The initialized Store instance
  */
 async function init(config = {}) {
-    const store = Store.init(config);
-
-    if (config.redis) {
+    if (config.redis !== false) {
         const redis = require('./redis.js');
         await redis.init();
-        store.setRedis(redis.rclient);
     }
 
+    if (config.dynamodb)
+        Saico.registerBackend('dynamodb', config.dynamodb);
+
+    // Legacy: still init Store shell
+    const store = Store.init(config);
     return store;
 }
 
@@ -34,15 +36,14 @@ module.exports = {
 
     // Core classes
     Itask,
-    Context,
+    Msgs,
     Store,
-    DynamoBackend,
 
     // Initialization
     init,
 
     // Factory
-    createContext,
+    createMsgs,
 
     // Utilities (re-export from util.js)
     util: require('./util.js'),

package/itask.js

@@ -534,6 +534,9 @@ Itask.prototype.continue = function(ret){
     return this;
 };
 
+/* ---------- serialization ---------- */
+Itask.prototype.serialize = function(){ return JSON.stringify({}); };
+
 /* ---------- introspection / ps ---------- */
 Itask.prototype.is_running = function(){ return this.running && !this._completed; };
 Itask.prototype.is_completed = function(){ return this._completed; };

package/msgs.js

@@ -8,23 +8,17 @@ const { _log, _lerr, _ldbg } = util;
 const debug = 0;
 
 /**
- * Context - Conversation context that can be attached to any Itask.
- *
- * Key differences from the old Messages class:
- * - Uses task hierarchy instead of parent/child messages
- * - task reference replaces parent reference
- * - getMsgContext() traverses task hierarchy
- * - _createMsgQ() aggregates from task ancestors
+ * Msgs - Pure message queue with tool call handling, summarization, and LLM communication.
+ * Saico sets callback hooks after construction to wire in hierarchy access.
  */
-class Context {
-    constructor(prompt, task, config = {}) {
+class Msgs {
+    constructor(prompt, config = {}) {
         this.prompt = prompt;
-        this.task = task; // Reference to owning Itask (replaces parent)
         this.tag = config.tag || crypto.randomBytes(4).toString('hex');
         this.token_limit = config.token_limit || 1000000000;
         this.lower_limit = this.token_limit * 0.85;
         this.upper_limit = this.token_limit * 0.98;
-        this.functions = config.functions || task?.functions || null;
+        this.functions = config.functions || null;
 
         // Recursive depth and repetition control
         this.max_depth = config.max_depth || 5;
@@ -50,18 +44,15 @@ class Context {
         // Tool digest — persistent history of tool calls that mutated task state
         this.tool_digest = config.tool_digest || [];
 
+        // Callback hooks — set by Saico after construction
+        this._findToolImpl = null;   // (toolName) => { saico, methodName } | null
+        this._getSnapshot = null;    // () => serializable snapshot for dirty detection
+
         // Initialize messages: explicit msgs take priority over chat_history
         this._chat_history = config.chat_history || null;
         (config.msgs || []).forEach(m => this.push(m));
 
-        _log('created Context for tag', this.tag);
-    }
-
-    // Set the task reference (used when context is created separately)
-    setTask(task) {
-        this.task = task;
-        if (!this.functions)
-            this.functions = task?.functions;
+        _log('created Msgs for tag', this.tag);
     }
 
     /**
@@ -135,32 +126,6 @@ class Context {
             this.tool_digest = this.tool_digest.slice(-this.TOOL_DIGEST_LIMIT);
     }
 
-    // Get the parent context by traversing task hierarchy (via Saico)
-    getParentContext() {
-        if (!this.task || !this.task.parent)
-            return null;
-        let task = this.task.parent;
-        while (task) {
-            if (task._saico?.context) return task._saico.context;
-            task = task.parent;
-        }
-        return null;
-    }
-
-    // Get all ancestor contexts via task hierarchy (via Saico)
-    getAncestorContexts() {
-        if (!this.task)
-            return [];
-        const contexts = [];
-        let task = this.task.parent;
-        while (task) {
-            if (task._saico?.context)
-                contexts.unshift(task._saico.context);
-            task = task.parent;
-        }
-        return contexts;
-    }
-
     _hasPendingToolCalls() {
         const toolCallMsgs = this._msgs.filter(m => m.msg.tool_calls);
 
@@ -334,16 +299,15 @@ class Context {
                     };
                 } else {
                     this._trackActiveToolCall(call);
-                    const _snap = this.task
-                        ? JSON.stringify(this._snapshotPublicProps(this.task)) : null;
+                    const _snap = this._getSnapshot
+                        ? JSON.stringify(this._getSnapshot()) : null;
 
                     try {
                         const correspondingDeferred = deferredGroup.find(d => d.call.id === call.id);
                         const timeout = correspondingDeferred?.originalMessage.opts.timeout;
 
                         result = await this._executeToolCallWithTimeout(call, timeout);
-                        if (_snap !== null &&
-                            _snap !== JSON.stringify(this._snapshotPublicProps(this.task)))
+                        if (_snap !== null && _snap !== JSON.stringify(this._getSnapshot()))
                             this._appendToolDigest(call.function.name, result?.content || '');
                     } finally {
                         this._completeActiveToolCall(call);
@@ -429,28 +393,18 @@ class Context {
         return this._msgs.length;
     }
 
-    serialize() { return JSON.stringify(this._msgs); }
+    async serialize() {
+        const { chat_history, tool_digest } = await this.prepareForStorage();
+        return JSON.stringify({
+            tag: this.tag,
+            chat_history,
+            tool_digest,
+            functions: this.functions,
+        });
+    }
 
     getSummaries() { return this._msgs.filter(m => m.opts.summary); }
 
-    // Get functions aggregated from this context and all ancestor contexts
-    getFunctions() {
-        const allFunctions = [];
-
-        // Get functions from ancestor contexts via task hierarchy
-        const ancestorContexts = this.getAncestorContexts();
-        for (const ctx of ancestorContexts) {
-            if (ctx.functions && Array.isArray(ctx.functions))
-                allFunctions.push(...ctx.functions);
-        }
-
-        // Add our own functions
-        if (this.functions && Array.isArray(this.functions))
-            allFunctions.push(...this.functions);
-
-        return allFunctions.length > 0 ? allFunctions : null;
-    }
-
     async summarizeMessages() {
         const tokens = util.countTokens(this.__msgs);
         if (tokens < this.lower_limit)
@@ -459,7 +413,7 @@ class Context {
     }
 
     async close() {
-        _log('Closing Context tag', this.tag);
+        _log('Closing Msgs tag', this.tag);
 
         if (this._sequential_mode && this._processing_sequential) {
             _ldbg('Sequential mode: waiting for current message to complete before closing tag', this.tag);
@@ -472,22 +426,8 @@ class Context {
             }
         }
 
-        // Move waiting messages to parent context via task hierarchy
-        const parentCtx = this.getParentContext();
-        if (parentCtx && this._waitingQueue.length > 0) {
-            _log('Moving', this._waitingQueue.length, 'waiting messages to parent context');
-            parentCtx._waitingQueue.push(...this._waitingQueue);
-            this._waitingQueue = [];
-        }
-
-        if (parentCtx && this._sequential_queue.length > 0) {
-            _log('Moving', this._sequential_queue.length, 'sequential queue messages to parent context');
-            parentCtx._sequential_queue.push(...this._sequential_queue);
-            this._sequential_queue = [];
-        }
-
-        await this._summarizeContext(true, parentCtx);
-        _log('Finished closing Context tag', this.tag);
+        await this._summarizeContext(true);
+        _log('Finished closing Msgs tag', this.tag);
     }
 
 
@@ -591,38 +531,6 @@ class Context {
         return summary;
     }
 
-    // Get message context - walks up task hierarchy to collect prompts and summaries
-    getMsgContext(add_tag) {
-        const msgs = [];
-
-        // Get context from ancestor tasks via task hierarchy
-        const ancestorContexts = this.getAncestorContexts();
-        for (const ctx of ancestorContexts) {
-            if (ctx.prompt)
-                msgs.push({role: 'system', content: ctx.prompt});
-            // Add summaries from ancestor contexts
-            const summaries = ctx._msgs.filter(m => m.opts.summary || m.msg.role === 'system').map(m => {
-                if (add_tag)
-                    m.msg.tag = ctx.tag;
-                return m.msg;
-            });
-            msgs.push(...summaries);
-        }
-
-        // Add this context's prompt
-        if (this.prompt)
-            msgs.push({role: 'system', content: this.prompt});
-
-        // Add this context's summaries
-        const mySummaries = this._msgs.filter(m => m.opts.summary || m.msg.role === 'system').map(m => {
-            if (add_tag)
-                m.msg.tag = this.tag;
-            return m.msg;
-        });
-
-        return msgs.concat(mySummaries);
-    }
-
     _createMsgObj(role, content, functions, opts) {
         const name = opts?.name;
         const tool_call_id = opts?.tool_call_id;
@@ -952,10 +860,10 @@ class Context {
                     ? [...o.opts._aggregatedFunctions, ...messageFuncs]
                     : null;
             } else {
-                const hierarchyFuncs = this.getFunctions() || [];
+                const ownFuncs = this.functions || [];
                 const messageFuncs = o.functions || [];
-                funcs = [...hierarchyFuncs, ...messageFuncs].length > 0
-                    ? [...hierarchyFuncs, ...messageFuncs]
+                funcs = [...ownFuncs, ...messageFuncs].length > 0
+                    ? [...ownFuncs, ...messageFuncs]
                     : null;
             }
 
@@ -1024,15 +932,15 @@ class Context {
 
                 for (const { call, isDuplicate } of toolCallsWithResults) {
                     if (!isDuplicate) {
-                        const _snap = this.task
-                            ? JSON.stringify(this._snapshotPublicProps(this.task)) : null;
+                        const _snap = this._getSnapshot
+                            ? JSON.stringify(this._getSnapshot()) : null;
                         try {
                             const result = await this._executeToolCallWithTimeout(
                                 call, o.opts?.timeout);
                             const item = toolCallsWithResults.find(item => item.call.id === call.id);
                             if (item) item.result = result;
                             if (_snap !== null &&
-                                _snap !== JSON.stringify(this._snapshotPublicProps(this.task)))
+                                _snap !== JSON.stringify(this._getSnapshot()))
                                 this._appendToolDigest(call.function.name, result?.content || '');
                         } finally {
                             this._completeActiveToolCall(call);
@@ -1088,39 +996,11 @@ class Context {
     }
 
     /**
-     * Search the Saico hierarchy for a TOOL_<toolName> method.
-     * Order: current task → walk UP parents → walk DOWN children (BFS).
+     * Find a TOOL_<toolName> implementation. Delegates to _findToolImpl callback
+     * set by Saico, which searches the hierarchy.
      */
     _findToolImplementation(toolName) {
-        const methodName = 'TOOL_' + toolName;
-        const check = (task) =>
-            task?._saico && typeof task._saico[methodName] === 'function' ? task._saico : null;
-
-        // 1. Current task
-        let found = check(this.task);
-        if (found) return { saico: found, methodName };
-
-        // 2. Walk UP parent chain
-        let t = this.task?.parent;
-        while (t) {
-            found = check(t);
-            if (found) return { saico: found, methodName };
-            t = t.parent;
-        }
-
-        // 3. Walk DOWN from this.task (BFS)
-        if (this.task) {
-            const queue = [...this.task.child];
-            while (queue.length > 0) {
-                const child = queue.shift();
-                if (child._completed) continue;
-                found = check(child);
-                if (found) return { saico: found, methodName };
-                if (child.child?.size > 0) queue.push(...child.child);
-            }
-        }
-
-        return null;
+        return this._findToolImpl ? this._findToolImpl(toolName) : null;
     }
 
     async interpretAndApplyChanges(call) {
@@ -1169,35 +1049,11 @@ class Context {
         return { content, functions };
     }
 
-    // Spawn child context (creates a child task with its own context)
-    spawnChild(prompt, tag, config = {}) {
-        if (!this.task) {
-            // If no task, create a standalone context
-            return createContext(prompt, null, { ...config, tag });
-        }
-
-        // Create a child task with its own context
-        const Itask = require('./itask.js');
-        const childTask = new Itask({
-            name: tag || 'child-context',
-            async: true,
-        }, []);
-        this.task.spawn(childTask);
-
-        const childContext = new Context(prompt, childTask, { ...config, tag });
-        // Store context on Saico if present, otherwise just set on task reference
-        if (childTask._saico) {
-            childTask._saico.context = childContext;
-            childTask._saico.context_id = childContext.tag;
-        }
-
-        return childContext;
-    }
 }
 
-// Factory function to create a Context with Proxy wrapper
-function createContext(prompt, task, config = {}) {
-    const instance = new Context(prompt, task, config);
+// Factory function to create a Msgs instance with Proxy wrapper
+function createMsgs(prompt, config = {}) {
+    const instance = new Msgs(prompt, config);
 
     return new Proxy(instance, {
         get(target, prop, receiver) {
@@ -1246,4 +1102,4 @@ function createContext(prompt, task, config = {}) {
     });
 }
 
-module.exports = { Context, createContext };
+module.exports = { Msgs, createMsgs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saico",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "main": "index.js",
   "type": "commonjs",
   "description": "Hierarchical AI Conversation Orchestrator - Task hierarchy with conversation contexts",

package/redis.js

@@ -39,11 +39,13 @@ function createObservableForRedis(key, obj) {
     let lastSavedObject = null; // Cache for the last-saved sanitized object
     let lastSavedTimestamp = null; // Timestamp of the last save to Redis
 
-    const saveToRedis = debounce(() => {
+    const saveToRedis = debounce(async () => {
         const sanitizedObj = sanitizeObject(obj);
 
         // Compare sanitized object with the last-saved object
-        if (serialize(sanitizedObj) === serialize(lastSavedObject)) {
+        const serializedNew = await serialize(sanitizedObj);
+        const serializedOld = await serialize(lastSavedObject);
+        if (serializedNew === serializedOld) {
             logDebug("No changes detected, skipping save.");
             return;
         }
@@ -51,7 +53,7 @@ function createObservableForRedis(key, obj) {
         lastSavedObject = sanitizedObj;
         lastSavedTimestamp = Date.now(); // Update the last saved timestamp
 		sanitizedObj.lastSave = lastSavedTimestamp;
-        rclient.set(key, serialize(sanitizedObj));
+        await rclient.set(key, serializedNew);
         logDebug("Saved to Redis:", key, `at ${lastSavedTimestamp}`);
     }, 1000);
 
@@ -100,9 +102,9 @@ function createObservableForRedis(key, obj) {
         },
     };
 
-    function serialize(obj) {
+    async function serialize(obj) {
 		if (typeof obj == 'object' && typeof obj?.serialize == 'function')
-			return obj.serialize();
+			return await obj.serialize();
         return JSON.stringify(obj);
 	}