@molroo-io/sdk 0.5.2

package/dist/cjs/memory/sqlite/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteMemoryAdapter = void 0;
+var memory_adapter_1 = require("./memory-adapter");
+Object.defineProperty(exports, "SqliteMemoryAdapter", { enumerable: true, get: function () { return memory_adapter_1.SqliteMemoryAdapter; } });

package/dist/cjs/memory/sqlite/memory-adapter.d.ts

@@ -0,0 +1,58 @@
+import Database from 'better-sqlite3';
+import type { MemoryAdapter, Episode, Reflection, RecallQuery, SemanticRecallOptions, EpisodePatch, CountQuery, EmbeddingAdapter } from '../types';
+export interface SqliteMemoryAdapterOptions {
+    /** Path to SQLite database file, or ':memory:' for in-memory. */
+    dbPath: string;
+    /** Enable WAL mode for better concurrent reads. Default: true. */
+    walMode?: boolean;
+    /** Enable vector search. When absent, semanticRecall is not available. */
+    vector?: {
+        /** Embedding provider (embed function + dimension). */
+        embedding: EmbeddingAdapter;
+        /** sqlite-vec load function. Auto-imports if not provided. */
+        loadVec?: (db: Database.Database) => void;
+    };
+}
+/**
+ * SQLite-backed MemoryAdapter with optional vector search.
+ *
+ * @example
+ * ```typescript
+ * // RDB only (no vector search)
+ * const adapter = new SqliteMemoryAdapter({ dbPath: './memory.db' });
+ * await adapter.init();
+ *
+ * // With vector search
+ * const adapter = new SqliteMemoryAdapter({
+ *   dbPath: './memory.db',
+ *   vector: {
+ *     embedding: openaiEmbedding({ apiKey: '...' }),
+ *   },
+ * });
+ * await adapter.init();
+ * ```
+ */
+export declare class SqliteMemoryAdapter implements MemoryAdapter {
+    private db;
+    private opts;
+    private vectorEnabled;
+    private stmts;
+    constructor(options: SqliteMemoryAdapterOptions);
+    /** Initialize the database and create tables. Must be called before use. */
+    init(): Promise<void>;
+    private prepareStatements;
+    saveEpisode(episode: Episode): Promise<void>;
+    recall(query: RecallQuery): Promise<Episode[]>;
+    saveReflection(reflection: Reflection): Promise<void>;
+    getReflections(sourceEntity?: string): Promise<Reflection[]>;
+    semanticRecall(query: string, options?: SemanticRecallOptions): Promise<Episode[]>;
+    getByIds(ids: string[]): Promise<Episode[]>;
+    countEpisodes(query: CountQuery): Promise<number>;
+    updateEpisode(id: string, patch: EpisodePatch): Promise<void>;
+    deleteEpisode(id: string): Promise<void>;
+    expireEpisodes(before: number, minImportance?: number): Promise<number>;
+    private indexEmbedding;
+    /** Close the database connection. */
+    close(): void;
+}
+//# sourceMappingURL=memory-adapter.d.ts.map

package/dist/cjs/memory/sqlite/memory-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-adapter.d.ts","sourceRoot":"","sources":["../../../../src/memory/sqlite/memory-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,gBAAgB,CAAC;AACtC,OAAO,KAAK,EACV,aAAa,EACb,OAAO,EACP,UAAU,EACV,WAAW,EACX,qBAAqB,EACrB,YAAY,EACZ,UAAU,EACV,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAGlB,MAAM,WAAW,0BAA0B;IACzC,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,MAAM,CAAC,EAAE;QACP,uDAAuD;QACvD,SAAS,EAAE,gBAAgB,CAAC;QAC5B,8DAA8D;QAC9D,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAC;KAC3C,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IACvD,OAAO,CAAC,EAAE,CAAqB;IAC/B,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,aAAa,CAAS;IAE9B,OAAO,CAAC,KAAK,CAQX;gBAEU,OAAO,EAAE,0BAA0B;IAI/C,4EAA4E;IACtE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAuB3B,OAAO,CAAC,iBAAiB;IAkCnB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA2B5C,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAkC9C,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAarD,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAU5D,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,OAAO,EAAE,CAAC;IAuCf,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAM3C,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBjD,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAe7D,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWxC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqB7E,OAAO,CAAC,cAAc;IAYtB,qCAAqC;IACrC,KAAK,IAAI,IAAI;CAGd"}

package/dist/cjs/memory/sqlite/memory-adapter.js

@@ -0,0 +1,336 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteMemoryAdapter = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const schema_1 = require("./schema");
+/**
+ * SQLite-backed MemoryAdapter with optional vector search.
+ *
+ * @example
+ * ```typescript
+ * // RDB only (no vector search)
+ * const adapter = new SqliteMemoryAdapter({ dbPath: './memory.db' });
+ * await adapter.init();
+ *
+ * // With vector search
+ * const adapter = new SqliteMemoryAdapter({
+ *   dbPath: './memory.db',
+ *   vector: {
+ *     embedding: openaiEmbedding({ apiKey: '...' }),
+ *   },
+ * });
+ * await adapter.init();
+ * ```
+ */
+class SqliteMemoryAdapter {
+    constructor(options) {
+        this.vectorEnabled = false;
+        this.opts = options;
+    }
+    /** Initialize the database and create tables. Must be called before use. */
+    async init() {
+        this.db = new better_sqlite3_1.default(this.opts.dbPath);
+        if (this.opts.walMode !== false) {
+            this.db.pragma('journal_mode = WAL');
+        }
+        if (this.opts.vector) {
+            const dim = this.opts.vector.embedding.dimension;
+            if (this.opts.vector.loadVec) {
+                this.opts.vector.loadVec(this.db);
+            }
+            else {
+                const sqliteVec = await Promise.resolve().then(() => __importStar(require('sqlite-vec')));
+                sqliteVec.load(this.db);
+            }
+            this.db.exec((0, schema_1.createSchema)(dim));
+            this.vectorEnabled = true;
+        }
+        else {
+            this.db.exec((0, schema_1.createSchemaWithoutVec)());
+        }
+        this.prepareStatements();
+    }
+    prepareStatements() {
+        this.stmts = {
+            insertEpisode: this.db.prepare(`
+        INSERT OR REPLACE INTO episodes
+          (id, timestamp, source_entity, context, appraisal, emotion_v, emotion_a, emotion_d, intensity, importance)
+        VALUES
+          (@id, @timestamp, @sourceEntity, @context, @appraisal, @emotionV, @emotionA, @emotionD, @intensity, @importance)
+      `),
+            insertReflection: this.db.prepare(`
+        INSERT OR REPLACE INTO reflections
+          (id, timestamp, source_entity, content, trigger_type, emotion_v, emotion_a, emotion_d)
+        VALUES
+          (@id, @timestamp, @sourceEntity, @content, @triggerType, @emotionV, @emotionA, @emotionD)
+      `),
+            getReflections: this.db.prepare(`SELECT * FROM reflections WHERE source_entity = ? ORDER BY timestamp DESC LIMIT ?`),
+            getReflectionsAll: this.db.prepare(`SELECT * FROM reflections ORDER BY timestamp DESC LIMIT ?`),
+            getByIds: this.db.prepare(`SELECT * FROM episodes WHERE id IN (SELECT value FROM json_each(?))`),
+            updateEpisode: this.db.prepare(`
+        UPDATE episodes SET importance = @importance, intensity = @intensity,
+          emotion_v = @emotionV, emotion_a = @emotionA, emotion_d = @emotionD
+        WHERE id = @id
+      `),
+            deleteEpisode: this.db.prepare(`DELETE FROM episodes WHERE id = ?`),
+        };
+    }
+    // ── Required methods ──
+    async saveEpisode(episode) {
+        this.stmts.insertEpisode.run({
+            id: episode.id,
+            timestamp: episode.timestamp,
+            sourceEntity: episode.sourceEntity ?? null,
+            context: episode.context ?? null,
+            appraisal: JSON.stringify(episode.appraisal),
+            emotionV: episode.emotionSnapshot.V,
+            emotionA: episode.emotionSnapshot.A,
+            emotionD: episode.emotionSnapshot.D,
+            intensity: episode.intensity,
+            importance: episode.importance,
+        });
+        if (this.vectorEnabled && this.opts.vector) {
+            try {
+                const text = episode.context ?? episode.sourceEntity ?? '';
+                if (text) {
+                    const embedding = await this.opts.vector.embedding.embed(text);
+                    this.indexEmbedding(episode.id, embedding);
+                }
+            }
+            catch {
+                // Best-effort: vector indexing failure doesn't block episode save.
+            }
+        }
+    }
+    async recall(query) {
+        const conditions = [];
+        const params = [];
+        if (query.sourceEntity) {
+            conditions.push('source_entity = ?');
+            params.push(query.sourceEntity);
+        }
+        if (query.context) {
+            conditions.push('context LIKE ?');
+            params.push(`%${query.context}%`);
+        }
+        if (query.minImportance !== undefined) {
+            conditions.push('importance >= ?');
+            params.push(query.minImportance);
+        }
+        if (query.timeRange) {
+            conditions.push('timestamp >= ? AND timestamp <= ?');
+            params.push(query.timeRange[0], query.timeRange[1]);
+        }
+        if (query.valenceRange) {
+            conditions.push('emotion_v >= ? AND emotion_v <= ?');
+            params.push(query.valenceRange[0], query.valenceRange[1]);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const limit = query.limit ?? 10;
+        params.push(limit);
+        const sql = `SELECT * FROM episodes ${where} ORDER BY timestamp DESC LIMIT ?`;
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(rowToEpisode);
+    }
+    async saveReflection(reflection) {
+        this.stmts.insertReflection.run({
+            id: reflection.id,
+            timestamp: reflection.timestamp,
+            sourceEntity: reflection.sourceEntity ?? null,
+            content: reflection.content,
+            triggerType: reflection.trigger,
+            emotionV: reflection.emotionSnapshot.V,
+            emotionA: reflection.emotionSnapshot.A,
+            emotionD: reflection.emotionSnapshot.D,
+        });
+    }
+    async getReflections(sourceEntity) {
+        const maxRows = 100;
+        const rows = sourceEntity
+            ? this.stmts.getReflections.all(sourceEntity, maxRows)
+            : this.stmts.getReflectionsAll.all(maxRows);
+        return rows.map(rowToReflection);
+    }
+    // ── Optional methods ──
+    async semanticRecall(query, options) {
+        if (!this.vectorEnabled || !this.opts.vector || !this.db.open) {
+            return this.recall({ context: query, limit: options?.topK ?? 10 });
+        }
+        const embedding = await this.opts.vector.embedding.embed(query);
+        const topK = options?.topK ?? 5;
+        const hasFilter = options?.filter?.sourceEntity || options?.filter?.minImportance !== undefined;
+        const fetchK = hasFilter ? topK * 4 : topK;
+        const vec = new Float32Array(embedding);
+        const vecRows = this.db.prepare(`SELECT id, distance FROM embeddings WHERE embedding MATCH ? ORDER BY distance LIMIT ?`).all(vec, fetchK);
+        if (vecRows.length === 0)
+            return [];
+        const ids = vecRows.map(r => r.id);
+        const distMap = new Map(vecRows.map(r => [r.id, r.distance]));
+        let sql = `SELECT * FROM episodes WHERE id IN (${ids.map(() => '?').join(',')})`;
+        const params = [...ids];
+        if (options?.filter?.sourceEntity) {
+            sql += ` AND source_entity = ?`;
+            params.push(options.filter.sourceEntity);
+        }
+        if (options?.filter?.minImportance !== undefined) {
+            sql += ` AND importance >= ?`;
+            params.push(options.filter.minImportance);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows
+            .map(row => rowToEpisode(row))
+            .sort((a, b) => (distMap.get(a.id) ?? 1) - (distMap.get(b.id) ?? 1))
+            .slice(0, topK);
+    }
+    async getByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        const rows = this.stmts.getByIds.all(JSON.stringify(ids));
+        return rows.map(rowToEpisode);
+    }
+    async countEpisodes(query) {
+        const conditions = [];
+        const params = [];
+        if (query.sourceEntity) {
+            conditions.push('source_entity = ?');
+            params.push(query.sourceEntity);
+        }
+        if (query.context) {
+            conditions.push('context LIKE ?');
+            params.push(`%${query.context}%`);
+        }
+        if (query.timeRange) {
+            conditions.push('timestamp >= ? AND timestamp <= ?');
+            params.push(query.timeRange[0], query.timeRange[1]);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const sql = `SELECT COUNT(*) as cnt FROM episodes ${where}`;
+        const row = this.db.prepare(sql).get(...params);
+        return row.cnt;
+    }
+    async updateEpisode(id, patch) {
+        const existing = this.stmts.getByIds.all(JSON.stringify([id]));
+        if (existing.length === 0)
+            return;
+        const row = existing[0];
+        this.stmts.updateEpisode.run({
+            id,
+            importance: patch.importance ?? row.importance,
+            intensity: patch.intensity ?? row.intensity,
+            emotionV: patch.emotionSnapshot?.V ?? row.emotion_v,
+            emotionA: patch.emotionSnapshot?.A ?? row.emotion_a,
+            emotionD: patch.emotionSnapshot?.D ?? row.emotion_d,
+        });
+    }
+    async deleteEpisode(id) {
+        this.stmts.deleteEpisode.run(id);
+        if (this.vectorEnabled) {
+            try {
+                this.db.prepare(`DELETE FROM embeddings WHERE id = ?`).run(id);
+            }
+            catch {
+                // Best-effort: vector cleanup failure is non-fatal.
+            }
+        }
+    }
+    async expireEpisodes(before, minImportance) {
+        const threshold = minImportance ?? 0;
+        const result = this.db.prepare(`DELETE FROM episodes WHERE timestamp < ? AND importance < ?`).run(before, threshold);
+        if (this.vectorEnabled) {
+            try {
+                this.db.prepare(`DELETE FROM embeddings WHERE id NOT IN (SELECT id FROM episodes)`).run();
+            }
+            catch {
+                // Best-effort cleanup.
+            }
+        }
+        return result.changes;
+    }
+    // ── Utility ──
+    indexEmbedding(id, embedding) {
+        if (!this.db.open)
+            return;
+        try {
+            const vec = new Float32Array(embedding);
+            const exists = this.db.prepare(`SELECT 1 FROM embeddings WHERE id = ?`).get(id);
+            if (exists)
+                return;
+            this.db.prepare(`INSERT INTO embeddings (id, embedding) VALUES (?, ?)`).run(id, vec);
+        }
+        catch {
+            // Silently ignore.
+        }
+    }
+    /** Close the database connection. */
+    close() {
+        this.db.close();
+    }
+}
+exports.SqliteMemoryAdapter = SqliteMemoryAdapter;
+// ── Row mappers ──
+function rowToEpisode(row) {
+    return {
+        id: row.id,
+        timestamp: row.timestamp,
+        sourceEntity: row.source_entity ?? undefined,
+        context: row.context ?? undefined,
+        appraisal: JSON.parse(row.appraisal),
+        emotionSnapshot: {
+            V: row.emotion_v,
+            A: row.emotion_a,
+            D: row.emotion_d,
+        },
+        intensity: row.intensity,
+        importance: row.importance,
+    };
+}
+function rowToReflection(row) {
+    return {
+        id: row.id,
+        timestamp: row.timestamp,
+        sourceEntity: row.source_entity ?? undefined,
+        content: row.content,
+        trigger: row.trigger_type,
+        emotionSnapshot: {
+            V: row.emotion_v,
+            A: row.emotion_a,
+            D: row.emotion_d,
+        },
+    };
+}

package/dist/cjs/memory/sqlite/schema.d.ts

@@ -0,0 +1,4 @@
+export declare const SCHEMA_VERSION = 2;
+export declare function createSchema(embeddingDim: number): string;
+export declare function createSchemaWithoutVec(): string;
+//# sourceMappingURL=schema.d.ts.map

package/dist/cjs/memory/sqlite/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/memory/sqlite/schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,wBAAgB,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CA4CzD;AAED,wBAAgB,sBAAsB,IAAI,MAAM,CAuC/C"}

package/dist/cjs/memory/sqlite/schema.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_VERSION = void 0;
+exports.createSchema = createSchema;
+exports.createSchemaWithoutVec = createSchemaWithoutVec;
+exports.SCHEMA_VERSION = 2;
+function createSchema(embeddingDim) {
+    return `
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    INSERT OR IGNORE INTO _meta (key, value) VALUES ('schema_version', '${exports.SCHEMA_VERSION}');
+
+    CREATE TABLE IF NOT EXISTS episodes (
+      id            TEXT PRIMARY KEY,
+      timestamp     INTEGER NOT NULL,
+      source_entity TEXT,
+      context       TEXT,
+      appraisal     TEXT NOT NULL,
+      emotion_v     REAL NOT NULL,
+      emotion_a     REAL NOT NULL,
+      emotion_d     REAL NOT NULL,
+      intensity     REAL NOT NULL,
+      importance    REAL NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_episodes_source ON episodes(source_entity);
+    CREATE INDEX IF NOT EXISTS idx_episodes_timestamp ON episodes(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_episodes_importance ON episodes(importance);
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS embeddings USING vec0(
+      id        TEXT PRIMARY KEY,
+      embedding FLOAT[${embeddingDim}]
+    );
+
+    CREATE TABLE IF NOT EXISTS reflections (
+      id            TEXT PRIMARY KEY,
+      timestamp     INTEGER NOT NULL,
+      source_entity TEXT,
+      content       TEXT NOT NULL,
+      trigger_type  TEXT NOT NULL,
+      emotion_v     REAL NOT NULL,
+      emotion_a     REAL NOT NULL,
+      emotion_d     REAL NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_reflections_source ON reflections(source_entity);
+  `;
+}
+function createSchemaWithoutVec() {
+    return `
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    INSERT OR IGNORE INTO _meta (key, value) VALUES ('schema_version', '${exports.SCHEMA_VERSION}');
+
+    CREATE TABLE IF NOT EXISTS episodes (
+      id            TEXT PRIMARY KEY,
+      timestamp     INTEGER NOT NULL,
+      source_entity TEXT,
+      context       TEXT,
+      appraisal     TEXT NOT NULL,
+      emotion_v     REAL NOT NULL,
+      emotion_a     REAL NOT NULL,
+      emotion_d     REAL NOT NULL,
+      intensity     REAL NOT NULL,
+      importance    REAL NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_episodes_source ON episodes(source_entity);
+    CREATE INDEX IF NOT EXISTS idx_episodes_timestamp ON episodes(timestamp DESC);
+    CREATE INDEX IF NOT EXISTS idx_episodes_importance ON episodes(importance);
+
+    CREATE TABLE IF NOT EXISTS reflections (
+      id            TEXT PRIMARY KEY,
+      timestamp     INTEGER NOT NULL,
+      source_entity TEXT,
+      content       TEXT NOT NULL,
+      trigger_type  TEXT NOT NULL,
+      emotion_v     REAL NOT NULL,
+      emotion_a     REAL NOT NULL,
+      emotion_d     REAL NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_reflections_source ON reflections(source_entity);
+  `;
+}

package/dist/cjs/memory/supabase/index.d.ts

@@ -0,0 +1,7 @@
+export { SupabaseSemanticMemory } from './semantic';
+export type { SupabaseSemanticMemoryOptions } from './semantic';
+/** @deprecated Use SupabaseSemanticMemory */
+export { SupabaseMemoryAdapter } from './memory-adapter';
+/** @deprecated Use SupabaseSemanticMemoryOptions */
+export type { SupabaseMemoryAdapterOptions } from './memory-adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/memory/supabase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/memory/supabase/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,YAAY,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAEhE,6CAA6C;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,oDAAoD;AACpD,YAAY,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/cjs/memory/supabase/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseMemoryAdapter = exports.SupabaseSemanticMemory = void 0;
+var semantic_1 = require("./semantic");
+Object.defineProperty(exports, "SupabaseSemanticMemory", { enumerable: true, get: function () { return semantic_1.SupabaseSemanticMemory; } });
+/** @deprecated Use SupabaseSemanticMemory */
+var memory_adapter_1 = require("./memory-adapter");
+Object.defineProperty(exports, "SupabaseMemoryAdapter", { enumerable: true, get: function () { return memory_adapter_1.SupabaseMemoryAdapter; } });

package/dist/cjs/memory/supabase/memory-adapter.d.ts

@@ -0,0 +1,67 @@
+import type { MemoryAdapter, Episode, Reflection, RecallQuery, SemanticRecallOptions, EpisodePatch, CountQuery, EmbeddingAdapter } from '../types';
+export interface SupabaseMemoryAdapterOptions {
+    /** Supabase project URL. */
+    supabaseUrl: string;
+    /** Supabase anon or service-role key. */
+    supabaseKey: string;
+    /** Persona/world ID for RLS scoping. */
+    personaId: string;
+    /** RLS strategy. Default: 'application'. */
+    rlsStrategy?: 'application' | 'jwt';
+    /** Enable vector search. When absent, semanticRecall falls back to text recall. */
+    vector?: {
+        /** Embedding provider (embed function + dimension). */
+        embedding: EmbeddingAdapter;
+        /** Match threshold for pgvector similarity. Default: 0.7. */
+        matchThreshold?: number;
+    };
+}
+/**
+ * Supabase-backed MemoryAdapter with optional pgvector semantic search.
+ *
+ * Combines episode/reflection RDB storage with optional pgvector embeddings
+ * into a single unified MemoryAdapter interface.
+ *
+ * @example
+ * ```typescript
+ * // RDB only (no vector search)
+ * const adapter = new SupabaseMemoryAdapter({
+ *   supabaseUrl: process.env.SUPABASE_URL!,
+ *   supabaseKey: process.env.SUPABASE_KEY!,
+ *   personaId: 'world-123',
+ * });
+ *
+ * // With vector search
+ * const adapter = new SupabaseMemoryAdapter({
+ *   supabaseUrl: process.env.SUPABASE_URL!,
+ *   supabaseKey: process.env.SUPABASE_KEY!,
+ *   personaId: 'world-123',
+ *   vector: {
+ *     embedding: openaiEmbedding({ apiKey: '...' }),
+ *     matchThreshold: 0.75,
+ *   },
+ * });
+ * ```
+ */
+export declare class SupabaseMemoryAdapter implements MemoryAdapter {
+    private client;
+    private personaId;
+    private rlsStrategy;
+    private vectorEnabled;
+    private embedding?;
+    private matchThreshold;
+    constructor(options: SupabaseMemoryAdapterOptions);
+    private setPersonaContext;
+    saveEpisode(episode: Episode): Promise<void>;
+    recall(query: RecallQuery): Promise<Episode[]>;
+    saveReflection(reflection: Reflection): Promise<void>;
+    getReflections(sourceEntity?: string): Promise<Reflection[]>;
+    semanticRecall(query: string, options?: SemanticRecallOptions): Promise<Episode[]>;
+    getByIds(ids: string[]): Promise<Episode[]>;
+    countEpisodes(query: CountQuery): Promise<number>;
+    updateEpisode(id: string, patch: EpisodePatch): Promise<void>;
+    deleteEpisode(id: string): Promise<void>;
+    expireEpisodes(before: number, minImportance?: number): Promise<number>;
+    private indexEmbedding;
+}
+//# sourceMappingURL=memory-adapter.d.ts.map

package/dist/cjs/memory/supabase/memory-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-adapter.d.ts","sourceRoot":"","sources":["../../../../src/memory/supabase/memory-adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,OAAO,EACP,UAAU,EACV,WAAW,EACX,qBAAqB,EACrB,YAAY,EACZ,UAAU,EACV,gBAAgB,EACjB,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,4BAA4B;IAC3C,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,aAAa,GAAG,KAAK,CAAC;IACpC,mFAAmF;IACnF,MAAM,CAAC,EAAE;QACP,uDAAuD;QACvD,SAAS,EAAE,gBAAgB,CAAC;QAC5B,6DAA6D;QAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,SAAS,CAAC,CAAmB;IACrC,OAAO,CAAC,cAAc,CAAS;gBAEnB,OAAO,EAAE,4BAA4B;YASnC,iBAAiB;IAazB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAoC5C,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAgC9C,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrD,cAAc,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAmB5D,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,OAAO,EAAE,CAAC;IA+Bf,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAY3C,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBjD,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB7D,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBxC,cAAc,CAClB,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;YAwCJ,cAAc;CAqB7B"}