praisonai 1.2.0 → 1.2.2

package/dist/cache/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cache System - In-memory and persistent caching for agents
+ * Inspired by mastra's cache module
+ */
+export interface CacheConfig {
+    name?: string;
+    ttl?: number;
+    maxSize?: number;
+}
+export interface CacheEntry<T = any> {
+    value: T;
+    createdAt: number;
+    expiresAt?: number;
+}
+/**
+ * Abstract base class for cache implementations
+ */
+export declare abstract class BaseCache {
+    readonly name: string;
+    constructor(config?: CacheConfig);
+    abstract get<T = any>(key: string): Promise<T | undefined>;
+    abstract set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    abstract delete(key: string): Promise<boolean>;
+    abstract clear(): Promise<void>;
+    abstract has(key: string): Promise<boolean>;
+    abstract keys(): Promise<string[]>;
+    abstract size(): Promise<number>;
+    abstract listPush<T = any>(key: string, value: T): Promise<void>;
+    abstract listLength(key: string): Promise<number>;
+    abstract listRange<T = any>(key: string, start: number, end?: number): Promise<T[]>;
+}
+/**
+ * In-memory cache implementation
+ */
+export declare class MemoryCache extends BaseCache {
+    private cache;
+    private lists;
+    private ttl?;
+    private maxSize?;
+    constructor(config?: CacheConfig);
+    get<T = any>(key: string): Promise<T | undefined>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    listPush<T = any>(key: string, value: T): Promise<void>;
+    listLength(key: string): Promise<number>;
+    listRange<T = any>(key: string, start: number, end?: number): Promise<T[]>;
+}
+/**
+ * File-based cache implementation
+ */
+export declare class FileCache extends BaseCache {
+    private cacheDir;
+    private fs;
+    private path;
+    constructor(config?: CacheConfig & {
+        cacheDir?: string;
+    });
+    private ensureDir;
+    private getFilePath;
+    get<T = any>(key: string): Promise<T | undefined>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    keys(): Promise<string[]>;
+    size(): Promise<number>;
+    listPush<T = any>(key: string, value: T): Promise<void>;
+    listLength(key: string): Promise<number>;
+    listRange<T = any>(key: string, start: number, end?: number): Promise<T[]>;
+}
+export declare function createMemoryCache(config?: CacheConfig): MemoryCache;
+export declare function createFileCache(config?: CacheConfig & {
+    cacheDir?: string;
+}): FileCache;

package/dist/cache/index.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * Cache System - In-memory and persistent caching for agents
+ * Inspired by mastra's cache module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCache = exports.MemoryCache = exports.BaseCache = void 0;
+exports.createMemoryCache = createMemoryCache;
+exports.createFileCache = createFileCache;
+/**
+ * Abstract base class for cache implementations
+ */
+class BaseCache {
+    constructor(config = {}) {
+        this.name = config.name || 'cache';
+    }
+}
+exports.BaseCache = BaseCache;
+/**
+ * In-memory cache implementation
+ */
+class MemoryCache extends BaseCache {
+    constructor(config = {}) {
+        super(config);
+        this.cache = new Map();
+        this.lists = new Map();
+        this.ttl = config.ttl;
+        this.maxSize = config.maxSize;
+    }
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        // Check expiration
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        // Enforce max size
+        if (this.maxSize && this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            // Remove oldest entry
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey)
+                this.cache.delete(firstKey);
+        }
+        const effectiveTtl = ttl ?? this.ttl;
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            expiresAt: effectiveTtl ? Date.now() + effectiveTtl : undefined
+        };
+        this.cache.set(key, entry);
+    }
+    async delete(key) {
+        const existed = this.cache.has(key);
+        this.cache.delete(key);
+        this.lists.delete(key);
+        return existed;
+    }
+    async clear() {
+        this.cache.clear();
+        this.lists.clear();
+    }
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    async keys() {
+        return Array.from(this.cache.keys());
+    }
+    async size() {
+        return this.cache.size;
+    }
+    async listPush(key, value) {
+        if (!this.lists.has(key)) {
+            this.lists.set(key, []);
+        }
+        this.lists.get(key).push(value);
+    }
+    async listLength(key) {
+        return this.lists.get(key)?.length ?? 0;
+    }
+    async listRange(key, start, end) {
+        const list = this.lists.get(key) ?? [];
+        return list.slice(start, end);
+    }
+}
+exports.MemoryCache = MemoryCache;
+/**
+ * File-based cache implementation
+ */
+class FileCache extends BaseCache {
+    constructor(config = {}) {
+        super(config);
+        this.cacheDir = config.cacheDir || '.cache';
+    }
+    async ensureDir() {
+        if (!this.fs) {
+            this.fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            this.path = await Promise.resolve().then(() => __importStar(require('path')));
+        }
+        try {
+            await this.fs.mkdir(this.cacheDir, { recursive: true });
+        }
+        catch { }
+    }
+    getFilePath(key) {
+        const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_');
+        return this.path.join(this.cacheDir, `${safeKey}.json`);
+    }
+    async get(key) {
+        await this.ensureDir();
+        try {
+            const data = await this.fs.readFile(this.getFilePath(key), 'utf-8');
+            const entry = JSON.parse(data);
+            if (entry.expiresAt && Date.now() > entry.expiresAt) {
+                await this.delete(key);
+                return undefined;
+            }
+            return entry.value;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async set(key, value, ttl) {
+        await this.ensureDir();
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            expiresAt: ttl ? Date.now() + ttl : undefined
+        };
+        await this.fs.writeFile(this.getFilePath(key), JSON.stringify(entry));
+    }
+    async delete(key) {
+        await this.ensureDir();
+        try {
+            await this.fs.unlink(this.getFilePath(key));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async clear() {
+        await this.ensureDir();
+        try {
+            const files = await this.fs.readdir(this.cacheDir);
+            await Promise.all(files.filter((f) => f.endsWith('.json'))
+                .map((f) => this.fs.unlink(this.path.join(this.cacheDir, f))));
+        }
+        catch { }
+    }
+    async has(key) {
+        return (await this.get(key)) !== undefined;
+    }
+    async keys() {
+        await this.ensureDir();
+        try {
+            const files = await this.fs.readdir(this.cacheDir);
+            return files
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => f.replace('.json', ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    async size() {
+        return (await this.keys()).length;
+    }
+    async listPush(key, value) {
+        const list = (await this.get(`list_${key}`)) || [];
+        list.push(value);
+        await this.set(`list_${key}`, list);
+    }
+    async listLength(key) {
+        const list = (await this.get(`list_${key}`)) || [];
+        return list.length;
+    }
+    async listRange(key, start, end) {
+        const list = (await this.get(`list_${key}`)) || [];
+        return list.slice(start, end);
+    }
+}
+exports.FileCache = FileCache;
+// Factory functions
+function createMemoryCache(config) {
+    return new MemoryCache(config);
+}
+function createFileCache(config) {
+    return new FileCache(config);
+}

package/dist/db/postgres.d.ts

@@ -0,0 +1,84 @@
+/**
+ * PostgreSQL Database Adapter
+ * For persistent storage of sessions, messages, and runs
+ */
+export interface PostgresConfig {
+    connectionString?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    ssl?: boolean;
+}
+export interface PostgresAdapter {
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    execute(sql: string, params?: any[]): Promise<{
+        rowCount: number;
+    }>;
+    transaction<T>(fn: (client: PostgresAdapter) => Promise<T>): Promise<T>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * PostgreSQL Adapter using pg-compatible REST APIs (like Neon, Supabase)
+ */
+export declare class NeonPostgresAdapter implements PostgresAdapter {
+    private connectionString;
+    private connected;
+    constructor(config: PostgresConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    execute(sql: string, params?: any[]): Promise<{
+        rowCount: number;
+    }>;
+    transaction<T>(fn: (client: PostgresAdapter) => Promise<T>): Promise<T>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * In-memory PostgreSQL-like adapter for testing
+ */
+export declare class MemoryPostgresAdapter implements PostgresAdapter {
+    private tables;
+    private connected;
+    query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    private handleSelect;
+    private handleInsert;
+    private handleUpdate;
+    private handleDelete;
+    private handleCreateTable;
+    execute(sql: string, params?: any[]): Promise<{
+        rowCount: number;
+    }>;
+    transaction<T>(fn: (client: PostgresAdapter) => Promise<T>): Promise<T>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getTable(name: string): any[];
+}
+/**
+ * PostgreSQL Session Storage
+ */
+export declare class PostgresSessionStorage {
+    private db;
+    private tableName;
+    private initialized;
+    constructor(db: PostgresAdapter, tableName?: string);
+    init(): Promise<void>;
+    createSession(id: string, data?: Record<string, any>): Promise<void>;
+    getSession(id: string): Promise<Record<string, any> | null>;
+    updateSession(id: string, data: Record<string, any>): Promise<void>;
+    deleteSession(id: string): Promise<void>;
+    addMessage(sessionId: string, message: {
+        id: string;
+        role: string;
+        content: string;
+        toolCalls?: any;
+    }): Promise<void>;
+    getMessages(sessionId: string, limit?: number): Promise<any[]>;
+}
+export declare function createNeonPostgres(config: PostgresConfig): NeonPostgresAdapter;
+export declare function createMemoryPostgres(): MemoryPostgresAdapter;
+export declare function createPostgresSessionStorage(db: PostgresAdapter, tableName?: string): PostgresSessionStorage;

package/dist/db/postgres.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * PostgreSQL Database Adapter
+ * For persistent storage of sessions, messages, and runs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresSessionStorage = exports.MemoryPostgresAdapter = exports.NeonPostgresAdapter = void 0;
+exports.createNeonPostgres = createNeonPostgres;
+exports.createMemoryPostgres = createMemoryPostgres;
+exports.createPostgresSessionStorage = createPostgresSessionStorage;
+/**
+ * PostgreSQL Adapter using pg-compatible REST APIs (like Neon, Supabase)
+ */
+class NeonPostgresAdapter {
+    constructor(config) {
+        this.connected = false;
+        if (config.connectionString) {
+            this.connectionString = config.connectionString;
+        }
+        else {
+            const { host, port, database, user, password, ssl } = config;
+            this.connectionString = `postgres://${user}:${password}@${host}:${port || 5432}/${database}${ssl ? '?sslmode=require' : ''}`;
+        }
+    }
+    async query(sql, params) {
+        // Use Neon serverless driver pattern
+        const response = await fetch(this.connectionString.replace('postgres://', 'https://').split('/')[0] + '/sql', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Neon-Connection-String': this.connectionString
+            },
+            body: JSON.stringify({
+                query: sql,
+                params: params || []
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`PostgreSQL error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return data.rows || [];
+    }
+    async execute(sql, params) {
+        const rows = await this.query(sql, params);
+        return { rowCount: rows.length };
+    }
+    async transaction(fn) {
+        await this.execute('BEGIN');
+        try {
+            const result = await fn(this);
+            await this.execute('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await this.execute('ROLLBACK');
+            throw error;
+        }
+    }
+    async connect() {
+        // Test connection
+        await this.query('SELECT 1');
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.NeonPostgresAdapter = NeonPostgresAdapter;
+/**
+ * In-memory PostgreSQL-like adapter for testing
+ */
+class MemoryPostgresAdapter {
+    constructor() {
+        this.tables = new Map();
+        this.connected = false;
+    }
+    async query(sql, params) {
+        // Very basic SQL parsing for testing
+        const normalizedSql = sql.toLowerCase().trim();
+        if (normalizedSql.startsWith('select')) {
+            return this.handleSelect(sql, params);
+        }
+        else if (normalizedSql.startsWith('insert')) {
+            return this.handleInsert(sql, params);
+        }
+        else if (normalizedSql.startsWith('update')) {
+            return this.handleUpdate(sql, params);
+        }
+        else if (normalizedSql.startsWith('delete')) {
+            return this.handleDelete(sql, params);
+        }
+        else if (normalizedSql.startsWith('create table')) {
+            this.handleCreateTable(sql);
+            return [];
+        }
+        return [];
+    }
+    handleSelect(sql, params) {
+        const match = sql.match(/from\s+(\w+)/i);
+        if (!match)
+            return [];
+        const tableName = match[1];
+        const rows = this.tables.get(tableName) || [];
+        // Handle WHERE clause
+        const whereMatch = sql.match(/where\s+(\w+)\s*=\s*\$(\d+)/i);
+        if (whereMatch && params) {
+            const field = whereMatch[1];
+            const paramIndex = parseInt(whereMatch[2]) - 1;
+            const value = params[paramIndex];
+            return rows.filter(row => row[field] === value);
+        }
+        return rows;
+    }
+    handleInsert(sql, params) {
+        const match = sql.match(/insert\s+into\s+(\w+)\s*\(([^)]+)\)/i);
+        if (!match || !params)
+            return [];
+        const tableName = match[1];
+        const columns = match[2].split(',').map(c => c.trim());
+        if (!this.tables.has(tableName)) {
+            this.tables.set(tableName, []);
+        }
+        const row = {};
+        columns.forEach((col, i) => {
+            row[col] = params[i];
+        });
+        this.tables.get(tableName).push(row);
+        return [row];
+    }
+    handleUpdate(sql, params) {
+        const match = sql.match(/update\s+(\w+)\s+set/i);
+        if (!match || !params)
+            return [];
+        const tableName = match[1];
+        const rows = this.tables.get(tableName) || [];
+        // Simple update - just return affected count
+        return [{ count: rows.length }];
+    }
+    handleDelete(sql, params) {
+        const match = sql.match(/delete\s+from\s+(\w+)/i);
+        if (!match)
+            return [];
+        const tableName = match[1];
+        const whereMatch = sql.match(/where\s+(\w+)\s*=\s*\$(\d+)/i);
+        if (whereMatch && params) {
+            const field = whereMatch[1];
+            const paramIndex = parseInt(whereMatch[2]) - 1;
+            const value = params[paramIndex];
+            const rows = this.tables.get(tableName) || [];
+            const filtered = rows.filter(row => row[field] !== value);
+            this.tables.set(tableName, filtered);
+            return [{ count: rows.length - filtered.length }];
+        }
+        return [];
+    }
+    handleCreateTable(sql) {
+        const match = sql.match(/create\s+table\s+(?:if\s+not\s+exists\s+)?(\w+)/i);
+        if (match) {
+            const tableName = match[1];
+            if (!this.tables.has(tableName)) {
+                this.tables.set(tableName, []);
+            }
+        }
+    }
+    async execute(sql, params) {
+        const rows = await this.query(sql, params);
+        return { rowCount: rows.length };
+    }
+    async transaction(fn) {
+        return fn(this);
+    }
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.tables.clear();
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // Helper for testing
+    getTable(name) {
+        return this.tables.get(name) || [];
+    }
+}
+exports.MemoryPostgresAdapter = MemoryPostgresAdapter;
+/**
+ * PostgreSQL Session Storage
+ */
+class PostgresSessionStorage {
+    constructor(db, tableName = 'sessions') {
+        this.initialized = false;
+        this.db = db;
+        this.tableName = tableName;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        id TEXT PRIMARY KEY,
+        data JSONB NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName}_messages (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL REFERENCES ${this.tableName}(id),
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        tool_calls JSONB,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        this.initialized = true;
+    }
+    async createSession(id, data = {}) {
+        await this.init();
+        await this.db.execute(`INSERT INTO ${this.tableName} (id, data) VALUES ($1, $2) ON CONFLICT (id) DO UPDATE SET data = $2, updated_at = CURRENT_TIMESTAMP`, [id, JSON.stringify(data)]);
+    }
+    async getSession(id) {
+        await this.init();
+        const rows = await this.db.query(`SELECT data FROM ${this.tableName} WHERE id = $1`, [id]);
+        return rows[0]?.data || null;
+    }
+    async updateSession(id, data) {
+        await this.init();
+        await this.db.execute(`UPDATE ${this.tableName} SET data = $1, updated_at = CURRENT_TIMESTAMP WHERE id = $2`, [JSON.stringify(data), id]);
+    }
+    async deleteSession(id) {
+        await this.init();
+        await this.db.execute(`DELETE FROM ${this.tableName}_messages WHERE session_id = $1`, [id]);
+        await this.db.execute(`DELETE FROM ${this.tableName} WHERE id = $1`, [id]);
+    }
+    async addMessage(sessionId, message) {
+        await this.init();
+        await this.db.execute(`INSERT INTO ${this.tableName}_messages (id, session_id, role, content, tool_calls) VALUES ($1, $2, $3, $4, $5)`, [message.id, sessionId, message.role, message.content, message.toolCalls ? JSON.stringify(message.toolCalls) : null]);
+    }
+    async getMessages(sessionId, limit) {
+        await this.init();
+        let sql = `SELECT * FROM ${this.tableName}_messages WHERE session_id = $1 ORDER BY created_at ASC`;
+        if (limit) {
+            sql += ` LIMIT ${limit}`;
+        }
+        return this.db.query(sql, [sessionId]);
+    }
+}
+exports.PostgresSessionStorage = PostgresSessionStorage;
+// Factory functions
+function createNeonPostgres(config) {
+    return new NeonPostgresAdapter(config);
+}
+function createMemoryPostgres() {
+    return new MemoryPostgresAdapter();
+}
+function createPostgresSessionStorage(db, tableName) {
+    return new PostgresSessionStorage(db, tableName);
+}