overai 1.4.0

package/dist/memory/file-memory.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * File-based Memory Storage
+ * Persistent memory using JSONL files with lockfile support for concurrent access
+ */
+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.FileMemory = void 0;
+exports.createFileMemory = createFileMemory;
+/**
+ * FileMemory - Append-only JSONL storage with compaction
+ */
+class FileMemory {
+    constructor(config) {
+        this.entries = new Map();
+        this.initialized = false;
+        this.writeQueue = Promise.resolve();
+        this.filePath = config.filePath;
+        this.maxEntries = config.maxEntries ?? 10000;
+        this.embeddingProvider = config.embeddingProvider;
+        this.compactionThreshold = config.compactionThreshold ?? 1000;
+        this.autoCompact = config.autoCompact ?? true;
+    }
+    /**
+     * Initialize and load existing entries
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const content = await fs.readFile(this.filePath, 'utf-8').catch(() => '');
+            if (content) {
+                const lines = content.trim().split('\n').filter(Boolean);
+                let deletedCount = 0;
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.deleted) {
+                            this.entries.delete(entry.id);
+                            deletedCount++;
+                        }
+                        else {
+                            this.entries.set(entry.id, entry);
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+                // Auto-compact if too many deleted entries
+                if (this.autoCompact && deletedCount > this.compactionThreshold) {
+                    await this.compact();
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * Add a memory entry
+     */
+    async add(content, role, metadata) {
+        await this.initialize();
+        const id = this.generateId();
+        const entry = {
+            id,
+            content,
+            role,
+            timestamp: Date.now(),
+            metadata
+        };
+        if (this.embeddingProvider) {
+            entry.embedding = await this.embeddingProvider.embed(content);
+        }
+        this.entries.set(id, entry);
+        await this.appendEntry(entry);
+        this.enforceLimit();
+        return entry;
+    }
+    /**
+     * Get a memory entry by ID
+     */
+    async get(id) {
+        await this.initialize();
+        const entry = this.entries.get(id);
+        return entry && !entry.deleted ? entry : undefined;
+    }
+    /**
+     * Get all entries
+     */
+    async getAll() {
+        await this.initialize();
+        return Array.from(this.entries.values())
+            .filter(e => !e.deleted)
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+    /**
+     * Get recent entries
+     */
+    async getRecent(count) {
+        const all = await this.getAll();
+        return all.slice(-count);
+    }
+    /**
+     * Search memory by text similarity
+     */
+    async search(query, limit = 5) {
+        await this.initialize();
+        if (!this.embeddingProvider) {
+            return this.textSearch(query, limit);
+        }
+        const queryEmbedding = await this.embeddingProvider.embed(query);
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.deleted)
+                continue;
+            if (entry.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, entry.embedding);
+                results.push({ entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Delete a memory entry (soft delete)
+     */
+    async delete(id) {
+        await this.initialize();
+        const entry = this.entries.get(id);
+        if (!entry || entry.deleted)
+            return false;
+        entry.deleted = true;
+        await this.appendEntry({ id, deleted: true });
+        return true;
+    }
+    /**
+     * Clear all memory
+     */
+    async clear() {
+        await this.initialize();
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await fs.writeFile(this.filePath, '');
+        this.entries.clear();
+    }
+    /**
+     * Compact the file by removing deleted entries
+     */
+    async compact() {
+        await this.initialize();
+        const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const activeEntries = Array.from(this.entries.values()).filter(e => !e.deleted);
+        const content = activeEntries
+            .map(e => JSON.stringify(e))
+            .join('\n') + (activeEntries.length ? '\n' : '');
+        // Write to temp file first, then rename (atomic)
+        const tempPath = `${this.filePath}.tmp`;
+        await fs.writeFile(tempPath, content);
+        await fs.rename(tempPath, this.filePath);
+    }
+    /**
+     * Get memory size
+     */
+    get size() {
+        return Array.from(this.entries.values()).filter(e => !e.deleted).length;
+    }
+    /**
+     * Export memory to JSON
+     */
+    async toJSON() {
+        return this.getAll();
+    }
+    /**
+     * Import memory from JSON
+     */
+    async fromJSON(entries) {
+        await this.clear();
+        for (const entry of entries) {
+            this.entries.set(entry.id, entry);
+        }
+        await this.compact();
+    }
+    /**
+     * Build context string from recent memory
+     */
+    async buildContext(count) {
+        const entries = count ? await this.getRecent(count) : await this.getAll();
+        return entries
+            .map(e => `${e.role}: ${e.content}`)
+            .join('\n');
+    }
+    async appendEntry(entry) {
+        // Queue writes to ensure order
+        this.writeQueue = this.writeQueue.then(async () => {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            await fs.appendFile(this.filePath, JSON.stringify(entry) + '\n');
+        });
+        await this.writeQueue;
+    }
+    textSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.deleted)
+                continue;
+            const contentLower = entry.content.toLowerCase();
+            if (contentLower.includes(queryLower)) {
+                const score = queryLower.length / contentLower.length;
+                results.push({ entry, score: Math.min(score * 10, 1) });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    generateId() {
+        return `fmem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    enforceLimit() {
+        const active = Array.from(this.entries.values()).filter(e => !e.deleted);
+        while (active.length > this.maxEntries) {
+            const oldest = active.shift();
+            if (oldest) {
+                oldest.deleted = true;
+            }
+        }
+    }
+}
+exports.FileMemory = FileMemory;
+/**
+ * Create a file-based memory instance
+ */
+function createFileMemory(config) {
+    return new FileMemory(config);
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,26 @@
+export interface Memory {
+    id: string;
+    content: any;
+    timestamp: Date;
+    metadata: Record<string, any>;
+}
+export interface MemoryStore {
+    add(memory: Memory): void;
+    get(id: string): Memory | undefined;
+    search(query: string): Memory[];
+    update(id: string, memory: Partial<Memory>): boolean;
+    delete(id: string): boolean;
+    clear(): void;
+}
+export declare class BaseMemoryStore implements MemoryStore {
+    private memories;
+    constructor();
+    add(memory: Memory): void;
+    get(id: string): Memory | undefined;
+    search(query: string): Memory[];
+    update(id: string, update: Partial<Memory>): boolean;
+    delete(id: string): boolean;
+    clear(): void;
+}
+export { FileMemory, createFileMemory, type FileMemoryConfig, type FileMemoryEntry } from './file-memory';
+export { AutoMemory, createAutoMemory, createLLMSummarizer, DEFAULT_POLICIES, type AutoMemoryConfig, type AutoMemoryPolicy, type AutoMemoryContext, type VectorStoreAdapter, type KnowledgeBaseAdapter } from './auto-memory';

package/dist/memory/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_POLICIES = exports.createLLMSummarizer = exports.createAutoMemory = exports.AutoMemory = exports.createFileMemory = exports.FileMemory = exports.BaseMemoryStore = void 0;
+class BaseMemoryStore {
+    constructor() {
+        this.memories = new Map();
+    }
+    add(memory) {
+        this.memories.set(memory.id, memory);
+    }
+    get(id) {
+        return this.memories.get(id);
+    }
+    search(query) {
+        return Array.from(this.memories.values()).filter(m => JSON.stringify(m).toLowerCase().includes(query.toLowerCase()));
+    }
+    update(id, update) {
+        const existing = this.memories.get(id);
+        if (!existing)
+            return false;
+        this.memories.set(id, { ...existing, ...update });
+        return true;
+    }
+    delete(id) {
+        return this.memories.delete(id);
+    }
+    clear() {
+        this.memories.clear();
+    }
+}
+exports.BaseMemoryStore = BaseMemoryStore;
+// Export FileMemory
+var file_memory_1 = require("./file-memory");
+Object.defineProperty(exports, "FileMemory", { enumerable: true, get: function () { return file_memory_1.FileMemory; } });
+Object.defineProperty(exports, "createFileMemory", { enumerable: true, get: function () { return file_memory_1.createFileMemory; } });
+// Export AutoMemory
+var auto_memory_1 = require("./auto-memory");
+Object.defineProperty(exports, "AutoMemory", { enumerable: true, get: function () { return auto_memory_1.AutoMemory; } });
+Object.defineProperty(exports, "createAutoMemory", { enumerable: true, get: function () { return auto_memory_1.createAutoMemory; } });
+Object.defineProperty(exports, "createLLMSummarizer", { enumerable: true, get: function () { return auto_memory_1.createLLMSummarizer; } });
+Object.defineProperty(exports, "DEFAULT_POLICIES", { enumerable: true, get: function () { return auto_memory_1.DEFAULT_POLICIES; } });

package/dist/memory/memory.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Memory System - Conversation and context memory management
+ */
+export interface MemoryEntry {
+    id: string;
+    content: string;
+    role: 'user' | 'assistant' | 'system';
+    timestamp: number;
+    metadata?: Record<string, any>;
+    embedding?: number[];
+}
+export interface MemoryConfig {
+    maxEntries?: number;
+    maxTokens?: number;
+    embeddingProvider?: EmbeddingProvider;
+}
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+}
+export interface SearchResult {
+    entry: MemoryEntry;
+    score: number;
+}
+/**
+ * Memory class for managing conversation history and context
+ */
+export declare class Memory {
+    private entries;
+    private maxEntries;
+    private maxTokens;
+    private embeddingProvider?;
+    constructor(config?: MemoryConfig);
+    /**
+     * Add a memory entry
+     */
+    add(content: string, role: 'user' | 'assistant' | 'system', metadata?: Record<string, any>): Promise<MemoryEntry>;
+    /**
+     * Get a memory entry by ID
+     */
+    get(id: string): MemoryEntry | undefined;
+    /**
+     * Get all entries
+     */
+    getAll(): MemoryEntry[];
+    /**
+     * Get recent entries
+     */
+    getRecent(count: number): MemoryEntry[];
+    /**
+     * Search memory by text similarity
+     */
+    search(query: string, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Simple text search fallback
+     */
+    private textSearch;
+    /**
+     * Calculate cosine similarity
+     */
+    private cosineSimilarity;
+    /**
+     * Delete a memory entry
+     */
+    delete(id: string): boolean;
+    /**
+     * Clear all memory
+     */
+    clear(): void;
+    /**
+     * Get memory size
+     */
+    get size(): number;
+    /**
+     * Build context string from recent memory
+     */
+    buildContext(count?: number): string;
+    /**
+     * Export memory to JSON
+     */
+    toJSON(): MemoryEntry[];
+    /**
+     * Import memory from JSON
+     */
+    fromJSON(entries: MemoryEntry[]): void;
+    private generateId;
+    private enforceLimit;
+}
+/**
+ * Create a memory instance
+ */
+export declare function createMemory(config?: MemoryConfig): Memory;

package/dist/memory/memory.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Memory System - Conversation and context memory management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+exports.createMemory = createMemory;
+/**
+ * Memory class for managing conversation history and context
+ */
+class Memory {
+    constructor(config = {}) {
+        this.entries = new Map();
+        this.maxEntries = config.maxEntries ?? 1000;
+        this.maxTokens = config.maxTokens ?? 100000;
+        this.embeddingProvider = config.embeddingProvider;
+    }
+    /**
+     * Add a memory entry
+     */
+    async add(content, role, metadata) {
+        const id = this.generateId();
+        const entry = {
+            id,
+            content,
+            role,
+            timestamp: Date.now(),
+            metadata
+        };
+        if (this.embeddingProvider) {
+            entry.embedding = await this.embeddingProvider.embed(content);
+        }
+        this.entries.set(id, entry);
+        this.enforceLimit();
+        return entry;
+    }
+    /**
+     * Get a memory entry by ID
+     */
+    get(id) {
+        return this.entries.get(id);
+    }
+    /**
+     * Get all entries
+     */
+    getAll() {
+        return Array.from(this.entries.values())
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+    /**
+     * Get recent entries
+     */
+    getRecent(count) {
+        return this.getAll().slice(-count);
+    }
+    /**
+     * Search memory by text similarity
+     */
+    async search(query, limit = 5) {
+        if (!this.embeddingProvider) {
+            // Fallback to simple text matching
+            return this.textSearch(query, limit);
+        }
+        const queryEmbedding = await this.embeddingProvider.embed(query);
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, entry.embedding);
+                results.push({ entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Simple text search fallback
+     */
+    textSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const entry of this.entries.values()) {
+            const contentLower = entry.content.toLowerCase();
+            if (contentLower.includes(queryLower)) {
+                const score = queryLower.length / contentLower.length;
+                results.push({ entry, score: Math.min(score * 10, 1) });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Calculate cosine similarity
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Delete a memory entry
+     */
+    delete(id) {
+        return this.entries.delete(id);
+    }
+    /**
+     * Clear all memory
+     */
+    clear() {
+        this.entries.clear();
+    }
+    /**
+     * Get memory size
+     */
+    get size() {
+        return this.entries.size;
+    }
+    /**
+     * Build context string from recent memory
+     */
+    buildContext(count) {
+        const entries = count ? this.getRecent(count) : this.getAll();
+        return entries
+            .map(e => `${e.role}: ${e.content}`)
+            .join('\n');
+    }
+    /**
+     * Export memory to JSON
+     */
+    toJSON() {
+        return this.getAll();
+    }
+    /**
+     * Import memory from JSON
+     */
+    fromJSON(entries) {
+        this.entries.clear();
+        for (const entry of entries) {
+            this.entries.set(entry.id, entry);
+        }
+    }
+    generateId() {
+        return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    enforceLimit() {
+        while (this.entries.size > this.maxEntries) {
+            const oldest = this.getAll()[0];
+            if (oldest) {
+                this.entries.delete(oldest.id);
+            }
+        }
+    }
+}
+exports.Memory = Memory;
+/**
+ * Create a memory instance
+ */
+function createMemory(config) {
+    return new Memory(config);
+}

package/dist/observability/adapters/console.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Console Observability Adapter
+ * Logs traces and spans to console for debugging
+ */
+import type { ObservabilityAdapter, TraceContext, SpanContext, SpanKind, SpanStatus, AttributionContext } from '../types';
+/**
+ * Console Observability Adapter
+ * Wraps memory adapter and logs all operations to console
+ */
+export declare class ConsoleObservabilityAdapter implements ObservabilityAdapter {
+    readonly name = "console";
+    readonly isEnabled = true;
+    private memory;
+    private verbose;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    startTrace(name: string, metadata?: Record<string, unknown>, attribution?: AttributionContext): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, unknown>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, unknown>): void;
+    recordError(spanId: string, error: Error): void;
+    flush(): Promise<void>;
+    getTrace(traceId: string): import("../types").TraceData | undefined;
+    getAllTraces(): import("../types").TraceData[];
+    clear(): void;
+}
+export declare function createConsoleAdapter(options?: {
+    verbose?: boolean;
+}): ConsoleObservabilityAdapter;