@elizaos/plugin-memory 1.0.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

@@ -0,0 +1,99 @@
+import { type IAgentRuntime, Service, type UUID, type ServiceTypeName } from '@elizaos/core';
+import { type LongTermMemory, type SessionSummary, type MemoryConfig, LongTermMemoryCategory } from '../types/index';
+/**
+ * Memory Service
+ * Manages both short-term (session summaries) and long-term (persistent facts) memory
+ */
+export declare class MemoryService extends Service {
+    static serviceType: ServiceTypeName;
+    private sessionMessageCounts;
+    private memoryConfig;
+    private lastExtractionCheckpoints;
+    capabilityDescription: string;
+    constructor(runtime?: IAgentRuntime);
+    static start(runtime: IAgentRuntime): Promise<Service>;
+    stop(): Promise<void>;
+    initialize(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Get the Drizzle database instance
+     */
+    private getDb;
+    /**
+     * Get configuration
+     */
+    getConfig(): MemoryConfig;
+    /**
+     * Update configuration
+     */
+    updateConfig(updates: Partial<MemoryConfig>): void;
+    /**
+     * Track message count for a room
+     */
+    incrementMessageCount(roomId: UUID): number;
+    /**
+     * Reset message count for a room
+     */
+    resetMessageCount(roomId: UUID): void;
+    /**
+     * Check if summarization is needed for a room
+     */
+    shouldSummarize(roomId: UUID): Promise<boolean>;
+    /**
+     * Generate cache key for tracking extraction checkpoints per entity-room pair
+     */
+    private getExtractionKey;
+    /**
+     * Get the last extraction checkpoint for an entity in a room
+     * Uses the cache table via adapter
+     */
+    getLastExtractionCheckpoint(entityId: UUID, roomId: UUID): Promise<number>;
+    /**
+     * Set the last extraction checkpoint for an entity in a room
+     * Uses the cache table via adapter
+     */
+    setLastExtractionCheckpoint(entityId: UUID, roomId: UUID, messageCount: number): Promise<void>;
+    /**
+     * Check if long-term extraction should run based on message count and interval
+     */
+    shouldRunExtraction(entityId: UUID, roomId: UUID, currentMessageCount: number): Promise<boolean>;
+    /**
+     * Store a long-term memory
+     */
+    storeLongTermMemory(memory: Omit<LongTermMemory, 'id' | 'createdAt' | 'updatedAt'>): Promise<LongTermMemory>;
+    /**
+     * Retrieve long-term memories for an entity
+     */
+    getLongTermMemories(entityId: UUID, category?: LongTermMemoryCategory, limit?: number): Promise<LongTermMemory[]>;
+    /**
+     * Update a long-term memory
+     */
+    updateLongTermMemory(id: UUID, updates: Partial<Omit<LongTermMemory, 'id' | 'agentId' | 'createdAt'>>): Promise<void>;
+    /**
+     * Delete a long-term memory
+     */
+    deleteLongTermMemory(id: UUID): Promise<void>;
+    /**
+     * Get the current session summary for a room (latest one)
+     */
+    getCurrentSessionSummary(roomId: UUID): Promise<SessionSummary | null>;
+    /**
+     * Store a session summary (initial creation)
+     */
+    storeSessionSummary(summary: Omit<SessionSummary, 'id' | 'createdAt' | 'updatedAt'>): Promise<SessionSummary>;
+    /**
+     * Update an existing session summary
+     */
+    updateSessionSummary(id: UUID, updates: Partial<Omit<SessionSummary, 'id' | 'agentId' | 'roomId' | 'createdAt' | 'updatedAt'>>): Promise<void>;
+    /**
+     * Get session summaries for a room
+     */
+    getSessionSummaries(roomId: UUID, limit?: number): Promise<SessionSummary[]>;
+    /**
+     * Search long-term memories by semantic similarity (if embeddings are available)
+     */
+    searchLongTermMemories(entityId: UUID, queryEmbedding: number[], limit?: number, matchThreshold?: number): Promise<LongTermMemory[]>;
+    /**
+     * Get all long-term memories formatted for context
+     */
+    getFormattedLongTermMemories(entityId: UUID): Promise<string>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,83 @@
+import type { UUID } from '@elizaos/core';
+/**
+ * Categories of long-term memory
+ */
+export declare enum LongTermMemoryCategory {
+    IDENTITY = "identity",// User identity, name, roles
+    EXPERTISE = "expertise",// Domain knowledge and familiarity
+    PROJECTS = "projects",// Past interactions and recurring topics
+    PREFERENCES = "preferences",// User preferences for interaction style
+    DATA_SOURCES = "data_sources",// Frequently used files, databases, APIs
+    GOALS = "goals",// User's broader intentions and objectives
+    CONSTRAINTS = "constraints",// User-defined rules and limitations
+    DEFINITIONS = "definitions",// Custom terms, acronyms, glossaries
+    BEHAVIORAL_PATTERNS = "behavioral_patterns"
+}
+/**
+ * Long-term memory entry
+ */
+export interface LongTermMemory {
+    id: UUID;
+    agentId: UUID;
+    entityId: UUID;
+    category: LongTermMemoryCategory;
+    content: string;
+    metadata?: Record<string, unknown>;
+    embedding?: number[];
+    confidence?: number;
+    source?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    lastAccessedAt?: Date;
+    accessCount?: number;
+    similarity?: number;
+}
+/**
+ * Short-term memory session summary
+ */
+export interface SessionSummary {
+    id: UUID;
+    agentId: UUID;
+    roomId: UUID;
+    entityId?: UUID;
+    summary: string;
+    messageCount: number;
+    lastMessageOffset: number;
+    startTime: Date;
+    endTime: Date;
+    topics?: string[];
+    metadata?: Record<string, unknown>;
+    embedding?: number[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Configuration for memory plugin
+ */
+export interface MemoryConfig {
+    shortTermSummarizationThreshold: number;
+    shortTermRetainRecent: number;
+    longTermExtractionEnabled: boolean;
+    longTermVectorSearchEnabled: boolean;
+    longTermConfidenceThreshold: number;
+    longTermExtractionInterval: number;
+    summaryModelType?: string;
+    summaryMaxTokens?: number;
+}
+/**
+ * Memory extraction result from evaluator
+ */
+export interface MemoryExtraction {
+    category: LongTermMemoryCategory;
+    content: string;
+    confidence: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Summary generation result
+ */
+export interface SummaryResult {
+    summary: string;
+    topics: string[];
+    keyPoints: string[];
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@elizaos/plugin-memory",
+  "version": "1.0.2",
+  "description": "Advanced memory management plugin with short-term summarization and long-term persistent memory",
+  "type": "module",
+  "main": "dist/cjs/index.node.cjs",
+  "module": "dist/node/index.node.js",
+  "types": "dist/index.d.ts",
+  "browser": "dist/browser/index.browser.js",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "browser": {
+        "types": "./dist/browser/index.d.ts",
+        "import": "./dist/browser/index.browser.js",
+        "default": "./dist/browser/index.browser.js"
+      },
+      "node": {
+        "types": "./dist/node/index.d.ts",
+        "import": "./dist/node/index.node.js",
+        "require": "./dist/cjs/index.node.cjs",
+        "default": "./dist/node/index.node.js"
+      },
+      "default": "./dist/node/index.node.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.node.js",
+      "default": "./dist/node/index.node.js"
+    },
+    "./browser": {
+      "types": "./dist/browser/index.d.ts",
+      "import": "./dist/browser/index.browser.js",
+      "default": "./dist/browser/index.browser.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun run build.ts",
+    "dev": "bun run build --watch",
+    "test": "bun test",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\""
+  },
+  "dependencies": {
+    "@elizaos/core": "latest",
+    "drizzle-orm": "^0.38.3"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "eliza",
+    "plugin",
+    "memory",
+    "long-term-memory",
+    "short-term-memory",
+    "summarization"
+  ],
+  "author": "ElizaOS Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}