praisonai 1.2.1 → 1.2.2

package/dist/db/redis.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Redis Database Adapter
+ * For session state, caching, and pub/sub
+ */
+export interface RedisConfig {
+    url?: string;
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+}
+export interface RedisAdapter {
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    keys(pattern: string): Promise<string[]>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    hget<T = any>(key: string, field: string): Promise<T | null>;
+    hset<T = any>(key: string, field: string, value: T): Promise<void>;
+    hgetall<T = any>(key: string): Promise<Record<string, T>>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    lpush<T = any>(key: string, ...values: T[]): Promise<number>;
+    rpush<T = any>(key: string, ...values: T[]): Promise<number>;
+    lrange<T = any>(key: string, start: number, stop: number): Promise<T[]>;
+    llen(key: string): Promise<number>;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(channel: string, callback: (message: string) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * Redis Adapter using native fetch (for Upstash REST API)
+ */
+export declare class UpstashRedisAdapter implements RedisAdapter {
+    private url;
+    private token;
+    private keyPrefix;
+    private connected;
+    constructor(config: {
+        url: string;
+        token: string;
+        keyPrefix?: string;
+    });
+    private prefixKey;
+    private request;
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    keys(pattern: string): Promise<string[]>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    hget<T = any>(key: string, field: string): Promise<T | null>;
+    hset<T = any>(key: string, field: string, value: T): Promise<void>;
+    hgetall<T = any>(key: string): Promise<Record<string, T>>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    lpush<T = any>(key: string, ...values: T[]): Promise<number>;
+    rpush<T = any>(key: string, ...values: T[]): Promise<number>;
+    lrange<T = any>(key: string, start: number, stop: number): Promise<T[]>;
+    llen(key: string): Promise<number>;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(_channel: string, _callback: (message: string) => void): Promise<void>;
+    unsubscribe(_channel: string): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * In-memory Redis-like adapter for testing
+ */
+export declare class MemoryRedisAdapter implements RedisAdapter {
+    private store;
+    private hashes;
+    private lists;
+    private subscribers;
+    private connected;
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    keys(pattern: string): Promise<string[]>;
+    expire(key: string, seconds: number): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    hget<T = any>(key: string, field: string): Promise<T | null>;
+    hset<T = any>(key: string, field: string, value: T): Promise<void>;
+    hgetall<T = any>(key: string): Promise<Record<string, T>>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    lpush<T = any>(key: string, ...values: T[]): Promise<number>;
+    rpush<T = any>(key: string, ...values: T[]): Promise<number>;
+    lrange<T = any>(key: string, start: number, stop: number): Promise<T[]>;
+    llen(key: string): Promise<number>;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(channel: string, callback: (message: string) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+export declare function createUpstashRedis(config: {
+    url: string;
+    token: string;
+    keyPrefix?: string;
+}): UpstashRedisAdapter;
+export declare function createMemoryRedis(): MemoryRedisAdapter;

package/dist/db/redis.js

@@ -0,0 +1,307 @@
+"use strict";
+/**
+ * Redis Database Adapter
+ * For session state, caching, and pub/sub
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRedisAdapter = exports.UpstashRedisAdapter = void 0;
+exports.createUpstashRedis = createUpstashRedis;
+exports.createMemoryRedis = createMemoryRedis;
+/**
+ * Redis Adapter using native fetch (for Upstash REST API)
+ */
+class UpstashRedisAdapter {
+    constructor(config) {
+        this.connected = false;
+        this.url = config.url;
+        this.token = config.token;
+        this.keyPrefix = config.keyPrefix || '';
+    }
+    prefixKey(key) {
+        return this.keyPrefix ? `${this.keyPrefix}:${key}` : key;
+    }
+    async request(command) {
+        const response = await fetch(this.url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(command)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Upstash Redis error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(`Redis error: ${data.error}`);
+        }
+        return data.result;
+    }
+    async get(key) {
+        const result = await this.request(['GET', this.prefixKey(key)]);
+        if (result === null)
+            return null;
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return result;
+        }
+    }
+    async set(key, value, ttl) {
+        const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+        const command = ['SET', this.prefixKey(key), serialized];
+        if (ttl) {
+            command.push('EX', String(ttl));
+        }
+        await this.request(command);
+    }
+    async delete(key) {
+        const result = await this.request(['DEL', this.prefixKey(key)]);
+        return result > 0;
+    }
+    async exists(key) {
+        const result = await this.request(['EXISTS', this.prefixKey(key)]);
+        return result > 0;
+    }
+    async keys(pattern) {
+        const result = await this.request(['KEYS', this.prefixKey(pattern)]);
+        return (result || []).map((k) => this.keyPrefix ? k.replace(`${this.keyPrefix}:`, '') : k);
+    }
+    async expire(key, seconds) {
+        const result = await this.request(['EXPIRE', this.prefixKey(key), String(seconds)]);
+        return result === 1;
+    }
+    async ttl(key) {
+        return await this.request(['TTL', this.prefixKey(key)]);
+    }
+    async hget(key, field) {
+        const result = await this.request(['HGET', this.prefixKey(key), field]);
+        if (result === null)
+            return null;
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return result;
+        }
+    }
+    async hset(key, field, value) {
+        const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+        await this.request(['HSET', this.prefixKey(key), field, serialized]);
+    }
+    async hgetall(key) {
+        const result = await this.request(['HGETALL', this.prefixKey(key)]);
+        if (!result || !Array.isArray(result))
+            return {};
+        const obj = {};
+        for (let i = 0; i < result.length; i += 2) {
+            try {
+                obj[result[i]] = JSON.parse(result[i + 1]);
+            }
+            catch {
+                obj[result[i]] = result[i + 1];
+            }
+        }
+        return obj;
+    }
+    async hdel(key, ...fields) {
+        return await this.request(['HDEL', this.prefixKey(key), ...fields]);
+    }
+    async lpush(key, ...values) {
+        const serialized = values.map(v => typeof v === 'string' ? v : JSON.stringify(v));
+        return await this.request(['LPUSH', this.prefixKey(key), ...serialized]);
+    }
+    async rpush(key, ...values) {
+        const serialized = values.map(v => typeof v === 'string' ? v : JSON.stringify(v));
+        return await this.request(['RPUSH', this.prefixKey(key), ...serialized]);
+    }
+    async lrange(key, start, stop) {
+        const result = await this.request(['LRANGE', this.prefixKey(key), String(start), String(stop)]);
+        return (result || []).map((item) => {
+            try {
+                return JSON.parse(item);
+            }
+            catch {
+                return item;
+            }
+        });
+    }
+    async llen(key) {
+        return await this.request(['LLEN', this.prefixKey(key)]);
+    }
+    async publish(channel, message) {
+        return await this.request(['PUBLISH', channel, message]);
+    }
+    async subscribe(_channel, _callback) {
+        // Upstash REST API doesn't support true pub/sub subscriptions
+        throw new Error('Subscribe not supported in REST mode. Use ioredis for pub/sub.');
+    }
+    async unsubscribe(_channel) {
+        throw new Error('Unsubscribe not supported in REST mode.');
+    }
+    async connect() {
+        // Test connection
+        await this.request(['PING']);
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.UpstashRedisAdapter = UpstashRedisAdapter;
+/**
+ * In-memory Redis-like adapter for testing
+ */
+class MemoryRedisAdapter {
+    constructor() {
+        this.store = new Map();
+        this.hashes = new Map();
+        this.lists = new Map();
+        this.subscribers = new Map();
+        this.connected = false;
+    }
+    async get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttl) {
+        this.store.set(key, {
+            value,
+            expiresAt: ttl ? Date.now() + ttl * 1000 : undefined
+        });
+    }
+    async delete(key) {
+        const existed = this.store.has(key);
+        this.store.delete(key);
+        this.hashes.delete(key);
+        this.lists.delete(key);
+        return existed;
+    }
+    async exists(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return false;
+        if (entry.expiresAt && Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return false;
+        }
+        return true;
+    }
+    async keys(pattern) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+        return Array.from(this.store.keys()).filter(k => regex.test(k));
+    }
+    async expire(key, seconds) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return false;
+        entry.expiresAt = Date.now() + seconds * 1000;
+        return true;
+    }
+    async ttl(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return -2;
+        if (!entry.expiresAt)
+            return -1;
+        const remaining = Math.ceil((entry.expiresAt - Date.now()) / 1000);
+        return remaining > 0 ? remaining : -2;
+    }
+    async hget(key, field) {
+        return this.hashes.get(key)?.get(field) ?? null;
+    }
+    async hset(key, field, value) {
+        if (!this.hashes.has(key)) {
+            this.hashes.set(key, new Map());
+        }
+        this.hashes.get(key).set(field, value);
+    }
+    async hgetall(key) {
+        const hash = this.hashes.get(key);
+        if (!hash)
+            return {};
+        return Object.fromEntries(hash.entries());
+    }
+    async hdel(key, ...fields) {
+        const hash = this.hashes.get(key);
+        if (!hash)
+            return 0;
+        let count = 0;
+        for (const field of fields) {
+            if (hash.delete(field))
+                count++;
+        }
+        return count;
+    }
+    async lpush(key, ...values) {
+        if (!this.lists.has(key)) {
+            this.lists.set(key, []);
+        }
+        this.lists.get(key).unshift(...values);
+        return this.lists.get(key).length;
+    }
+    async rpush(key, ...values) {
+        if (!this.lists.has(key)) {
+            this.lists.set(key, []);
+        }
+        this.lists.get(key).push(...values);
+        return this.lists.get(key).length;
+    }
+    async lrange(key, start, stop) {
+        const list = this.lists.get(key) || [];
+        const end = stop === -1 ? list.length : stop + 1;
+        return list.slice(start, end);
+    }
+    async llen(key) {
+        return this.lists.get(key)?.length ?? 0;
+    }
+    async publish(channel, message) {
+        const subs = this.subscribers.get(channel);
+        if (!subs)
+            return 0;
+        subs.forEach(cb => cb(message));
+        return subs.size;
+    }
+    async subscribe(channel, callback) {
+        if (!this.subscribers.has(channel)) {
+            this.subscribers.set(channel, new Set());
+        }
+        this.subscribers.get(channel).add(callback);
+    }
+    async unsubscribe(channel) {
+        this.subscribers.delete(channel);
+    }
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+        this.store.clear();
+        this.hashes.clear();
+        this.lists.clear();
+        this.subscribers.clear();
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+exports.MemoryRedisAdapter = MemoryRedisAdapter;
+// Factory functions
+function createUpstashRedis(config) {
+    return new UpstashRedisAdapter(config);
+}
+function createMemoryRedis() {
+    return new MemoryRedisAdapter();
+}

package/dist/db/sqlite.d.ts

@@ -0,0 +1,66 @@
+/**
+ * SQLite Database Adapter
+ * Persistent storage using SQLite for sessions, messages, and runs
+ */
+export interface SQLiteConfig {
+    filename: string;
+    verbose?: boolean;
+}
+export interface DbMessage {
+    id: string;
+    sessionId: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    toolCalls?: string;
+    createdAt: number;
+    metadata?: string;
+}
+export interface DbRun {
+    id: string;
+    sessionId: string;
+    agentId?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    input?: string;
+    output?: string;
+    error?: string;
+    startedAt: number;
+    completedAt?: number;
+    metadata?: string;
+}
+export interface DbTrace {
+    id: string;
+    runId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    type: string;
+    startedAt: number;
+    completedAt?: number;
+    attributes?: string;
+    status?: string;
+}
+/**
+ * SQLite Adapter - Uses better-sqlite3 for synchronous operations
+ * Falls back to sql.js for browser compatibility
+ */
+export declare class SQLiteAdapter {
+    private db;
+    private filename;
+    private verbose;
+    private initialized;
+    constructor(config: SQLiteConfig);
+    initialize(): Promise<void>;
+    private createTables;
+    createSession(id: string, metadata?: Record<string, any>): Promise<void>;
+    getSession(id: string): Promise<any | null>;
+    addMessage(message: DbMessage): Promise<void>;
+    getMessages(sessionId: string, limit?: number): Promise<DbMessage[]>;
+    createRun(run: DbRun): Promise<void>;
+    updateRun(id: string, updates: Partial<DbRun>): Promise<void>;
+    getRun(id: string): Promise<DbRun | null>;
+    addTrace(trace: DbTrace): Promise<void>;
+    getTraces(runId: string): Promise<DbTrace[]>;
+    close(): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare function createSQLiteAdapter(config: SQLiteConfig): SQLiteAdapter;