overai 1.4.0

package/dist/llm/providers/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * LLM Provider Types - Core type definitions for the provider abstraction layer
+ */
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolDefinition {
+    name: string;
+    description?: string;
+    parameters?: Record<string, any>;
+}
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface GenerateTextOptions {
+    messages: Message[];
+    temperature?: number;
+    maxTokens?: number;
+    tools?: ToolDefinition[];
+    toolChoice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    stop?: string[];
+    topP?: number;
+    frequencyPenalty?: number;
+    presencePenalty?: number;
+}
+export interface GenerateTextResult {
+    text: string;
+    toolCalls?: ToolCall[];
+    usage: TokenUsage;
+    finishReason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'error';
+    raw?: any;
+}
+export interface StreamTextOptions extends GenerateTextOptions {
+    onToken?: (token: string) => void;
+    onToolCall?: (toolCall: ToolCall) => void;
+}
+export interface StreamChunk {
+    text?: string;
+    toolCalls?: ToolCall[];
+    usage?: Partial<TokenUsage>;
+    finishReason?: string;
+}
+export interface GenerateObjectOptions<T = any> {
+    messages: Message[];
+    schema: Record<string, any> | any;
+    temperature?: number;
+    maxTokens?: number;
+    maxRetries?: number;
+}
+export interface GenerateObjectResult<T = any> {
+    object: T;
+    usage: TokenUsage;
+    raw?: any;
+}
+export interface ProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    maxRetries?: number;
+    timeout?: number;
+    defaultModel?: string;
+}
+/**
+ * Base interface for all LLM providers
+ */
+export interface LLMProvider {
+    readonly providerId: string;
+    readonly modelId: string;
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: StreamTextOptions): Promise<AsyncIterable<StreamChunk>>;
+    generateObject<T = any>(options: GenerateObjectOptions<T>): Promise<GenerateObjectResult<T>>;
+}
+/**
+ * Provider factory function type
+ */
+export type ProviderFactory = (modelId: string, config?: ProviderConfig) => LLMProvider;

package/dist/llm/providers/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * LLM Provider Types - Core type definitions for the provider abstraction layer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/main.js

@@ -0,0 +1 @@
+"use strict";

package/dist/memory/auto-memory.d.ts

@@ -0,0 +1,136 @@
+/**
+ * AutoMemory - Policy-based automatic memory capture
+ * Integrates with Memory, KnowledgeBase, and Vector stores
+ */
+import { Memory, MemoryEntry, MemoryConfig } from './memory';
+export interface AutoMemoryPolicy {
+    name: string;
+    condition: (content: string, role: string, context: AutoMemoryContext) => boolean;
+    action: 'store' | 'summarize' | 'vectorize' | 'skip';
+    priority?: number;
+}
+export interface AutoMemoryContext {
+    messageCount: number;
+    tokenCount: number;
+    lastSummaryAt?: number;
+    metadata: Record<string, any>;
+}
+export interface AutoMemoryConfig extends MemoryConfig {
+    policies?: AutoMemoryPolicy[];
+    summaryThreshold?: number;
+    vectorizeThreshold?: number;
+    summarizer?: (entries: MemoryEntry[]) => Promise<string>;
+    vectorStore?: VectorStoreAdapter;
+    knowledgeBase?: KnowledgeBaseAdapter;
+}
+export interface VectorStoreAdapter {
+    add(id: string, embedding: number[], metadata?: Record<string, any>): Promise<void>;
+    search(embedding: number[], limit?: number): Promise<Array<{
+        id: string;
+        score: number;
+    }>>;
+}
+export interface KnowledgeBaseAdapter {
+    add(content: string, metadata?: Record<string, any>): Promise<string>;
+    search(query: string, limit?: number): Promise<Array<{
+        content: string;
+        score: number;
+    }>>;
+}
+/**
+ * Default policies for automatic memory management
+ */
+export declare const DEFAULT_POLICIES: AutoMemoryPolicy[];
+/**
+ * AutoMemory - Automatic memory management with policies
+ */
+export declare class AutoMemory {
+    private memory;
+    private policies;
+    private summaryThreshold;
+    private vectorizeThreshold;
+    private summarizer?;
+    private vectorStore?;
+    private knowledgeBase?;
+    private embeddingProvider?;
+    private context;
+    private pendingVectorization;
+    constructor(config?: AutoMemoryConfig);
+    /**
+     * Process and add content with automatic policy application
+     */
+    add(content: string, role: 'user' | 'assistant' | 'system', metadata?: Record<string, any>): Promise<MemoryEntry | null>;
+    /**
+     * 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
+     */
+    search(query: string, limit?: number): Promise<Array<{
+        entry: MemoryEntry;
+        score: number;
+    }>>;
+    /**
+     * Build context with automatic retrieval
+     */
+    buildContext(query?: string, maxTokens?: number): Promise<string>;
+    /**
+     * Add a custom policy
+     */
+    addPolicy(policy: AutoMemoryPolicy): void;
+    /**
+     * Remove a policy by name
+     */
+    removePolicy(name: string): boolean;
+    /**
+     * Get current context stats
+     */
+    getStats(): AutoMemoryContext;
+    /**
+     * Clear all memory
+     */
+    clear(): void;
+    /**
+     * Export memory
+     */
+    toJSON(): MemoryEntry[];
+    /**
+     * Import memory
+     */
+    fromJSON(entries: MemoryEntry[]): void;
+    /**
+     * Get underlying memory instance
+     */
+    getMemory(): Memory;
+    /**
+     * Flush pending vectorization
+     */
+    private flushVectorization;
+    /**
+     * Summarize old entries to save space
+     */
+    private summarizeOldEntries;
+    /**
+     * Estimate token count (rough approximation)
+     */
+    private estimateTokens;
+}
+/**
+ * Create an auto-memory instance
+ */
+export declare function createAutoMemory(config?: AutoMemoryConfig): AutoMemory;
+/**
+ * Create a simple summarizer using an LLM
+ */
+export declare function createLLMSummarizer(llm: {
+    chat: (prompt: string) => Promise<string>;
+}): (entries: MemoryEntry[]) => Promise<string>;

package/dist/memory/auto-memory.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * AutoMemory - Policy-based automatic memory capture
+ * Integrates with Memory, KnowledgeBase, and Vector stores
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoMemory = exports.DEFAULT_POLICIES = void 0;
+exports.createAutoMemory = createAutoMemory;
+exports.createLLMSummarizer = createLLMSummarizer;
+const memory_1 = require("./memory");
+/**
+ * Default policies for automatic memory management
+ */
+exports.DEFAULT_POLICIES = [
+    {
+        name: 'store-important',
+        condition: (content) => {
+            const importantKeywords = ['remember', 'important', 'note', 'save', 'key point'];
+            return importantKeywords.some(kw => content.toLowerCase().includes(kw));
+        },
+        action: 'store',
+        priority: 100
+    },
+    {
+        name: 'summarize-long',
+        condition: (content) => content.length > 2000,
+        action: 'summarize',
+        priority: 50
+    },
+    {
+        name: 'vectorize-knowledge',
+        condition: (content, role) => {
+            return role === 'assistant' && content.length > 500;
+        },
+        action: 'vectorize',
+        priority: 30
+    },
+    {
+        name: 'skip-short',
+        condition: (content) => content.length < 10,
+        action: 'skip',
+        priority: 10
+    }
+];
+/**
+ * AutoMemory - Automatic memory management with policies
+ */
+class AutoMemory {
+    constructor(config = {}) {
+        this.pendingVectorization = [];
+        this.memory = new memory_1.Memory(config);
+        this.policies = (config.policies || exports.DEFAULT_POLICIES).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        this.summaryThreshold = config.summaryThreshold ?? 50;
+        this.vectorizeThreshold = config.vectorizeThreshold ?? 10;
+        this.summarizer = config.summarizer;
+        this.vectorStore = config.vectorStore;
+        this.knowledgeBase = config.knowledgeBase;
+        this.embeddingProvider = config.embeddingProvider;
+        this.context = {
+            messageCount: 0,
+            tokenCount: 0,
+            metadata: {}
+        };
+    }
+    /**
+     * Process and add content with automatic policy application
+     */
+    async add(content, role, metadata) {
+        this.context.messageCount++;
+        this.context.tokenCount += this.estimateTokens(content);
+        // Find matching policy
+        const policy = this.policies.find(p => p.condition(content, role, this.context));
+        if (!policy || policy.action === 'skip') {
+            return null;
+        }
+        let entry;
+        switch (policy.action) {
+            case 'summarize':
+                if (this.summarizer) {
+                    const summary = await this.summarizer([{
+                            id: '', content, role, timestamp: Date.now(), metadata
+                        }]);
+                    entry = await this.memory.add(summary, role, {
+                        ...metadata,
+                        original: content,
+                        summarized: true
+                    });
+                }
+                else {
+                    entry = await this.memory.add(content, role, metadata);
+                }
+                break;
+            case 'vectorize':
+                entry = await this.memory.add(content, role, metadata);
+                this.pendingVectorization.push(entry);
+                if (this.pendingVectorization.length >= this.vectorizeThreshold) {
+                    await this.flushVectorization();
+                }
+                break;
+            case 'store':
+            default:
+                entry = await this.memory.add(content, role, metadata);
+                break;
+        }
+        // Check if we need to trigger summarization
+        if (this.memory.size >= this.summaryThreshold && this.summarizer) {
+            await this.summarizeOldEntries();
+        }
+        return entry;
+    }
+    /**
+     * Get a memory entry by ID
+     */
+    get(id) {
+        return this.memory.get(id);
+    }
+    /**
+     * Get all entries
+     */
+    getAll() {
+        return this.memory.getAll();
+    }
+    /**
+     * Get recent entries
+     */
+    getRecent(count) {
+        return this.memory.getRecent(count);
+    }
+    /**
+     * Search memory
+     */
+    async search(query, limit = 5) {
+        const memoryResults = await this.memory.search(query, limit);
+        // Also search vector store if available
+        if (this.vectorStore && this.embeddingProvider) {
+            const queryEmbedding = await this.embeddingProvider.embed(query);
+            const vectorResults = await this.vectorStore.search(queryEmbedding, limit);
+            // Merge results (deduplicate by ID)
+            const seen = new Set(memoryResults.map(r => r.entry.id));
+            for (const vr of vectorResults) {
+                if (!seen.has(vr.id)) {
+                    const entry = this.memory.get(vr.id);
+                    if (entry) {
+                        memoryResults.push({ entry, score: vr.score });
+                    }
+                }
+            }
+        }
+        // Also search knowledge base if available
+        if (this.knowledgeBase) {
+            const kbResults = await this.knowledgeBase.search(query, limit);
+            // Knowledge base results are returned separately as they may not have IDs
+        }
+        return memoryResults
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Build context with automatic retrieval
+     */
+    async buildContext(query, maxTokens = 4000) {
+        let entries;
+        if (query) {
+            const results = await this.search(query, 20);
+            entries = results.map(r => r.entry);
+        }
+        else {
+            entries = this.getRecent(20);
+        }
+        // Build context within token limit
+        const contextParts = [];
+        let tokenCount = 0;
+        for (const entry of entries) {
+            const part = `${entry.role}: ${entry.content}`;
+            const partTokens = this.estimateTokens(part);
+            if (tokenCount + partTokens > maxTokens)
+                break;
+            contextParts.push(part);
+            tokenCount += partTokens;
+        }
+        return contextParts.join('\n');
+    }
+    /**
+     * Add a custom policy
+     */
+    addPolicy(policy) {
+        this.policies.push(policy);
+        this.policies.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+    /**
+     * Remove a policy by name
+     */
+    removePolicy(name) {
+        const index = this.policies.findIndex(p => p.name === name);
+        if (index >= 0) {
+            this.policies.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get current context stats
+     */
+    getStats() {
+        return { ...this.context };
+    }
+    /**
+     * Clear all memory
+     */
+    clear() {
+        this.memory.clear();
+        this.pendingVectorization = [];
+        this.context = {
+            messageCount: 0,
+            tokenCount: 0,
+            metadata: {}
+        };
+    }
+    /**
+     * Export memory
+     */
+    toJSON() {
+        return this.memory.toJSON();
+    }
+    /**
+     * Import memory
+     */
+    fromJSON(entries) {
+        this.memory.fromJSON(entries);
+        this.context.messageCount = entries.length;
+    }
+    /**
+     * Get underlying memory instance
+     */
+    getMemory() {
+        return this.memory;
+    }
+    /**
+     * Flush pending vectorization
+     */
+    async flushVectorization() {
+        if (!this.vectorStore || !this.embeddingProvider || this.pendingVectorization.length === 0) {
+            return;
+        }
+        for (const entry of this.pendingVectorization) {
+            if (entry.embedding) {
+                await this.vectorStore.add(entry.id, entry.embedding, entry.metadata);
+            }
+            else {
+                const embedding = await this.embeddingProvider.embed(entry.content);
+                await this.vectorStore.add(entry.id, embedding, entry.metadata);
+            }
+        }
+        this.pendingVectorization = [];
+    }
+    /**
+     * Summarize old entries to save space
+     */
+    async summarizeOldEntries() {
+        if (!this.summarizer)
+            return;
+        const entries = this.memory.getAll();
+        const oldEntries = entries.slice(0, Math.floor(entries.length / 2));
+        if (oldEntries.length < 10)
+            return;
+        const summary = await this.summarizer(oldEntries);
+        // Delete old entries and add summary
+        for (const entry of oldEntries) {
+            this.memory.delete(entry.id);
+        }
+        await this.memory.add(summary, 'system', {
+            type: 'summary',
+            summarizedCount: oldEntries.length,
+            summarizedAt: Date.now()
+        });
+        this.context.lastSummaryAt = Date.now();
+    }
+    /**
+     * Estimate token count (rough approximation)
+     */
+    estimateTokens(text) {
+        return Math.ceil(text.length / 4);
+    }
+}
+exports.AutoMemory = AutoMemory;
+/**
+ * Create an auto-memory instance
+ */
+function createAutoMemory(config) {
+    return new AutoMemory(config);
+}
+/**
+ * Create a simple summarizer using an LLM
+ */
+function createLLMSummarizer(llm) {
+    return async (entries) => {
+        const content = entries.map(e => `${e.role}: ${e.content}`).join('\n');
+        const prompt = `Summarize the following conversation concisely, preserving key information:\n\n${content}`;
+        return llm.chat(prompt);
+    };
+}

package/dist/memory/file-memory.d.ts

@@ -0,0 +1,88 @@
+/**
+ * File-based Memory Storage
+ * Persistent memory using JSONL files with lockfile support for concurrent access
+ */
+import { MemoryEntry, MemoryConfig, SearchResult } from './memory';
+export interface FileMemoryConfig extends MemoryConfig {
+    filePath: string;
+    compactionThreshold?: number;
+    autoCompact?: boolean;
+}
+export interface FileMemoryEntry extends MemoryEntry {
+    deleted?: boolean;
+}
+/**
+ * FileMemory - Append-only JSONL storage with compaction
+ */
+export declare class FileMemory {
+    private filePath;
+    private entries;
+    private maxEntries;
+    private embeddingProvider?;
+    private compactionThreshold;
+    private autoCompact;
+    private initialized;
+    private writeQueue;
+    constructor(config: FileMemoryConfig);
+    /**
+     * Initialize and load existing entries
+     */
+    initialize(): Promise<void>;
+    /**
+     * 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): Promise<MemoryEntry | undefined>;
+    /**
+     * Get all entries
+     */
+    getAll(): Promise<MemoryEntry[]>;
+    /**
+     * Get recent entries
+     */
+    getRecent(count: number): Promise<MemoryEntry[]>;
+    /**
+     * Search memory by text similarity
+     */
+    search(query: string, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Delete a memory entry (soft delete)
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Clear all memory
+     */
+    clear(): Promise<void>;
+    /**
+     * Compact the file by removing deleted entries
+     */
+    compact(): Promise<void>;
+    /**
+     * Get memory size
+     */
+    get size(): number;
+    /**
+     * Export memory to JSON
+     */
+    toJSON(): Promise<MemoryEntry[]>;
+    /**
+     * Import memory from JSON
+     */
+    fromJSON(entries: MemoryEntry[]): Promise<void>;
+    /**
+     * Build context string from recent memory
+     */
+    buildContext(count?: number): Promise<string>;
+    private appendEntry;
+    private textSearch;
+    private cosineSimilarity;
+    private generateId;
+    private enforceLimit;
+}
+/**
+ * Create a file-based memory instance
+ */
+export declare function createFileMemory(config: FileMemoryConfig): FileMemory;