saico 2.0.0

package/openai.js

@@ -0,0 +1,72 @@
+const OpenAI = require('openai');
+
+const openai = new OpenAI({
+	apiKey: process.env.OPENAI_API_KEY||'test'
+});
+
+module.exports = {
+	send,
+};
+
+async function send(messages, functions, model) {
+	let data;
+	let retries = 5;
+	
+	// Convert functions to tools format if provided
+	let tools;
+	if (functions && functions.length > 0) {
+		tools = functions.map(func => ({
+			type: 'function',
+			function: func
+		}));
+	}
+	
+	while (--retries)
+	{
+		try {
+			const requestParams = {
+				model: model || 'gpt-5-mini',
+				messages
+			};
+			
+			if (tools) {
+				requestParams.tools = tools;
+			}
+			
+			data = await openai.chat.completions.create(requestParams);
+			break;
+		} catch (error) {
+			// Check if the status code is 429
+			if (error.status == 429)
+			{
+				console.error("Error 429: Too Many Requests");
+				console.error("Message:", error.message);
+				const errorMessage = error.message || '';
+
+				const waitTimeMatch = errorMessage.match(/Please try again in (\d+(\.\d+)?)(ms|s)/);
+
+				if (waitTimeMatch)
+				{
+					let waitTime = parseFloat(waitTimeMatch[1]);
+					if (waitTimeMatch[3] === 's')
+						waitTime *= 1000; // Convert seconds to milliseconds
+					console.error(`Rate limit reached. Retrying in ${waitTime}ms...`);
+					await new Promise(resolve => setTimeout(resolve, waitTime+100));
+				} else {
+					console.error('Rate limit error encountered, but could not extract wait time. Aborting.');
+					console.error('messages:\n', JSON.stringify(messages));
+					throw error; // Exit if wait time cannot be extracted
+				}
+			} else {
+				console.error(`Unexpected Error ${error.status}: ${error.message}`);
+				throw error;
+			}
+		}
+	}
+
+	if (!data || !data.choices || !data.choices.length)
+		return console.error('failed to receive response\n', data);
+	return data.choices[0].message;
+}
+
+

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "saico",
+  "version": "2.0.0",
+  "main": "index.js",
+  "type": "commonjs",
+  "description": "Hierarchical AI Conversation Orchestrator - Task hierarchy with conversation contexts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wanderli-ai/saico.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wanderli-ai/saico/issues"
+  },
+  "homepage": "https://github.com/wanderli-ai/saico#readme",
+  "files": [
+    "index.js",
+    "itask.js",
+    "context.js",
+    "sid.js",
+    "openai.js",
+    "util.js",
+    "redis.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "openai": "^4.85.4",
+    "tiktoken": "^1.0.17",
+    "redis": "^4.7.0"
+  },
+  "devDependencies": {
+    "chai": "^4.5.0",
+    "chai-http": "^4.4.0",
+    "mock-fs": "^5.4.1",
+    "mocha": "^10.2.0",
+    "sinon": "^17.0.0",
+    "sinon-chai": "^3.7.0"
+  },
+  "scripts": {
+    "test": "NODE_ENV=test mocha --exit 'test/**/*.test.js'",
+    "start": "node server.js"
+  },
+  "keywords": ["ai", "conversation", "orchestrator", "task", "hierarchy", "openai", "chatgpt", "llm"],
+  "author": "wanderli-ai",
+  "license": "ISC"
+}

package/redis.js

@@ -0,0 +1,123 @@
+const redis = require('redis');
+let rclient;
+let debug = false;
+
+module.exports = {
+	init,
+	createObservableForRedis,
+};
+
+function logDebug(...args) {
+    if (debug)
+        console.log(...args);
+}
+
+async function init() {
+	rclient = redis.createClient({ url: 'redis://localhost:6379' });
+	module.exports.rclient = rclient;
+
+	rclient.on('connect', () => {
+		console.log('Connected to Redis');
+	});
+
+	rclient.on('error', (err) => {
+		console.error('Redis connection error:', err);
+	});
+
+	await rclient.connect();
+}
+
+function debounce(func, delay) {
+    let timer;
+    return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => func(...args), delay);
+    };
+}
+
+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 sanitizedObj = sanitizeObject(obj);
+
+        // Compare sanitized object with the last-saved object
+        if (serialize(sanitizedObj) === serialize(lastSavedObject)) {
+            logDebug("No changes detected, skipping save.");
+            return;
+        }
+
+        lastSavedObject = sanitizedObj;
+        lastSavedTimestamp = Date.now(); // Update the last saved timestamp
+		sanitizedObj.lastSave = lastSavedTimestamp;
+        rclient.set(key, serialize(sanitizedObj));
+        logDebug("Saved to Redis:", key, `at ${lastSavedTimestamp}`);
+    }, 1000);
+
+    const handler = {
+        get(target, prop, receiver) {
+            if (prop === "lastMod") {
+                // Expose the last saved timestamp as a method
+                return () => lastSavedTimestamp;
+			}
+			if (prop in target) {
+				const value = Reflect.get(target, prop, receiver);
+				if (typeof value === 'function') {
+					// Bind the method to the original target to preserve `this`
+					return value.bind(target);
+				}
+				return value;
+			}
+			return Reflect.get(target, prop, receiver);
+        },
+        set(target, prop, value) {
+            if (String(prop).startsWith('_')) {
+                target[prop] = value; // Allow setting but do not trigger save
+                logDebug(`Ignored saving property '${prop}'`);
+                return true;
+            }
+
+            // Wrap new objects with the Proxy
+            if (typeof value === 'object' && value !== null) {
+                value = new Proxy(value, handler);
+            }
+
+            target[prop] = value;
+            saveToRedis(); // Trigger save for the root object
+            return true;
+        },
+        deleteProperty(target, prop) {
+            if (String(prop).startsWith('_')) {
+                delete target[prop]; // Allow deletion without triggering save
+                logDebug(`Ignored deletion of property '${prop}'`);
+                return true;
+            }
+
+            delete target[prop];
+            saveToRedis(); // Trigger save for the root object
+            return true;
+        },
+    };
+
+    function serialize(obj) {
+		if (typeof obj == 'object' && typeof obj?.serialize == 'function')
+			return obj.serialize();
+        return JSON.stringify(obj);
+	}
+
+    function sanitizeObject(obj) {
+        if (typeof obj !== 'object' || obj === null || typeof obj.serialize == 'function')
+			return obj;
+        const sanitized = Array.isArray(obj) ? [] : {};
+        for (const key in obj) {
+            if (!key.startsWith('_')) {
+                sanitized[key] = sanitizeObject(obj[key]);
+            }
+        }
+        return sanitized;
+    }
+
+    return new Proxy(obj, handler);
+}
+

package/sid.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const Itask = require('./itask.js');
+const { Context, createContext } = require('./context.js');
+
+/**
+ * Sid - Session/User Context root task.
+ *
+ * Extends Itask to serve as the root of task hierarchies.
+ * Always has a conversation context attached.
+ * Provides serialization support for persistence.
+ */
+class Sid extends Itask {
+    constructor(opt = {}, states = []) {
+        // Normalize options
+        if (typeof opt === 'string')
+            opt = { name: opt };
+
+        // Set defaults for a session root task
+        const name = opt.name || 'session';
+        const prompt = opt.prompt || '';
+
+        // Call parent constructor with async:true to control context creation
+        super({
+            ...opt,
+            name,
+            prompt,
+            async: true // We'll manage running ourselves
+        }, states);
+
+        // User data storage
+        this.userData = opt.userData || {};
+
+        // Session-specific configuration
+        this.sessionConfig = {
+            token_limit: opt.token_limit,
+            max_depth: opt.max_depth,
+            max_tool_repetition: opt.max_tool_repetition,
+            ...opt.sessionConfig
+        };
+
+        // Always create a context for Sid (root session task)
+        const contextConfig = {
+            tag: opt.tag || this.id,
+            token_limit: this.sessionConfig.token_limit,
+            max_depth: this.sessionConfig.max_depth,
+            max_tool_repetition: this.sessionConfig.max_tool_repetition,
+            tool_handler: opt.tool_handler,
+            functions: opt.functions,
+            sequential_mode: opt.sequential_mode,
+            msgs: opt.msgs
+        };
+
+        this.context = new Context(prompt, this, contextConfig);
+
+        // Start running if not explicitly set to async
+        if (opt.async !== true && states.length > 0) {
+            process.nextTick(() => {
+                try { this._run(); } catch (e) { console.error(e); }
+            });
+        }
+    }
+
+    // Override sendMessage to always use our context
+    async sendMessage(role, content, functions, opts) {
+        return this.context.sendMessage(role, content, functions || this.functions, opts);
+    }
+
+    // Serialize the session for persistence
+    serialize() {
+        return JSON.stringify({
+            id: this.id,
+            name: this.name,
+            prompt: this.prompt,
+            userData: this.userData,
+            sessionConfig: this.sessionConfig,
+            context: {
+                tag: this.context.tag,
+                msgs: this.context._msgs,
+                functions: this.context.functions
+            },
+            tm_create: this.tm_create
+        });
+    }
+
+    // Deserialize a session from stored data
+    static deserialize(data, opt = {}) {
+        const parsed = typeof data === 'string' ? JSON.parse(data) : data;
+
+        const sid = new Sid({
+            name: parsed.name,
+            prompt: parsed.prompt,
+            userData: parsed.userData,
+            sessionConfig: parsed.sessionConfig,
+            tag: parsed.context?.tag,
+            tool_handler: opt.tool_handler,
+            functions: opt.functions || parsed.context?.functions,
+            async: true, // Don't auto-run states
+            ...opt
+        }, opt.states || []);
+
+        // Restore the original ID and timestamps
+        sid.id = parsed.id;
+        sid.tm_create = parsed.tm_create;
+
+        // Restore messages to context
+        if (parsed.context?.msgs) {
+            sid.context._msgs = parsed.context.msgs;
+        }
+
+        return sid;
+    }
+
+    // Create a child task with its own context
+    spawnTaskWithContext(opt, states = []) {
+        if (typeof opt === 'string')
+            opt = { name: opt };
+
+        const childTask = new Itask({
+            ...opt,
+            spawn_parent: this,
+            async: true
+        }, states);
+
+        if (opt.prompt) {
+            const childContext = new Context(opt.prompt, childTask, {
+                tag: opt.tag || childTask.id,
+                token_limit: opt.token_limit || this.sessionConfig.token_limit,
+                max_depth: opt.max_depth || this.sessionConfig.max_depth,
+                max_tool_repetition: opt.max_tool_repetition || this.sessionConfig.max_tool_repetition,
+                tool_handler: opt.tool_handler || this.tool_handler,
+                functions: opt.functions || this.functions
+            });
+            childTask.setContext(childContext);
+        }
+
+        // Start the child task
+        process.nextTick(() => {
+            try { childTask._run(); } catch (e) { console.error(e); }
+        });
+
+        return childTask;
+    }
+
+    // Create a child task without its own context (uses parent's context)
+    spawnTask(opt, states = []) {
+        if (typeof opt === 'string')
+            opt = { name: opt };
+
+        const childTask = new Itask({
+            ...opt,
+            spawn_parent: this,
+            async: true
+        }, states);
+
+        // Start the child task
+        process.nextTick(() => {
+            try { childTask._run(); } catch (e) { console.error(e); }
+        });
+
+        return childTask;
+    }
+
+    // Close the session - summarize context and cleanup
+    async closeSession() {
+        await this.context.close();
+        this._ecancel();
+    }
+
+    // Get session info for debugging/monitoring
+    getSessionInfo() {
+        return {
+            id: this.id,
+            name: this.name,
+            running: this.running,
+            completed: this._completed,
+            messageCount: this.context.length,
+            childCount: this.child.size,
+            userData: this.userData,
+            uptime: Date.now() - this.tm_create
+        };
+    }
+
+    // Store user data
+    setUserData(key, value) {
+        this.userData[key] = value;
+        return this;
+    }
+
+    // Get user data
+    getUserData(key) {
+        return key ? this.userData[key] : this.userData;
+    }
+
+    // Clear user data
+    clearUserData() {
+        this.userData = {};
+        return this;
+    }
+}
+
+// Factory function to create a Sid instance
+function createSid(opt = {}, states = []) {
+    return new Sid(opt, states);
+}
+
+module.exports = { Sid, createSid };

package/util.js

@@ -0,0 +1,110 @@
+const is_mocha = process.env.NODE_ENV == 'test';
+const tiktoken = require('tiktoken');
+
+const debug = process.env.DEBUG === '1' || process.env.DEBUG === 'true';
+
+function _log(...args) {
+    if (!is_mocha || process.env.VERBOSE)
+        console.log(...args);
+}
+
+function _lerr(...args) {
+    console.error(...args);
+}
+
+// Add perr method for error logging with stack trace
+_lerr.perr = function(err) {
+    if (err instanceof Error) {
+        console.error(err.message, err.stack);
+    } else {
+        console.error(err);
+    }
+};
+
+function _ldbg(...args) {
+    if (debug)
+        console.log('[DEBUG]', ...args);
+}
+
+function daysSince(timestamp) {
+    return (Date.now() - timestamp) / (1000 * 60 * 60 * 24);
+}
+
+function minSince(timestamp) {
+    return (Date.now() - timestamp) / (1000 * 60);
+}
+
+function shallowEqual(obj1, obj2) {
+    if (obj1 === obj2) return true;
+    if (!obj1 || !obj2) return false;
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) return false;
+    for (const key of keys1) {
+        if (obj1[key] !== obj2[key]) return false;
+    }
+    return true;
+}
+
+function filterArray(arr, predicate) {
+    return arr.filter(predicate);
+}
+
+function logEvent(event, data) {
+    _log(`[EVENT: ${event}]`, data);
+}
+
+const lerr = _lerr;
+
+module.exports = {
+    countTokens,
+    is_mocha,
+    _log,
+    _lerr,
+    lerr,
+    _ldbg,
+    daysSince,
+    minSince,
+    shallowEqual,
+    filterArray,
+    logEvent,
+}
+
+function countTokens(messages, model = "gpt-4o") {
+	// Load the encoding for the specified model
+	const encoding = tiktoken.encoding_for_model(model);
+	let bmsg_size = 0;
+	let numTokens = 0;
+
+	if (!Array.isArray(messages))
+		messages = [messages];
+	messages.forEach(message => {
+		if (typeof message == 'string')
+		{
+			numTokens += encoding.encode(message).length;
+			if (message.length > bmsg_size)
+				bmsg_size = message.length;
+		}
+		else if (typeof message == 'object')
+		{
+			numTokens += 4; // Role and other structure overhead
+			for (const key in message) {
+				if (!message[key])
+					continue
+				if (typeof message[key] != 'string')
+					continue;
+				numTokens += encoding.encode(message[key]).length;
+				if (message[key].length > bmsg_size)
+					bmsg_size = message[key].length;
+			}
+		}
+	});
+
+	// Add 2 tokens for the assistant's reply overhead
+	numTokens += 2;
+	encoding.free();
+
+	return numTokens;
+}
+
+