@elizaos/plugin-memory 1.1.0 → 1.1.2

package/dist/schemas/session-summaries.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Session summaries table
+ * Stores condensed summaries of conversation sessions
+ */
+export declare const sessionSummaries: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "session_summaries";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 36;
+        }>;
+        agentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "agent_id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 36;
+        }>;
+        roomId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "room_id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 36;
+        }>;
+        entityId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 36;
+        }>;
+        summary: import("drizzle-orm/pg-core").PgColumn<{
+            name: "summary";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        messageCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "message_count";
+            tableName: "session_summaries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastMessageOffset: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_message_offset";
+            tableName: "session_summaries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        startTime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "start_time";
+            tableName: "session_summaries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endTime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "end_time";
+            tableName: "session_summaries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        topics: import("drizzle-orm/pg-core").PgColumn<{
+            name: "topics";
+            tableName: "session_summaries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "session_summaries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        embedding: import("drizzle-orm/pg-core").PgColumn<{
+            name: "embedding";
+            tableName: "session_summaries";
+            dataType: "array";
+            columnType: "PgArray";
+            data: number[];
+            driverParam: string | (string | number)[];
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: import("drizzle-orm").Column<{
+                name: "embedding";
+                tableName: "session_summaries";
+                dataType: "number";
+                columnType: "PgReal";
+                data: number;
+                driverParam: string | number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "embedding";
+                dataType: "number";
+                columnType: "PgReal";
+                data: number;
+                driverParam: string | number;
+                enumValues: undefined;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+            size: undefined;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "session_summaries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "session_summaries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/services/memory-service.d.ts

@@ -1,146 +1,102 @@
 import { type IAgentRuntime, Service, type UUID, type ServiceTypeName } from '@elizaos/core';
-import type { Metadata } from '@elizaos/core';
-import { type LongTermMemory, type LongTermMemoryConfig, type LongTermMemorySearchParams, type LongTermMemoryRetrievalResult, type ConversationSummary, MemoryType } from '../types/index';
+import { type LongTermMemory, type SessionSummary, type MemoryConfig, LongTermMemoryCategory } from '../types/index';
 /**
- * Long-Term Memory Service - State-of-the-Art Cognitive Memory System
- *
- * Research: Based on comprehensive analysis in refactor.md
- *
- * This service implements:
- * 1. Three-tier long-term memory taxonomy (Episodic, Semantic, Procedural)
- * 2. Memory consolidation pipeline (transient filtering)
- * 3. Hybrid retrieval (Vector + BM25 + Graph)
- * 4. Exponential decay for long-term memory forgetting
- * 5. Contextual embeddings for superior retrieval
- * 6. Contradiction detection and resolution
- *
- * Architecture Philosophy:
- * - Async consolidation: Don't block the conversation loop
- * - Decay-weighted scoring: Recent and frequently accessed long-term memories score higher
- * - Graph-guided retrieval: Use relations for context
- * - Confidence-based filtering: Only store high-quality extractions
+ * Memory Service
+ * Manages both short-term (session summaries) and long-term (persistent facts) memory
  */
 export declare class MemoryService extends Service {
     static serviceType: ServiceTypeName;
-    config: LongTermMemoryConfig & Metadata;
-    private bm25Index;
-    private embeddingDimension?;
-    private isInitialized;
-    private longTermMemoryRepo;
-    private conversationSummaryRepo;
+    private sessionMessageCounts;
+    private memoryConfig;
+    private lastExtractionCheckpoints;
     capabilityDescription: string;
-    /**
-     * Default configuration based on research recommendations
-     * Research: Section 6 "Implementation Strategy"
-     */
-    private static defaultConfig;
     constructor(runtime?: IAgentRuntime);
     static start(runtime: IAgentRuntime): Promise<Service>;
     stop(): Promise<void>;
     initialize(runtime: IAgentRuntime): Promise<void>;
     /**
-     * Load configuration from runtime settings
+     * Get the Drizzle database instance
      */
-    private loadConfiguration;
+    private getDb;
     /**
-     * Ensure embedding dimension is set dynamically based on the model
+     * Get configuration
      */
-    private ensureEmbeddingDimension;
+    getConfig(): MemoryConfig;
     /**
-     * Get current configuration
+     * Update configuration
      */
-    getConfig(): LongTermMemoryConfig;
+    updateConfig(updates: Partial<MemoryConfig>): void;
     /**
-     * Update configuration
+     * Track message count for a room
      */
-    updateConfig(updates: Partial<LongTermMemoryConfig>): void;
+    incrementMessageCount(roomId: UUID): number;
     /**
-     * Store a new long-term memory
-     *
-     * Research: Section 3.2.1 "Contextual Embeddings"
+     * Reset message count for a room
      */
-    storeLongTermMemory(memory: Omit<LongTermMemory, 'id' | 'createdAt' | 'lastAccessedAt' | 'accessCount' | 'isActive' | 'embedding'>): Promise<LongTermMemory>;
+    resetMessageCount(roomId: UUID): void;
     /**
-     * Retrieve long-term memory by ID
+     * Check if summarization is needed for a room
      */
-    getLongTermMemory(id: UUID): Promise<LongTermMemory | null>;
+    shouldSummarize(roomId: UUID): Promise<boolean>;
     /**
-     * Update an existing long-term memory
-     *
-     * Research: Section 4.3.2 "Resolution Strategies"
+     * Generate cache key for tracking extraction checkpoints per entity-room pair
      */
-    updateLongTermMemory(id: UUID, updates: Partial<Omit<LongTermMemory, 'id' | 'agentId' | 'createdAt'>>): Promise<void>;
+    private getExtractionKey;
     /**
-     * Delete a long-term memory (hard delete)
+     * Get the last extraction checkpoint for an entity in a room
+     * Uses the cache table via adapter
      */
-    deleteLongTermMemory(id: UUID): Promise<void>;
+    getLastExtractionCheckpoint(entityId: UUID, roomId: UUID): Promise<number>;
     /**
-     * Get all long-term memories for an entity (with basic filtering)
+     * Set the last extraction checkpoint for an entity in a room
+     * Uses the cache table via adapter
      */
-    getLongTermMemories(entityId: UUID, type?: MemoryType, limit?: number, includeInactive?: boolean): Promise<LongTermMemory[]>;
+    setLastExtractionCheckpoint(entityId: UUID, roomId: UUID, messageCount: number): Promise<void>;
     /**
-     * Handle contradictory long-term memory
-     *
-     * Research: Section 4.3 "Handling Contradictions"
+     * Check if long-term extraction should run based on message count and interval
      */
-    handleContradiction(entityId: UUID, newMemory: Omit<LongTermMemory, 'id' | 'createdAt' | 'lastAccessedAt' | 'accessCount' | 'isActive' | 'embedding'>): Promise<void>;
+    shouldRunExtraction(entityId: UUID, roomId: UUID, currentMessageCount: number): Promise<boolean>;
     /**
-     * Detect if new memory contradicts any existing memory
-     *
-     * Research: Section 4.3.1 "Detection Logic"
+     * Store a long-term memory
      */
-    detectContradiction(newMemory: Omit<LongTermMemory, 'id' | 'createdAt' | 'lastAccessedAt' | 'accessCount' | 'isActive' | 'embedding'>, existingMemories: LongTermMemoryRetrievalResult[]): Promise<LongTermMemory | null>;
+    storeLongTermMemory(memory: Omit<LongTermMemory, 'id' | 'createdAt' | 'updatedAt'>): Promise<LongTermMemory>;
     /**
-     * Search long-term memories with hybrid retrieval
-     *
-     * Research: Section 3 "Retrieval Augmented Generation Strategy"
+     * Retrieve long-term memories for an entity
      */
-    searchLongTermMemories(params: LongTermMemorySearchParams): Promise<LongTermMemoryRetrievalResult[]>;
+    getLongTermMemories(entityId: UUID, category?: LongTermMemoryCategory, limit?: number): Promise<LongTermMemory[]>;
     /**
-     * Vector search implementation
+     * Update a long-term memory
+     * Enforces multi-tenancy by verifying agentId and entityId
      */
-    private vectorSearch;
+    updateLongTermMemory(id: UUID, entityId: UUID, updates: Partial<Omit<LongTermMemory, 'id' | 'agentId' | 'entityId' | 'createdAt'>>): Promise<void>;
     /**
-     * BM25 search implementation
+     * Delete a long-term memory
+     * Enforces multi-tenancy by verifying agentId and entityId
      */
-    private bm25Search;
+    deleteLongTermMemory(id: UUID, entityId: UUID): Promise<void>;
     /**
-     * Rebuild BM25 index from database
+     * Get the current session summary for a room (latest one)
      */
-    private rebuildBM25Index;
+    getCurrentSessionSummary(roomId: UUID): Promise<SessionSummary | null>;
     /**
-     * Get formatted memories for context injection
-     *
-     * Research: Section 5.1.3 "Tier 3: Just-In-Time Injection"
+     * Store a session summary (initial creation)
      */
-    getFormattedLongTermMemoriesForContext(entityId: UUID, query: string, roomId?: UUID): Promise<string>;
+    storeSessionSummary(summary: Omit<SessionSummary, 'id' | 'createdAt' | 'updatedAt'>): Promise<SessionSummary>;
     /**
-     * Store a conversation summary
-     *
-     * Research: Section 5.1.2 "Hierarchical Conversation Summarization"
+     * Update an existing session summary
+     * Enforces multi-tenancy by verifying agentId
      */
-    storeSummary(summary: Omit<ConversationSummary, 'id' | 'createdAt' | 'lastAccessedAt' | 'accessCount'>): Promise<ConversationSummary>;
+    updateSessionSummary(id: UUID, roomId: UUID, updates: Partial<Omit<SessionSummary, 'id' | 'agentId' | 'roomId' | 'createdAt' | 'updatedAt'>>): Promise<void>;
     /**
-     * Get summaries at a specific level for a room
+     * Get session summaries for a room
      */
-    getSummariesByLevel(roomId: UUID, level: number): Promise<ConversationSummary[]>;
+    getSessionSummaries(roomId: UUID, limit?: number): Promise<SessionSummary[]>;
     /**
-     * Search summaries by semantic similarity
-     *
-     * Research: Section 5.1.2 "Tier 2: The Conversation Summary"
+     * Search long-term memories by semantic similarity (if embeddings are available)
      */
-    searchSummaries(params: {
-        entityId: UUID;
-        roomId: UUID;
-        query: string;
-        limit?: number;
-        tokenBudget?: number;
-    }): Promise<ConversationSummary[]>;
+    searchLongTermMemories(entityId: UUID, queryEmbedding: number[], limit?: number, matchThreshold?: number): Promise<LongTermMemory[]>;
     /**
-     * Get the most recent Level 1 summary for a room and entity
-     * Used to determine which messages have already been summarized
-     *
-     * @returns The most recent Level 1 summary, or null if none exist
+     * Get all long-term memories formatted for context
      */
-    getMostRecentLevel1Summary(roomId: UUID, entityId: UUID): Promise<ConversationSummary | null>;
+    getFormattedLongTermMemories(entityId: UUID): Promise<string>;
 }