overai 1.4.0

package/dist/db/index.js

@@ -0,0 +1,75 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDbAdapter = createDbAdapter;
+exports.getDefaultDbAdapter = getDefaultDbAdapter;
+exports.setDefaultDbAdapter = setDefaultDbAdapter;
+exports.db = db;
+__exportStar(require("./types"), exports);
+// In-memory implementation as default/fallback
+class MemoryDbAdapter {
+    constructor() {
+        this.messages = [];
+        this.runs = [];
+        this.traces = [];
+    }
+    async saveMessage(message) {
+        this.messages.push(message);
+    }
+    async getMessages(sessionId, limit) {
+        const sessionMessages = this.messages
+            .filter(m => m.sessionId === sessionId)
+            .sort((a, b) => a.createdAt - b.createdAt);
+        return limit ? sessionMessages.slice(-limit) : sessionMessages;
+    }
+    async deleteMessages(sessionId) {
+        this.messages = this.messages.filter(m => m.sessionId !== sessionId);
+    }
+    async saveRun(run) {
+        this.runs.push(run);
+    }
+    async updateRun(runId, updates) {
+        const run = this.runs.find(r => r.id === runId);
+        if (run) {
+            Object.assign(run, updates);
+        }
+    }
+    async saveTrace(trace) {
+        this.traces.push(trace);
+    }
+    async close() {
+        // No-op for memory
+    }
+}
+let defaultAdapter;
+function createDbAdapter(config) {
+    // Placeholder: Real implementation would switch on config.type or connection string
+    // For now, return Memory adapter to satisfy types
+    console.warn("Using in-memory DB adapter (placeholder)");
+    return new MemoryDbAdapter();
+}
+function getDefaultDbAdapter() {
+    return defaultAdapter;
+}
+function setDefaultDbAdapter(adapter) {
+    defaultAdapter = adapter;
+}
+function db(connectionString) {
+    if (!connectionString && defaultAdapter) {
+        return defaultAdapter;
+    }
+    return createDbAdapter(connectionString || { type: 'memory' });
+}

package/dist/db/types.d.ts

@@ -0,0 +1,42 @@
+export interface DbMessage {
+    id: string;
+    sessionId: string;
+    runId: string;
+    role: string;
+    content: string;
+    createdAt: number;
+    tool_calls?: any[];
+    tool_call_id?: string;
+}
+export interface DbRun {
+    id: string;
+    agentName: string;
+    instructions: string;
+    startTime: number;
+    endTime?: number;
+    status: 'running' | 'completed' | 'failed';
+    error?: string;
+}
+export interface DbTrace {
+    id: string;
+    runId: string;
+    type: string;
+    input: any;
+    output: any;
+    startTime: number;
+    endTime: number;
+}
+export interface DbConfig {
+    url?: string;
+    type?: 'sqlite' | 'postgres' | 'redis' | 'memory';
+    path?: string;
+}
+export interface DbAdapter {
+    saveMessage(message: DbMessage): Promise<void>;
+    getMessages(sessionId: string, limit?: number): Promise<DbMessage[]>;
+    deleteMessages(sessionId: string): Promise<void>;
+    saveRun(run: DbRun): Promise<void>;
+    updateRun(runId: string, updates: Partial<DbRun>): Promise<void>;
+    saveTrace(trace: DbTrace): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/db/types.js

@@ -0,0 +1,2 @@
+"use strict";
+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/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/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;
+};