praisonai 1.2.0 → 1.2.2

package/dist/db/sqlite.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * SQLite Database Adapter
+ * Persistent storage using SQLite for sessions, messages, and runs
+ */
+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.SQLiteAdapter = void 0;
+exports.createSQLiteAdapter = createSQLiteAdapter;
+/**
+ * SQLite Adapter - Uses better-sqlite3 for synchronous operations
+ * Falls back to sql.js for browser compatibility
+ */
+class SQLiteAdapter {
+    constructor(config) {
+        this.initialized = false;
+        this.filename = config.filename;
+        this.verbose = config.verbose || false;
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            // Try better-sqlite3 first (Node.js)
+            // @ts-ignore - optional dependency
+            const Database = (await Promise.resolve().then(() => __importStar(require('better-sqlite3')))).default;
+            this.db = new Database(this.filename, { verbose: this.verbose ? console.log : undefined });
+            this.db.pragma('journal_mode = WAL');
+        }
+        catch (e) {
+            // Fallback to in-memory Map-based storage
+            console.warn('SQLite not available, using in-memory storage');
+            this.db = new InMemoryDb();
+        }
+        await this.createTables();
+        this.initialized = true;
+    }
+    async createTables() {
+        if (this.db.exec) {
+            // better-sqlite3
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS messages (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          role TEXT NOT NULL,
+          content TEXT NOT NULL,
+          tool_calls TEXT,
+          created_at INTEGER NOT NULL,
+          metadata TEXT,
+          FOREIGN KEY (session_id) REFERENCES sessions(id)
+        );
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          id TEXT PRIMARY KEY,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          metadata TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS runs (
+          id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          agent_id TEXT,
+          status TEXT NOT NULL,
+          input TEXT,
+          output TEXT,
+          error TEXT,
+          started_at INTEGER NOT NULL,
+          completed_at INTEGER,
+          metadata TEXT
+        );
+
+        CREATE TABLE IF NOT EXISTS traces (
+          id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL,
+          span_id TEXT NOT NULL,
+          parent_span_id TEXT,
+          name TEXT NOT NULL,
+          type TEXT NOT NULL,
+          started_at INTEGER NOT NULL,
+          completed_at INTEGER,
+          attributes TEXT,
+          status TEXT
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+        CREATE INDEX IF NOT EXISTS idx_runs_session ON runs(session_id);
+        CREATE INDEX IF NOT EXISTS idx_traces_run ON traces(run_id);
+      `);
+        }
+        else {
+            // In-memory fallback
+            await this.db.createTables();
+        }
+    }
+    // Session operations
+    async createSession(id, metadata) {
+        await this.initialize();
+        const now = Date.now();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('INSERT OR REPLACE INTO sessions (id, created_at, updated_at, metadata) VALUES (?, ?, ?, ?)');
+            stmt.run(id, now, now, metadata ? JSON.stringify(metadata) : null);
+        }
+        else {
+            this.db.sessions.set(id, { id, createdAt: now, updatedAt: now, metadata });
+        }
+    }
+    async getSession(id) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('SELECT * FROM sessions WHERE id = ?');
+            const row = stmt.get(id);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+            };
+        }
+        else {
+            return this.db.sessions.get(id) || null;
+        }
+    }
+    // Message operations
+    async addMessage(message) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('INSERT INTO messages (id, session_id, role, content, tool_calls, created_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)');
+            stmt.run(message.id, message.sessionId, message.role, message.content, message.toolCalls || null, message.createdAt, message.metadata || null);
+        }
+        else {
+            this.db.messages.set(message.id, message);
+        }
+    }
+    async getMessages(sessionId, limit) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const query = limit
+                ? 'SELECT * FROM messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ?'
+                : 'SELECT * FROM messages WHERE session_id = ? ORDER BY created_at ASC';
+            const stmt = this.db.prepare(query);
+            const rows = limit ? stmt.all(sessionId, limit) : stmt.all(sessionId);
+            return rows.map((row) => ({
+                id: row.id,
+                sessionId: row.session_id,
+                role: row.role,
+                content: row.content,
+                toolCalls: row.tool_calls,
+                createdAt: row.created_at,
+                metadata: row.metadata
+            }));
+        }
+        else {
+            const messages = Array.from(this.db.messages.values())
+                .filter((m) => m.sessionId === sessionId)
+                .sort((a, b) => a.createdAt - b.createdAt);
+            return limit ? messages.slice(-limit) : messages;
+        }
+    }
+    // Run operations
+    async createRun(run) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('INSERT INTO runs (id, session_id, agent_id, status, input, output, error, started_at, completed_at, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+            stmt.run(run.id, run.sessionId, run.agentId || null, run.status, run.input || null, run.output || null, run.error || null, run.startedAt, run.completedAt || null, run.metadata || null);
+        }
+        else {
+            this.db.runs.set(run.id, run);
+        }
+    }
+    async updateRun(id, updates) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const fields = [];
+            const values = [];
+            if (updates.status !== undefined) {
+                fields.push('status = ?');
+                values.push(updates.status);
+            }
+            if (updates.output !== undefined) {
+                fields.push('output = ?');
+                values.push(updates.output);
+            }
+            if (updates.error !== undefined) {
+                fields.push('error = ?');
+                values.push(updates.error);
+            }
+            if (updates.completedAt !== undefined) {
+                fields.push('completed_at = ?');
+                values.push(updates.completedAt);
+            }
+            if (fields.length > 0) {
+                values.push(id);
+                const stmt = this.db.prepare(`UPDATE runs SET ${fields.join(', ')} WHERE id = ?`);
+                stmt.run(...values);
+            }
+        }
+        else {
+            const existing = this.db.runs.get(id);
+            if (existing) {
+                this.db.runs.set(id, { ...existing, ...updates });
+            }
+        }
+    }
+    async getRun(id) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('SELECT * FROM runs WHERE id = ?');
+            const row = stmt.get(id);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                sessionId: row.session_id,
+                agentId: row.agent_id,
+                status: row.status,
+                input: row.input,
+                output: row.output,
+                error: row.error,
+                startedAt: row.started_at,
+                completedAt: row.completed_at,
+                metadata: row.metadata
+            };
+        }
+        else {
+            return this.db.runs.get(id) || null;
+        }
+    }
+    // Trace operations
+    async addTrace(trace) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('INSERT INTO traces (id, run_id, span_id, parent_span_id, name, type, started_at, completed_at, attributes, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+            stmt.run(trace.id, trace.runId, trace.spanId, trace.parentSpanId || null, trace.name, trace.type, trace.startedAt, trace.completedAt || null, trace.attributes || null, trace.status || null);
+        }
+        else {
+            this.db.traces.set(trace.id, trace);
+        }
+    }
+    async getTraces(runId) {
+        await this.initialize();
+        if (this.db.prepare) {
+            const stmt = this.db.prepare('SELECT * FROM traces WHERE run_id = ? ORDER BY started_at ASC');
+            const rows = stmt.all(runId);
+            return rows.map((row) => ({
+                id: row.id,
+                runId: row.run_id,
+                spanId: row.span_id,
+                parentSpanId: row.parent_span_id,
+                name: row.name,
+                type: row.type,
+                startedAt: row.started_at,
+                completedAt: row.completed_at,
+                attributes: row.attributes,
+                status: row.status
+            }));
+        }
+        else {
+            return Array.from(this.db.traces.values())
+                .filter((t) => t.runId === runId)
+                .sort((a, b) => a.startedAt - b.startedAt);
+        }
+    }
+    // Cleanup
+    async close() {
+        if (this.db?.close) {
+            this.db.close();
+        }
+        this.initialized = false;
+    }
+    async clear() {
+        await this.initialize();
+        if (this.db.exec) {
+            this.db.exec('DELETE FROM traces; DELETE FROM runs; DELETE FROM messages; DELETE FROM sessions;');
+        }
+        else {
+            this.db.clear();
+        }
+    }
+}
+exports.SQLiteAdapter = SQLiteAdapter;
+/**
+ * In-memory fallback database
+ */
+class InMemoryDb {
+    constructor() {
+        this.sessions = new Map();
+        this.messages = new Map();
+        this.runs = new Map();
+        this.traces = new Map();
+    }
+    async createTables() {
+        // No-op for in-memory
+    }
+    clear() {
+        this.sessions.clear();
+        this.messages.clear();
+        this.runs.clear();
+        this.traces.clear();
+    }
+}
+// Factory function
+function createSQLiteAdapter(config) {
+    return new SQLiteAdapter(config);
+}

package/dist/events/index.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Event System - PubSub and Event Emitter for agent communication
+ * Inspired by mastra's events module
+ */
+import { EventEmitter } from 'events';
+export interface Event {
+    id: string;
+    topic: string;
+    data: any;
+    createdAt: Date;
+    metadata?: Record<string, any>;
+}
+export type EventHandler = (event: Event, ack?: () => Promise<void>) => void | Promise<void>;
+/**
+ * Abstract PubSub base class
+ */
+export declare abstract class PubSub {
+    abstract publish(topic: string, data: any, metadata?: Record<string, any>): Promise<void>;
+    abstract subscribe(topic: string, handler: EventHandler): Promise<void>;
+    abstract unsubscribe(topic: string, handler: EventHandler): Promise<void>;
+    abstract close(): Promise<void>;
+}
+/**
+ * In-memory EventEmitter-based PubSub implementation
+ */
+export declare class EventEmitterPubSub extends PubSub {
+    private emitter;
+    private handlers;
+    constructor(existingEmitter?: EventEmitter);
+    publish(topic: string, data: any, metadata?: Record<string, any>): Promise<void>;
+    subscribe(topic: string, handler: EventHandler): Promise<void>;
+    unsubscribe(topic: string, handler: EventHandler): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Wait for a specific event with optional timeout
+     */
+    waitFor(topic: string, timeout?: number): Promise<Event>;
+    /**
+     * Get the underlying EventEmitter
+     */
+    getEmitter(): EventEmitter;
+}
+/**
+ * Agent Event Bus - Specialized event system for agent communication
+ */
+export declare class AgentEventBus {
+    private pubsub;
+    private agentId;
+    constructor(agentId: string, pubsub?: PubSub);
+    /**
+     * Emit an agent event
+     */
+    emit(eventType: string, data: any): Promise<void>;
+    /**
+     * Listen for agent events
+     */
+    on(eventType: string, handler: (data: any) => void | Promise<void>): Promise<void>;
+    /**
+     * Broadcast to all agents
+     */
+    broadcast(eventType: string, data: any): Promise<void>;
+    /**
+     * Listen for broadcast events
+     */
+    onBroadcast(eventType: string, handler: (data: any, sourceAgentId: string) => void | Promise<void>): Promise<void>;
+    /**
+     * Send message to specific agent
+     */
+    sendTo(targetAgentId: string, eventType: string, data: any): Promise<void>;
+    close(): Promise<void>;
+}
+export declare const AgentEvents: {
+    readonly STARTED: "started";
+    readonly COMPLETED: "completed";
+    readonly ERROR: "error";
+    readonly TOOL_CALLED: "tool_called";
+    readonly TOOL_RESULT: "tool_result";
+    readonly MESSAGE_RECEIVED: "message_received";
+    readonly MESSAGE_SENT: "message_sent";
+    readonly HANDOFF_INITIATED: "handoff_initiated";
+    readonly HANDOFF_COMPLETED: "handoff_completed";
+};
+export declare function createEventBus(agentId: string): AgentEventBus;
+export declare function createPubSub(): EventEmitterPubSub;

package/dist/events/index.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Event System - PubSub and Event Emitter for agent communication
+ * Inspired by mastra's events module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentEvents = exports.AgentEventBus = exports.EventEmitterPubSub = exports.PubSub = void 0;
+exports.createEventBus = createEventBus;
+exports.createPubSub = createPubSub;
+const events_1 = require("events");
+/**
+ * Abstract PubSub base class
+ */
+class PubSub {
+}
+exports.PubSub = PubSub;
+/**
+ * In-memory EventEmitter-based PubSub implementation
+ */
+class EventEmitterPubSub extends PubSub {
+    constructor(existingEmitter) {
+        super();
+        this.handlers = new Map();
+        this.emitter = existingEmitter ?? new events_1.EventEmitter();
+        this.emitter.setMaxListeners(100); // Allow many listeners
+    }
+    async publish(topic, data, metadata) {
+        const event = {
+            id: crypto.randomUUID(),
+            topic,
+            data,
+            createdAt: new Date(),
+            metadata
+        };
+        this.emitter.emit(topic, event);
+    }
+    async subscribe(topic, handler) {
+        if (!this.handlers.has(topic)) {
+            this.handlers.set(topic, new Set());
+        }
+        this.handlers.get(topic).add(handler);
+        this.emitter.on(topic, handler);
+    }
+    async unsubscribe(topic, handler) {
+        this.handlers.get(topic)?.delete(handler);
+        this.emitter.off(topic, handler);
+    }
+    async close() {
+        this.emitter.removeAllListeners();
+        this.handlers.clear();
+    }
+    /**
+     * Wait for a specific event with optional timeout
+     */
+    async waitFor(topic, timeout) {
+        return new Promise((resolve, reject) => {
+            const timer = timeout ? setTimeout(() => {
+                this.emitter.off(topic, handler);
+                reject(new Error(`Timeout waiting for event: ${topic}`));
+            }, timeout) : null;
+            const handler = (event) => {
+                if (timer)
+                    clearTimeout(timer);
+                this.emitter.off(topic, handler);
+                resolve(event);
+            };
+            this.emitter.once(topic, handler);
+        });
+    }
+    /**
+     * Get the underlying EventEmitter
+     */
+    getEmitter() {
+        return this.emitter;
+    }
+}
+exports.EventEmitterPubSub = EventEmitterPubSub;
+/**
+ * Agent Event Bus - Specialized event system for agent communication
+ */
+class AgentEventBus {
+    constructor(agentId, pubsub) {
+        this.agentId = agentId;
+        this.pubsub = pubsub ?? new EventEmitterPubSub();
+    }
+    /**
+     * Emit an agent event
+     */
+    async emit(eventType, data) {
+        await this.pubsub.publish(`agent:${this.agentId}:${eventType}`, data, {
+            agentId: this.agentId,
+            eventType
+        });
+    }
+    /**
+     * Listen for agent events
+     */
+    async on(eventType, handler) {
+        await this.pubsub.subscribe(`agent:${this.agentId}:${eventType}`, (event) => {
+            handler(event.data);
+        });
+    }
+    /**
+     * Broadcast to all agents
+     */
+    async broadcast(eventType, data) {
+        await this.pubsub.publish(`broadcast:${eventType}`, data, {
+            sourceAgentId: this.agentId,
+            eventType
+        });
+    }
+    /**
+     * Listen for broadcast events
+     */
+    async onBroadcast(eventType, handler) {
+        await this.pubsub.subscribe(`broadcast:${eventType}`, (event) => {
+            handler(event.data, event.metadata?.sourceAgentId);
+        });
+    }
+    /**
+     * Send message to specific agent
+     */
+    async sendTo(targetAgentId, eventType, data) {
+        await this.pubsub.publish(`agent:${targetAgentId}:${eventType}`, data, {
+            sourceAgentId: this.agentId,
+            targetAgentId,
+            eventType
+        });
+    }
+    async close() {
+        await this.pubsub.close();
+    }
+}
+exports.AgentEventBus = AgentEventBus;
+// Standard event types
+exports.AgentEvents = {
+    STARTED: 'started',
+    COMPLETED: 'completed',
+    ERROR: 'error',
+    TOOL_CALLED: 'tool_called',
+    TOOL_RESULT: 'tool_result',
+    MESSAGE_RECEIVED: 'message_received',
+    MESSAGE_SENT: 'message_sent',
+    HANDOFF_INITIATED: 'handoff_initiated',
+    HANDOFF_COMPLETED: 'handoff_completed'
+};
+// Factory functions
+function createEventBus(agentId) {
+    return new AgentEventBus(agentId);
+}
+function createPubSub() {
+    return new EventEmitterPubSub();
+}

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export * from './knowledge';
 export * from './llm';
 export * from './memory';
 export * from './process';
-export { Tool, BaseTool, FunctionTool, tool, ToolRegistry, getRegistry, registerTool, getTool, type ToolConfig, type ToolContext, type ToolParameters } from './tools';
+export { BaseTool, ToolResult, ToolValidationError, validateTool, createTool, FunctionTool, tool, ToolRegistry, getRegistry, registerTool, getTool, type ToolConfig, type ToolContext, type ToolParameters } from './tools';
 export * from './tools/arxivTools';
 export * from './tools/mcpSse';
 export * from './session';
@@ -28,4 +28,15 @@ export { PromptExpanderAgent, createPromptExpanderAgent, type PromptExpanderConf
 export { Chunking, createChunking, type ChunkingConfig, type Chunk, type ChunkStrategy } from './knowledge/chunking';
 export { LLMGuardrail, createLLMGuardrail, type LLMGuardrailConfig, type LLMGuardrailResult } from './guardrails/llm-guardrail';
 export { Plan, PlanStep, TodoList, TodoItem, PlanStorage, createPlan, createTodoList, createPlanStorage, type PlanConfig, type PlanStepConfig, type TodoItemConfig, type PlanStatus, type TodoStatus } from './planning';
+export { BaseCache, MemoryCache, FileCache, createMemoryCache, createFileCache, type CacheConfig, type CacheEntry } from './cache';
+export { PubSub, EventEmitterPubSub, AgentEventBus, AgentEvents, createEventBus, createPubSub, type Event, type EventHandler } from './events';
+export { parseYAMLWorkflow, createWorkflowFromYAML, loadWorkflowFromFile, validateWorkflowDefinition, type YAMLWorkflowDefinition, type YAMLStepDefinition, type ParsedWorkflow } from './workflows/yaml-parser';
+export { SQLiteAdapter, createSQLiteAdapter, type SQLiteConfig, type DbMessage, type DbRun, type DbTrace } from './db/sqlite';
+export { UpstashRedisAdapter, MemoryRedisAdapter, createUpstashRedis, createMemoryRedis, type RedisConfig, type RedisAdapter } from './db/redis';
+export { NeonPostgresAdapter, MemoryPostgresAdapter, PostgresSessionStorage, createNeonPostgres, createMemoryPostgres, createPostgresSessionStorage, type PostgresConfig, type PostgresAdapter } from './db/postgres';
+export { BaseVectorStore, MemoryVectorStore, createMemoryVectorStore, PineconeVectorStore, createPineconeStore, WeaviateVectorStore, createWeaviateStore, QdrantVectorStore, createQdrantStore, ChromaVectorStore, createChromaStore, type VectorDocument, type QueryResult as VectorQueryResult, type IndexStats } from './integrations/vector';
+export { BaseObservabilityProvider, ConsoleObservabilityProvider, MemoryObservabilityProvider, LangfuseObservabilityProvider, createConsoleObservability, createMemoryObservability, createLangfuseObservability, type Span, type TraceContext as ObservabilityTraceContext, type LogEntry, type Metric } from './integrations/observability';
+export { BaseVoiceProvider, OpenAIVoiceProvider, ElevenLabsVoiceProvider, createOpenAIVoice, createElevenLabsVoice, type VoiceConfig, type SpeakOptions, type ListenOptions, type Speaker } from './integrations/voice';
+export { BaseReranker, CohereReranker, CrossEncoderReranker, LLMReranker, createCohereReranker, createCrossEncoderReranker, createLLMReranker, type RerankResult, type RerankConfig } from './knowledge/reranker';
+export { GraphStore, GraphRAG, createGraphRAG, type GraphNode, type GraphEdge, type GraphQueryResult, type GraphRAGConfig } from './knowledge/graph-rag';
 export { createProvider, getDefaultProvider, parseModelString, isProviderAvailable, getAvailableProviders, OpenAIProvider, AnthropicProvider, GoogleProvider, BaseProvider, type LLMProvider, type ProviderConfig, type ProviderFactory, type GenerateTextOptions, type GenerateTextResult, type StreamTextOptions, type StreamChunk, type GenerateObjectOptions, type GenerateObjectResult, type TokenUsage, type Message as ProviderMessage, type ToolCall, type ToolDefinition as ProviderToolDefinition, } from './llm/providers';