@deepagents/agent 0.1.0

package/dist/lib/memory.d.ts

@@ -0,0 +1,701 @@
+/**
+ * Memory System - Inspired by human memory architecture
+ *
+ * This system implements a multi-layered memory architecture:
+ *
+ * 1. Working Memory: Short-term, context-specific information (current conversation)
+ * 2. Episodic Memory: Event-based memories with temporal context
+ * 3. Semantic Memory: Facts, concepts, and general knowledge
+ * 4. Procedural Memory: Learned patterns and associations
+ */
+export interface MemoryEntry {
+    id: string;
+    content: string;
+    type: 'episodic' | 'semantic' | 'procedural';
+    timestamp: number;
+    tags: string[];
+    importance: number;
+    accessCount: number;
+    lastAccessed: number;
+    context?: Record<string, any>;
+    relationships?: string[];
+    decay?: number;
+}
+export interface MemoryQuery {
+    query: string;
+    type?: 'episodic' | 'semantic' | 'procedural';
+    limit?: number;
+    minImportance?: number;
+    tags?: string[];
+    timeRange?: {
+        start?: number;
+        end?: number;
+    };
+}
+export interface MemoryStats {
+    totalMemories: number;
+    byType: Record<string, number>;
+    mostAccessed: MemoryEntry[];
+    recentMemories: MemoryEntry[];
+    averageImportance: number;
+}
+export declare class MemoryStore {
+    private store;
+    constructor(name?: string);
+    /**
+     * Generate a unique memory ID
+     */
+    private generateId;
+    /**
+     * Calculate memory decay based on time and access patterns
+     */
+    private calculateDecay;
+    /**
+     * Store a new memory
+     */
+    write(entry: Omit<MemoryEntry, 'id' | 'timestamp' | 'accessCount' | 'lastAccessed' | 'decay'>): MemoryEntry;
+    /**
+     * Retrieve a memory by ID
+     */
+    get(id: string): MemoryEntry | null;
+    /**
+     * Search memories based on query
+     */
+    lookup(query: MemoryQuery): MemoryEntry[];
+    /**
+     * Update an existing memory
+     */
+    correct(id: string, updates: Partial<Omit<MemoryEntry, 'id' | 'timestamp'>>): MemoryEntry | null;
+    /**
+     * Delete a memory (forget)
+     */
+    forget(id: string): boolean;
+    /**
+     * Get related memories
+     */
+    getRelated(id: string, limit?: number): MemoryEntry[];
+    /**
+     * Get memory statistics
+     */
+    getStats(): MemoryStats;
+    /**
+     * Consolidate memories (prune low-importance, rarely accessed memories)
+     */
+    consolidate(threshold?: number): number;
+    /**
+     * Clear all memories
+     */
+    clear(): void;
+    /**
+     * Export all memories
+     */
+    export(): Record<string, MemoryEntry>;
+    /**
+     * Import memories
+     */
+    import(memories: Record<string, MemoryEntry>): void;
+    /**
+     * Write a semantic memory (facts, concepts, general knowledge)
+     *
+     * @example
+     * store.writeSemantic("React is a JavaScript library for building UIs", {
+     *   tags: ["react", "javascript"],
+     *   importance: 8
+     * });
+     */
+    writeSemantic(content: string, options?: {
+        importance?: number;
+        tags?: string[];
+        context?: Record<string, any>;
+        relationships?: string[];
+    }): MemoryEntry;
+    /**
+     * Write an episodic memory (events, conversations, experiences)
+     *
+     * @example
+     * store.writeEpisodic("User completed onboarding", {
+     *   tags: ["milestone", "user123"],
+     *   context: { userId: "user123", timestamp: Date.now() }
+     * });
+     */
+    writeEpisodic(content: string, options?: {
+        importance?: number;
+        tags?: string[];
+        context?: Record<string, any>;
+        relationships?: string[];
+    }): MemoryEntry;
+    /**
+     * Write a procedural memory (patterns, behaviors, methods)
+     *
+     * @example
+     * store.writeProcedural("When user asks for help, first check documentation", {
+     *   tags: ["pattern", "help"],
+     *   importance: 7
+     * });
+     */
+    writeProcedural(content: string, options?: {
+        importance?: number;
+        tags?: string[];
+        context?: Record<string, any>;
+        relationships?: string[];
+    }): MemoryEntry;
+    /**
+     * Store a user preference (convenience wrapper for semantic memory)
+     *
+     * @example
+     * store.storePreference("user123", "theme", "dark");
+     */
+    storePreference(userId: string, preference: string, value: any, importance?: number): MemoryEntry;
+    /**
+     * Record a conversation exchange (convenience wrapper for episodic memory)
+     *
+     * @example
+     * store.recordConversation("user123", "session456", "user", "How do I use React hooks?");
+     */
+    recordConversation(userId: string, sessionId: string, role: 'user' | 'assistant' | 'system', message: string, importance?: number): MemoryEntry;
+    /**
+     * Record a user action/event (convenience wrapper for episodic memory)
+     *
+     * @example
+     * store.recordAction("user123", "completed_tutorial", { tutorialId: "intro" });
+     */
+    recordAction(userId: string, action: string, details?: Record<string, any>, importance?: number): MemoryEntry;
+    /**
+     * Learn a pattern from observations (convenience wrapper for procedural memory)
+     *
+     * @example
+     * store.learnPattern("optimization-workflow", "Profile before optimizing", {
+     *   conditions: "Performance issues reported",
+     *   relatedMemories: ["mem_123"]
+     * });
+     */
+    learnPattern(patternName: string, description: string, options?: {
+        importance?: number;
+        conditions?: string;
+        relatedMemories?: string[];
+        context?: Record<string, any>;
+    }): MemoryEntry;
+    /**
+     * Store a fact or knowledge (convenience wrapper for semantic memory)
+     *
+     * @example
+     * store.storeFact("JavaScript", "JavaScript is a programming language", {
+     *   source: "documentation",
+     *   relatedTo: ["mem_456"]
+     * });
+     */
+    storeFact(topic: string, fact: string, options?: {
+        importance?: number;
+        source?: string;
+        relatedTo?: string[];
+        tags?: string[];
+    }): MemoryEntry;
+    /**
+     * Record a milestone or achievement (convenience wrapper for episodic memory)
+     *
+     * @example
+     * store.recordMilestone("user123", "first-project-completed", "User completed their first project");
+     */
+    recordMilestone(userId: string, milestoneType: string, description: string, importance?: number): MemoryEntry;
+    /**
+     * Store contextual information about current session (working memory)
+     * Note: These should have lower importance as they're temporary
+     *
+     * @example
+     * store.storeSessionContext("session456", "user-preferences-loaded", { theme: "dark" });
+     */
+    storeSessionContext(sessionId: string, contextKey: string, data: any, importance?: number): MemoryEntry;
+    /**
+     * Get proactive memories that should always be present in system prompt
+     * These are high-importance memories that provide essential context
+     *
+     * @param options Configuration for proactive memory retrieval
+     * @returns Formatted string ready for system prompt injection
+     *
+     * @example
+     * const memoryContext = memoryStore.getProactiveMemories({
+     *   userId: 'user123',
+     *   minImportance: 7,
+     *   categories: ['preference', 'core-knowledge']
+     * });
+     *
+     * // Use in agent:
+     * const systemPrompt = `${basePrompt}\n\n${memoryContext}`;
+     */
+    getProactiveMemories(options: {
+        userId?: string;
+        sessionId?: string;
+        minImportance?: number;
+        categories?: string[];
+        maxMemories?: number;
+        types?: Array<'episodic' | 'semantic' | 'procedural'>;
+        includeRelationships?: boolean;
+    }): string;
+    /**
+     * Format proactive memories into a structured system prompt section
+     */
+    private formatProactiveMemories;
+    /**
+     * Helper to format time ago for human readability
+     */
+    private formatTimeAgo;
+    /**
+     * Get user-specific proactive memories
+     * Convenience method that focuses on user preferences and patterns
+     *
+     * @example
+     * const userContext = memoryStore.getUserProactiveMemories('user123');
+     */
+    getUserProactiveMemories(userId: string, options?: {
+        includePreferences?: boolean;
+        includePatterns?: boolean;
+        includeRecentHistory?: boolean;
+        maxPerCategory?: number;
+    }): string;
+    /**
+     * Get session-specific proactive memories
+     * Focuses on working memory and recent context
+     *
+     * @example
+     * const sessionContext = memoryStore.getSessionProactiveMemories('session456');
+     */
+    getSessionProactiveMemories(sessionId: string, options?: {
+        includeWorkingMemory?: boolean;
+        maxMemories?: number;
+    }): string;
+    /**
+     * Get critical memories that should ALWAYS be present
+     * These are importance level 9-10 memories
+     *
+     * @example
+     * const criticalContext = memoryStore.getCriticalMemories();
+     */
+    getCriticalMemories(options?: {
+        userId?: string;
+        maxMemories?: number;
+    }): string;
+    /**
+     * Build complete proactive context for an agent
+     * Combines critical, user-specific, and session-specific memories
+     *
+     * @example
+     * const fullContext = memoryStore.buildProactiveContext({
+     *   userId: 'user123',
+     *   sessionId: 'session456'
+     * });
+     *
+     * // Use in agent system prompt
+     * const systemPrompt = `${basePrompt}\n\n${fullContext}`;
+     */
+    buildProactiveContext(options: {
+        userId?: string;
+        sessionId?: string;
+        includeCritical?: boolean;
+        includeUser?: boolean;
+        includeSession?: boolean;
+    }): string;
+}
+export declare const memoryStore: MemoryStore;
+/**
+ * Tool: Lookup memories
+ */
+export declare const memoryLookup: import("ai").Tool<{
+    query: string;
+    limit: number;
+    type?: "episodic" | "semantic" | "procedural" | undefined;
+    minImportance?: number | undefined;
+    tags?: string[] | undefined;
+}, {
+    count: number;
+    memories: {
+        id: string;
+        content: string;
+        type: "episodic" | "semantic" | "procedural";
+        importance: number;
+        tags: string[];
+        timestamp: string;
+        accessCount: number;
+        decay: string | undefined;
+        context: Record<string, any> | undefined;
+    }[];
+}>;
+/**
+ * Tool: Explain a specific memory
+ */
+export declare const memoryExplain: import("ai").Tool<{
+    id: string;
+    includeRelated: boolean;
+}, {
+    found: boolean;
+    message: string;
+    memory?: undefined;
+    related?: undefined;
+} | {
+    found: boolean;
+    memory: {
+        id: string;
+        content: string;
+        type: "episodic" | "semantic" | "procedural";
+        importance: number;
+        tags: string[];
+        timestamp: string;
+        lastAccessed: string;
+        accessCount: number;
+        decay: string | undefined;
+        context: Record<string, any> | undefined;
+        age: {
+            days: number;
+            hours: number;
+        };
+        timeSinceAccess: {
+            days: number;
+            hours: number;
+        };
+    };
+    related: {
+        id: string;
+        content: string;
+        type: "episodic" | "semantic" | "procedural";
+        importance: number;
+    }[];
+    message?: undefined;
+}>;
+/**
+ * Tool: Write a new memory
+ */
+export declare const memoryWrite: import("ai").Tool<{
+    content: string;
+    type: "episodic" | "semantic" | "procedural";
+    importance: number;
+    tags: string[];
+    context?: Record<any, any> | undefined;
+    relationships?: string[] | undefined;
+}, {
+    success: boolean;
+    id: string;
+    message: string;
+    memory: {
+        id: string;
+        type: "episodic" | "semantic" | "procedural";
+        importance: number;
+        timestamp: string;
+    };
+}>;
+/**
+ * Tool: Forget a memory
+ */
+export declare const memoryForget: import("ai").Tool<{
+    id: string;
+    reason?: string | undefined;
+}, {
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Tool: Correct a memory
+ */
+export declare const memoryCorrect: import("ai").Tool<{
+    id: string;
+    updates: {
+        content?: string | undefined;
+        importance?: number | undefined;
+        tags?: string[] | undefined;
+        context?: Record<any, any> | undefined;
+        relationships?: string[] | undefined;
+    };
+    correctionNote?: string | undefined;
+}, {
+    success: boolean;
+    message: string;
+    memory?: undefined;
+} | {
+    success: boolean;
+    message: string;
+    memory: {
+        id: string;
+        content: string;
+        type: "episodic" | "semantic" | "procedural";
+        importance: number;
+        lastAccessed: string;
+    };
+}>;
+/**
+ * Tool: Get memory statistics
+ */
+export declare const memoryStats: import("ai").Tool<Record<string, never>, {
+    total: number;
+    byType: Record<string, number>;
+    averageImportance: string;
+    mostAccessed: {
+        id: string;
+        content: string;
+        accessCount: number;
+        type: "episodic" | "semantic" | "procedural";
+    }[];
+    recent: {
+        id: string;
+        content: string;
+        timestamp: string;
+        type: "episodic" | "semantic" | "procedural";
+    }[];
+}>;
+export declare const memoryTools: {
+    memoryLookup: import("ai").Tool<{
+        query: string;
+        limit: number;
+        type?: "episodic" | "semantic" | "procedural" | undefined;
+        minImportance?: number | undefined;
+        tags?: string[] | undefined;
+    }, {
+        count: number;
+        memories: {
+            id: string;
+            content: string;
+            type: "episodic" | "semantic" | "procedural";
+            importance: number;
+            tags: string[];
+            timestamp: string;
+            accessCount: number;
+            decay: string | undefined;
+            context: Record<string, any> | undefined;
+        }[];
+    }>;
+    memoryExplain: import("ai").Tool<{
+        id: string;
+        includeRelated: boolean;
+    }, {
+        found: boolean;
+        message: string;
+        memory?: undefined;
+        related?: undefined;
+    } | {
+        found: boolean;
+        memory: {
+            id: string;
+            content: string;
+            type: "episodic" | "semantic" | "procedural";
+            importance: number;
+            tags: string[];
+            timestamp: string;
+            lastAccessed: string;
+            accessCount: number;
+            decay: string | undefined;
+            context: Record<string, any> | undefined;
+            age: {
+                days: number;
+                hours: number;
+            };
+            timeSinceAccess: {
+                days: number;
+                hours: number;
+            };
+        };
+        related: {
+            id: string;
+            content: string;
+            type: "episodic" | "semantic" | "procedural";
+            importance: number;
+        }[];
+        message?: undefined;
+    }>;
+    memoryWrite: import("ai").Tool<{
+        content: string;
+        type: "episodic" | "semantic" | "procedural";
+        importance: number;
+        tags: string[];
+        context?: Record<any, any> | undefined;
+        relationships?: string[] | undefined;
+    }, {
+        success: boolean;
+        id: string;
+        message: string;
+        memory: {
+            id: string;
+            type: "episodic" | "semantic" | "procedural";
+            importance: number;
+            timestamp: string;
+        };
+    }>;
+    memoryForget: import("ai").Tool<{
+        id: string;
+        reason?: string | undefined;
+    }, {
+        success: boolean;
+        message: string;
+    }>;
+    memoryCorrect: import("ai").Tool<{
+        id: string;
+        updates: {
+            content?: string | undefined;
+            importance?: number | undefined;
+            tags?: string[] | undefined;
+            context?: Record<any, any> | undefined;
+            relationships?: string[] | undefined;
+        };
+        correctionNote?: string | undefined;
+    }, {
+        success: boolean;
+        message: string;
+        memory?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        memory: {
+            id: string;
+            content: string;
+            type: "episodic" | "semantic" | "procedural";
+            importance: number;
+            lastAccessed: string;
+        };
+    }>;
+    memoryStats: import("ai").Tool<Record<string, never>, {
+        total: number;
+        byType: Record<string, number>;
+        averageImportance: string;
+        mostAccessed: {
+            id: string;
+            content: string;
+            accessCount: number;
+            type: "episodic" | "semantic" | "procedural";
+        }[];
+        recent: {
+            id: string;
+            content: string;
+            timestamp: string;
+            type: "episodic" | "semantic" | "procedural";
+        }[];
+    }>;
+};
+declare const _default: {
+    memoryStore: MemoryStore;
+    memoryTools: {
+        memoryLookup: import("ai").Tool<{
+            query: string;
+            limit: number;
+            type?: "episodic" | "semantic" | "procedural" | undefined;
+            minImportance?: number | undefined;
+            tags?: string[] | undefined;
+        }, {
+            count: number;
+            memories: {
+                id: string;
+                content: string;
+                type: "episodic" | "semantic" | "procedural";
+                importance: number;
+                tags: string[];
+                timestamp: string;
+                accessCount: number;
+                decay: string | undefined;
+                context: Record<string, any> | undefined;
+            }[];
+        }>;
+        memoryExplain: import("ai").Tool<{
+            id: string;
+            includeRelated: boolean;
+        }, {
+            found: boolean;
+            message: string;
+            memory?: undefined;
+            related?: undefined;
+        } | {
+            found: boolean;
+            memory: {
+                id: string;
+                content: string;
+                type: "episodic" | "semantic" | "procedural";
+                importance: number;
+                tags: string[];
+                timestamp: string;
+                lastAccessed: string;
+                accessCount: number;
+                decay: string | undefined;
+                context: Record<string, any> | undefined;
+                age: {
+                    days: number;
+                    hours: number;
+                };
+                timeSinceAccess: {
+                    days: number;
+                    hours: number;
+                };
+            };
+            related: {
+                id: string;
+                content: string;
+                type: "episodic" | "semantic" | "procedural";
+                importance: number;
+            }[];
+            message?: undefined;
+        }>;
+        memoryWrite: import("ai").Tool<{
+            content: string;
+            type: "episodic" | "semantic" | "procedural";
+            importance: number;
+            tags: string[];
+            context?: Record<any, any> | undefined;
+            relationships?: string[] | undefined;
+        }, {
+            success: boolean;
+            id: string;
+            message: string;
+            memory: {
+                id: string;
+                type: "episodic" | "semantic" | "procedural";
+                importance: number;
+                timestamp: string;
+            };
+        }>;
+        memoryForget: import("ai").Tool<{
+            id: string;
+            reason?: string | undefined;
+        }, {
+            success: boolean;
+            message: string;
+        }>;
+        memoryCorrect: import("ai").Tool<{
+            id: string;
+            updates: {
+                content?: string | undefined;
+                importance?: number | undefined;
+                tags?: string[] | undefined;
+                context?: Record<any, any> | undefined;
+                relationships?: string[] | undefined;
+            };
+            correctionNote?: string | undefined;
+        }, {
+            success: boolean;
+            message: string;
+            memory?: undefined;
+        } | {
+            success: boolean;
+            message: string;
+            memory: {
+                id: string;
+                content: string;
+                type: "episodic" | "semantic" | "procedural";
+                importance: number;
+                lastAccessed: string;
+            };
+        }>;
+        memoryStats: import("ai").Tool<Record<string, never>, {
+            total: number;
+            byType: Record<string, number>;
+            averageImportance: string;
+            mostAccessed: {
+                id: string;
+                content: string;
+                accessCount: number;
+                type: "episodic" | "semantic" | "procedural";
+            }[];
+            recent: {
+                id: string;
+                content: string;
+                timestamp: string;
+                type: "episodic" | "semantic" | "procedural";
+            }[];
+        }>;
+    };
+    MemoryStore: typeof MemoryStore;
+};
+export default _default;
+//# sourceMappingURL=memory.d.ts.map

package/dist/lib/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/lib/memory.ts"],"names":[],"mappings":"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"}