praisonai 1.0.19 → 1.2.0

package/dist/db/memory-adapter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * In-Memory Database Adapter - Simple implementation for testing and development
+ */
+import type { DbAdapter, DbSession, DbMessage, DbRun, DbToolCall, DbTrace, DbSpan } from './types';
+export declare class MemoryDbAdapter implements DbAdapter {
+    private sessions;
+    private messages;
+    private runs;
+    private toolCalls;
+    private traces;
+    private spans;
+    private connected;
+    createSession(session: DbSession): Promise<void>;
+    getSession(id: string): Promise<DbSession | null>;
+    updateSession(id: string, updates: Partial<DbSession>): Promise<void>;
+    deleteSession(id: string): Promise<void>;
+    listSessions(limit?: number, offset?: number): Promise<DbSession[]>;
+    saveMessage(message: DbMessage): Promise<void>;
+    getMessages(sessionId: string, limit?: number): Promise<DbMessage[]>;
+    deleteMessages(sessionId: string): Promise<void>;
+    createRun(run: DbRun): Promise<void>;
+    getRun(id: string): Promise<DbRun | null>;
+    updateRun(id: string, updates: Partial<DbRun>): Promise<void>;
+    listRuns(sessionId: string, limit?: number): Promise<DbRun[]>;
+    saveToolCall(toolCall: DbToolCall): Promise<void>;
+    getToolCalls(runId: string): Promise<DbToolCall[]>;
+    createTrace(trace: DbTrace): Promise<void>;
+    getTrace(id: string): Promise<DbTrace | null>;
+    updateTrace(id: string, updates: Partial<DbTrace>): Promise<void>;
+    createSpan(span: DbSpan): Promise<void>;
+    getSpans(traceId: string): Promise<DbSpan[]>;
+    updateSpan(id: string, updates: Partial<DbSpan>): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    clear(): void;
+    getStats(): {
+        sessions: number;
+        messages: number;
+        runs: number;
+    };
+}

package/dist/db/memory-adapter.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * In-Memory Database Adapter - Simple implementation for testing and development
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDbAdapter = void 0;
+class MemoryDbAdapter {
+    constructor() {
+        this.sessions = new Map();
+        this.messages = new Map();
+        this.runs = new Map();
+        this.toolCalls = new Map();
+        this.traces = new Map();
+        this.spans = new Map();
+        this.connected = false;
+    }
+    // Session operations
+    async createSession(session) {
+        this.sessions.set(session.id, session);
+        this.messages.set(session.id, []);
+    }
+    async getSession(id) {
+        return this.sessions.get(id) || null;
+    }
+    async updateSession(id, updates) {
+        const session = this.sessions.get(id);
+        if (session) {
+            this.sessions.set(id, { ...session, ...updates, updatedAt: Date.now() });
+        }
+    }
+    async deleteSession(id) {
+        this.sessions.delete(id);
+        this.messages.delete(id);
+    }
+    async listSessions(limit = 100, offset = 0) {
+        const all = Array.from(this.sessions.values());
+        return all.slice(offset, offset + limit);
+    }
+    // Message operations
+    async saveMessage(message) {
+        const messages = this.messages.get(message.sessionId) || [];
+        messages.push(message);
+        this.messages.set(message.sessionId, messages);
+    }
+    async getMessages(sessionId, limit) {
+        const messages = this.messages.get(sessionId) || [];
+        if (limit) {
+            return messages.slice(-limit);
+        }
+        return messages;
+    }
+    async deleteMessages(sessionId) {
+        this.messages.set(sessionId, []);
+    }
+    // Run operations
+    async createRun(run) {
+        this.runs.set(run.id, run);
+        this.toolCalls.set(run.id, []);
+    }
+    async getRun(id) {
+        return this.runs.get(id) || null;
+    }
+    async updateRun(id, updates) {
+        const run = this.runs.get(id);
+        if (run) {
+            this.runs.set(id, { ...run, ...updates });
+        }
+    }
+    async listRuns(sessionId, limit = 100) {
+        const all = Array.from(this.runs.values()).filter(r => r.sessionId === sessionId);
+        return all.slice(-limit);
+    }
+    // Tool call operations
+    async saveToolCall(toolCall) {
+        const calls = this.toolCalls.get(toolCall.runId) || [];
+        calls.push(toolCall);
+        this.toolCalls.set(toolCall.runId, calls);
+    }
+    async getToolCalls(runId) {
+        return this.toolCalls.get(runId) || [];
+    }
+    // Trace operations
+    async createTrace(trace) {
+        this.traces.set(trace.id, trace);
+        this.spans.set(trace.id, []);
+    }
+    async getTrace(id) {
+        return this.traces.get(id) || null;
+    }
+    async updateTrace(id, updates) {
+        const trace = this.traces.get(id);
+        if (trace) {
+            this.traces.set(id, { ...trace, ...updates });
+        }
+    }
+    // Span operations
+    async createSpan(span) {
+        const spans = this.spans.get(span.traceId) || [];
+        spans.push(span);
+        this.spans.set(span.traceId, spans);
+    }
+    async getSpans(traceId) {
+        return this.spans.get(traceId) || [];
+    }
+    async updateSpan(id, updates) {
+        for (const [traceId, spans] of this.spans) {
+            const index = spans.findIndex(s => s.id === id);
+            if (index !== -1) {
+                spans[index] = { ...spans[index], ...updates };
+                this.spans.set(traceId, spans);
+                return;
+            }
+        }
+    }
+    // Lifecycle
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    // Utility methods
+    clear() {
+        this.sessions.clear();
+        this.messages.clear();
+        this.runs.clear();
+        this.toolCalls.clear();
+        this.traces.clear();
+        this.spans.clear();
+    }
+    getStats() {
+        let messageCount = 0;
+        for (const msgs of this.messages.values()) {
+            messageCount += msgs.length;
+        }
+        return {
+            sessions: this.sessions.size,
+            messages: messageCount,
+            runs: this.runs.size,
+        };
+    }
+}
+exports.MemoryDbAdapter = MemoryDbAdapter;

package/dist/db/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Database Adapter Types - Protocol definitions for persistence layer
+ */
+export interface DbMessage {
+    id: string;
+    sessionId: string;
+    runId?: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: any[];
+    createdAt: number;
+    metadata?: Record<string, any>;
+}
+export interface DbToolCall {
+    id: string;
+    runId: string;
+    name: string;
+    arguments: string;
+    result?: string;
+    status: 'pending' | 'completed' | 'failed';
+    startedAt: number;
+    completedAt?: number;
+    error?: string;
+}
+export interface DbRun {
+    id: string;
+    sessionId: string;
+    agentName?: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    startedAt: number;
+    completedAt?: number;
+    error?: string;
+    metadata?: Record<string, any>;
+    tokenUsage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface DbSession {
+    id: string;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, any>;
+}
+export interface DbSpan {
+    id: string;
+    traceId: string;
+    parentId?: string;
+    name: string;
+    startedAt: number;
+    completedAt?: number;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    attributes?: Record<string, any>;
+}
+export interface DbTrace {
+    id: string;
+    sessionId: string;
+    runId?: string;
+    agentName?: string;
+    startedAt: number;
+    completedAt?: number;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    metadata?: Record<string, any>;
+}
+/**
+ * Database Adapter Protocol - Interface for persistence implementations
+ */
+export interface DbAdapter {
+    createSession(session: DbSession): Promise<void>;
+    getSession(id: string): Promise<DbSession | null>;
+    updateSession(id: string, updates: Partial<DbSession>): Promise<void>;
+    deleteSession(id: string): Promise<void>;
+    listSessions(limit?: number, offset?: number): Promise<DbSession[]>;
+    saveMessage(message: DbMessage): Promise<void>;
+    getMessages(sessionId: string, limit?: number): Promise<DbMessage[]>;
+    deleteMessages(sessionId: string): Promise<void>;
+    createRun(run: DbRun): Promise<void>;
+    getRun(id: string): Promise<DbRun | null>;
+    updateRun(id: string, updates: Partial<DbRun>): Promise<void>;
+    listRuns(sessionId: string, limit?: number): Promise<DbRun[]>;
+    saveToolCall(toolCall: DbToolCall): Promise<void>;
+    getToolCalls(runId: string): Promise<DbToolCall[]>;
+    createTrace(trace: DbTrace): Promise<void>;
+    getTrace(id: string): Promise<DbTrace | null>;
+    updateTrace(id: string, updates: Partial<DbTrace>): Promise<void>;
+    createSpan(span: DbSpan): Promise<void>;
+    getSpans(traceId: string): Promise<DbSpan[]>;
+    updateSpan(id: string, updates: Partial<DbSpan>): Promise<void>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * Async Database Adapter - For async-first implementations
+ */
+export interface AsyncDbAdapter extends DbAdapter {
+}
+/**
+ * Database configuration
+ */
+export interface DbConfig {
+    type: 'sqlite' | 'postgres' | 'redis' | 'memory';
+    connectionString?: string;
+    path?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+}

package/dist/db/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Database Adapter Types - Protocol definitions for persistence layer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/eval/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Evaluation Framework - Accuracy, Performance, and Reliability evaluation
+ */
+export interface EvalResult {
+    passed: boolean;
+    score: number;
+    message?: string;
+    details?: Record<string, any>;
+    duration: number;
+}
+export interface AccuracyEvalConfig {
+    input: string;
+    expectedOutput: string;
+    actualOutput: string;
+    threshold?: number;
+}
+export interface PerformanceEvalConfig {
+    func: () => Promise<any>;
+    iterations?: number;
+    warmupRuns?: number;
+}
+export interface PerformanceResult extends EvalResult {
+    avgTime: number;
+    minTime: number;
+    maxTime: number;
+    p95Time: number;
+    times: number[];
+}
+export interface ReliabilityEvalConfig {
+    expectedToolCalls: string[];
+    actualToolCalls: string[];
+}
+/**
+ * Accuracy Evaluation - Compare actual output to expected
+ */
+export declare function accuracyEval(config: AccuracyEvalConfig): Promise<EvalResult>;
+/**
+ * Performance Evaluation - Measure execution time
+ */
+export declare function performanceEval(config: PerformanceEvalConfig): Promise<PerformanceResult>;
+/**
+ * Reliability Evaluation - Check tool call accuracy
+ */
+export declare function reliabilityEval(config: ReliabilityEvalConfig): Promise<EvalResult>;
+/**
+ * Eval Suite - Run multiple evaluations
+ */
+export declare class EvalSuite {
+    private results;
+    runAccuracy(name: string, config: AccuracyEvalConfig): Promise<EvalResult>;
+    runPerformance(name: string, config: PerformanceEvalConfig): Promise<PerformanceResult>;
+    runReliability(name: string, config: ReliabilityEvalConfig): Promise<EvalResult>;
+    getResults(): Map<string, EvalResult>;
+    getSummary(): {
+        total: number;
+        passed: number;
+        failed: number;
+        avgScore: number;
+    };
+    printSummary(): void;
+}

package/dist/eval/index.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * Evaluation Framework - Accuracy, Performance, and Reliability evaluation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvalSuite = void 0;
+exports.accuracyEval = accuracyEval;
+exports.performanceEval = performanceEval;
+exports.reliabilityEval = reliabilityEval;
+/**
+ * Accuracy Evaluation - Compare actual output to expected
+ */
+async function accuracyEval(config) {
+    const start = Date.now();
+    const threshold = config.threshold ?? 0.8;
+    const similarity = calculateSimilarity(config.expectedOutput, config.actualOutput);
+    const passed = similarity >= threshold;
+    return {
+        passed,
+        score: similarity,
+        message: passed ? 'Output matches expected' : 'Output does not match expected',
+        details: {
+            expected: config.expectedOutput,
+            actual: config.actualOutput,
+            threshold
+        },
+        duration: Date.now() - start
+    };
+}
+/**
+ * Performance Evaluation - Measure execution time
+ */
+async function performanceEval(config) {
+    const iterations = config.iterations ?? 10;
+    const warmupRuns = config.warmupRuns ?? 2;
+    const times = [];
+    // Warmup runs
+    for (let i = 0; i < warmupRuns; i++) {
+        await config.func();
+    }
+    // Actual runs
+    const start = Date.now();
+    for (let i = 0; i < iterations; i++) {
+        const runStart = Date.now();
+        await config.func();
+        times.push(Date.now() - runStart);
+    }
+    const sortedTimes = [...times].sort((a, b) => a - b);
+    const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
+    const minTime = sortedTimes[0];
+    const maxTime = sortedTimes[sortedTimes.length - 1];
+    const p95Index = Math.floor(sortedTimes.length * 0.95);
+    const p95Time = sortedTimes[p95Index] || maxTime;
+    return {
+        passed: true,
+        score: 1,
+        avgTime,
+        minTime,
+        maxTime,
+        p95Time,
+        times,
+        duration: Date.now() - start,
+        details: {
+            iterations,
+            warmupRuns
+        }
+    };
+}
+/**
+ * Reliability Evaluation - Check tool call accuracy
+ */
+async function reliabilityEval(config) {
+    const start = Date.now();
+    const expected = new Set(config.expectedToolCalls);
+    const actual = new Set(config.actualToolCalls);
+    const matched = config.expectedToolCalls.filter(t => actual.has(t));
+    const missing = config.expectedToolCalls.filter(t => !actual.has(t));
+    const extra = config.actualToolCalls.filter(t => !expected.has(t));
+    const score = expected.size > 0 ? matched.length / expected.size : 1;
+    const passed = missing.length === 0;
+    return {
+        passed,
+        score,
+        message: passed ? 'All expected tool calls made' : `Missing tool calls: ${missing.join(', ')}`,
+        details: {
+            matched,
+            missing,
+            extra,
+            expected: config.expectedToolCalls,
+            actual: config.actualToolCalls
+        },
+        duration: Date.now() - start
+    };
+}
+/**
+ * Calculate text similarity (simple Jaccard similarity)
+ */
+function calculateSimilarity(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = new Set(b.toLowerCase().split(/\s+/));
+    const intersection = new Set([...wordsA].filter(x => wordsB.has(x)));
+    const union = new Set([...wordsA, ...wordsB]);
+    return union.size > 0 ? intersection.size / union.size : 0;
+}
+/**
+ * Eval Suite - Run multiple evaluations
+ */
+class EvalSuite {
+    constructor() {
+        this.results = new Map();
+    }
+    async runAccuracy(name, config) {
+        const result = await accuracyEval(config);
+        this.results.set(name, result);
+        return result;
+    }
+    async runPerformance(name, config) {
+        const result = await performanceEval(config);
+        this.results.set(name, result);
+        return result;
+    }
+    async runReliability(name, config) {
+        const result = await reliabilityEval(config);
+        this.results.set(name, result);
+        return result;
+    }
+    getResults() {
+        return new Map(this.results);
+    }
+    getSummary() {
+        const results = Array.from(this.results.values());
+        const passed = results.filter(r => r.passed).length;
+        const avgScore = results.length > 0
+            ? results.reduce((a, b) => a + b.score, 0) / results.length
+            : 0;
+        return {
+            total: results.length,
+            passed,
+            failed: results.length - passed,
+            avgScore
+        };
+    }
+    printSummary() {
+        const summary = this.getSummary();
+        console.log('\n=== Evaluation Summary ===');
+        console.log(`Total: ${summary.total}`);
+        console.log(`Passed: ${summary.passed}`);
+        console.log(`Failed: ${summary.failed}`);
+        console.log(`Avg Score: ${(summary.avgScore * 100).toFixed(1)}%`);
+        console.log('\nResults:');
+        for (const [name, result] of this.results) {
+            const status = result.passed ? '✅' : '❌';
+            console.log(`  ${status} ${name}: ${(result.score * 100).toFixed(1)}%`);
+        }
+    }
+}
+exports.EvalSuite = EvalSuite;

package/dist/guardrails/index.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Guardrails - Input/output validation and safety checks
+ */
+export type GuardrailStatus = 'passed' | 'failed' | 'warning';
+export interface GuardrailResult {
+    status: GuardrailStatus;
+    message?: string;
+    details?: Record<string, any>;
+    modifiedContent?: string;
+}
+export type GuardrailFunction = (content: string, context?: GuardrailContext) => Promise<GuardrailResult> | GuardrailResult;
+export interface GuardrailContext {
+    role: 'input' | 'output';
+    agentName?: string;
+    sessionId?: string;
+    metadata?: Record<string, any>;
+}
+export interface GuardrailConfig {
+    name: string;
+    description?: string;
+    check: GuardrailFunction;
+    onFail?: 'block' | 'warn' | 'modify';
+}
+/**
+ * Guardrail class
+ */
+export declare class Guardrail {
+    readonly name: string;
+    readonly description: string;
+    readonly check: GuardrailFunction;
+    readonly onFail: 'block' | 'warn' | 'modify';
+    constructor(config: GuardrailConfig);
+    run(content: string, context?: GuardrailContext): Promise<GuardrailResult>;
+}
+/**
+ * Create a guardrail
+ */
+export declare function guardrail(config: GuardrailConfig): Guardrail;
+/**
+ * Guardrail Manager - Run multiple guardrails
+ */
+export declare class GuardrailManager {
+    private guardrails;
+    add(g: Guardrail): this;
+    runAll(content: string, context?: GuardrailContext): Promise<{
+        passed: boolean;
+        results: Array<{
+            name: string;
+            result: GuardrailResult;
+        }>;
+    }>;
+    get count(): number;
+}
+/**
+ * Built-in guardrails
+ */
+export declare const builtinGuardrails: {
+    /**
+     * Check for maximum length
+     */
+    maxLength: (maxChars: number) => Guardrail;
+    /**
+     * Check for minimum length
+     */
+    minLength: (minChars: number) => Guardrail;
+    /**
+     * Check for blocked words
+     */
+    blockedWords: (words: string[]) => Guardrail;
+    /**
+     * Check for required words
+     */
+    requiredWords: (words: string[]) => Guardrail;
+    /**
+     * Regex pattern check
+     */
+    pattern: (regex: RegExp, mustMatch?: boolean) => Guardrail;
+    /**
+     * JSON validity check
+     */
+    validJson: () => Guardrail;
+};