@molroo-io/sdk 0.5.2

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

@@ -0,0 +1,86 @@
+export const SCHEMA_VERSION = 2;
+export 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', '${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);
+  `;
+}
+export 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', '${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/esm/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/esm/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/esm/memory/supabase/index.js

@@ -0,0 +1,3 @@
+export { SupabaseSemanticMemory } from './semantic';
+/** @deprecated Use SupabaseSemanticMemory */
+export { SupabaseMemoryAdapter } from './memory-adapter';

package/dist/esm/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/esm/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"}

package/dist/esm/memory/supabase/memory-adapter.js

@@ -0,0 +1,331 @@
+import { createClient } from '@supabase/supabase-js';
+/**
+ * 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 class SupabaseMemoryAdapter {
+    constructor(options) {
+        this.client = createClient(options.supabaseUrl, options.supabaseKey);
+        this.personaId = options.personaId;
+        this.rlsStrategy = options.rlsStrategy ?? 'application';
+        this.vectorEnabled = !!options.vector;
+        this.embedding = options.vector?.embedding;
+        this.matchThreshold = options.vector?.matchThreshold ?? 0.7;
+    }
+    async setPersonaContext() {
+        if (this.rlsStrategy === 'application') {
+            await this.client
+                .rpc('set_config', {
+                setting: 'app.current_persona_id',
+                value: this.personaId,
+            })
+                .throwOnError();
+        }
+    }
+    // ── Required methods ──
+    async saveEpisode(episode) {
+        await this.setPersonaContext();
+        const { error } = await this.client.from('episodes').upsert({
+            id: episode.id,
+            persona_id: this.personaId,
+            source_entity: episode.sourceEntity ?? null,
+            context: episode.context ?? null,
+            timestamp: episode.timestamp,
+            importance: episode.importance,
+            intensity: episode.intensity,
+            vad_v: episode.emotionSnapshot.V,
+            vad_a: episode.emotionSnapshot.A,
+            vad_d: episode.emotionSnapshot.D,
+            appraisal: episode.appraisal,
+        });
+        if (error)
+            throw new Error(`saveEpisode failed: ${error.message}`);
+        // Auto-index embedding when vector is enabled
+        if (this.vectorEnabled && this.embedding) {
+            try {
+                const text = episode.context ?? episode.sourceEntity ?? '';
+                if (text) {
+                    const embedding = await this.embedding.embed(text);
+                    await this.indexEmbedding(episode.id, embedding, {
+                        type: 'episode',
+                        sourceEntity: episode.sourceEntity,
+                        timestamp: episode.timestamp,
+                        importance: episode.importance,
+                    });
+                }
+            }
+            catch {
+                // Best-effort: vector indexing failure doesn't block episode save.
+            }
+        }
+    }
+    async recall(query) {
+        await this.setPersonaContext();
+        const limit = query.limit ?? 10;
+        let q = this.client
+            .from('episodes')
+            .select('*')
+            .eq('persona_id', this.personaId);
+        if (query.sourceEntity)
+            q = q.eq('source_entity', query.sourceEntity);
+        if (query.context)
+            q = q.ilike('context', `%${query.context}%`);
+        if (query.minImportance !== undefined)
+            q = q.gte('importance', query.minImportance);
+        if (query.valenceRange) {
+            q = q
+                .gte('vad_v', query.valenceRange[0])
+                .lte('vad_v', query.valenceRange[1]);
+        }
+        if (query.timeRange) {
+            q = q
+                .gte('timestamp', query.timeRange[0])
+                .lte('timestamp', query.timeRange[1]);
+        }
+        const { data, error } = await q
+            .order('timestamp', { ascending: false })
+            .limit(limit);
+        if (error)
+            throw new Error(`recall failed: ${error.message}`);
+        return (data ?? []).map(rowToEpisode);
+    }
+    async saveReflection(reflection) {
+        await this.setPersonaContext();
+        const { error } = await this.client.from('reflections').upsert({
+            id: reflection.id,
+            persona_id: this.personaId,
+            source_entity: reflection.sourceEntity ?? null,
+            content: reflection.content,
+            trigger: reflection.trigger,
+            timestamp: reflection.timestamp,
+            vad_v: reflection.emotionSnapshot.V,
+            vad_a: reflection.emotionSnapshot.A,
+            vad_d: reflection.emotionSnapshot.D,
+        });
+        if (error)
+            throw new Error(`saveReflection failed: ${error.message}`);
+    }
+    async getReflections(sourceEntity) {
+        await this.setPersonaContext();
+        const maxRows = 100;
+        let q = this.client
+            .from('reflections')
+            .select('*')
+            .eq('persona_id', this.personaId)
+            .order('timestamp', { ascending: false });
+        if (sourceEntity)
+            q = q.eq('source_entity', sourceEntity);
+        const { data, error } = await q.limit(maxRows);
+        if (error)
+            throw new Error(`getReflections failed: ${error.message}`);
+        return (data ?? []).map(rowToReflection);
+    }
+    // ── Optional methods ──
+    async semanticRecall(query, options) {
+        if (!this.vectorEnabled || !this.embedding) {
+            // Fallback to text-based recall
+            return this.recall({ context: query, limit: options?.topK ?? 10 });
+        }
+        await this.setPersonaContext();
+        const embedding = await this.embedding.embed(query);
+        const topK = options?.topK ?? 5;
+        const { data, error } = await this.client.rpc('match_embeddings', {
+            query_embedding: embedding,
+            match_threshold: this.matchThreshold,
+            match_count: topK,
+            filter_persona_id: this.personaId,
+            filter_type: 'episode',
+            filter_source_entity: options?.filter?.sourceEntity ?? null,
+            filter_min_importance: options?.filter?.minImportance ?? null,
+        });
+        if (error)
+            throw new Error(`semanticRecall failed: ${error.message}`);
+        const matchedIds = (data ?? []).map((row) => row.id);
+        if (matchedIds.length === 0)
+            return [];
+        // Fetch full episodes for matched IDs
+        return this.getByIds(matchedIds);
+    }
+    async getByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        await this.setPersonaContext();
+        const { data, error } = await this.client
+            .from('episodes')
+            .select('*')
+            .eq('persona_id', this.personaId)
+            .in('id', ids);
+        if (error)
+            throw new Error(`getByIds failed: ${error.message}`);
+        return (data ?? []).map(rowToEpisode);
+    }
+    async countEpisodes(query) {
+        await this.setPersonaContext();
+        let q = this.client
+            .from('episodes')
+            .select('*', { count: 'exact', head: true })
+            .eq('persona_id', this.personaId);
+        if (query.sourceEntity)
+            q = q.eq('source_entity', query.sourceEntity);
+        if (query.context)
+            q = q.ilike('context', `%${query.context}%`);
+        if (query.timeRange) {
+            q = q
+                .gte('timestamp', query.timeRange[0])
+                .lte('timestamp', query.timeRange[1]);
+        }
+        const { count, error } = await q;
+        if (error)
+            throw new Error(`countEpisodes failed: ${error.message}`);
+        return count ?? 0;
+    }
+    async updateEpisode(id, patch) {
+        await this.setPersonaContext();
+        const updates = {};
+        if (patch.importance !== undefined)
+            updates.importance = patch.importance;
+        if (patch.intensity !== undefined)
+            updates.intensity = patch.intensity;
+        if (patch.emotionSnapshot !== undefined) {
+            updates.vad_v = patch.emotionSnapshot.V;
+            updates.vad_a = patch.emotionSnapshot.A;
+            updates.vad_d = patch.emotionSnapshot.D;
+        }
+        if (Object.keys(updates).length === 0)
+            return;
+        const { error } = await this.client
+            .from('episodes')
+            .update(updates)
+            .eq('id', id)
+            .eq('persona_id', this.personaId);
+        if (error)
+            throw new Error(`updateEpisode failed: ${error.message}`);
+    }
+    async deleteEpisode(id) {
+        await this.setPersonaContext();
+        const { error } = await this.client
+            .from('episodes')
+            .delete()
+            .eq('id', id)
+            .eq('persona_id', this.personaId);
+        if (error)
+            throw new Error(`deleteEpisode failed: ${error.message}`);
+        // Best-effort: clean up embedding
+        if (this.vectorEnabled) {
+            try {
+                await this.client
+                    .from('memory_embeddings')
+                    .delete()
+                    .eq('id', id)
+                    .eq('persona_id', this.personaId);
+            }
+            catch {
+                // Non-fatal: vector cleanup failure is acceptable.
+            }
+        }
+    }
+    async expireEpisodes(before, minImportance) {
+        await this.setPersonaContext();
+        const threshold = minImportance ?? 0;
+        // Count first, then delete (Supabase delete doesn't return count reliably)
+        const { count, error: countErr } = await this.client
+            .from('episodes')
+            .select('*', { count: 'exact', head: true })
+            .eq('persona_id', this.personaId)
+            .lt('timestamp', before)
+            .lt('importance', threshold);
+        if (countErr)
+            throw new Error(`expireEpisodes count failed: ${countErr.message}`);
+        const expired = count ?? 0;
+        if (expired === 0)
+            return 0;
+        const { error } = await this.client
+            .from('episodes')
+            .delete()
+            .eq('persona_id', this.personaId)
+            .lt('timestamp', before)
+            .lt('importance', threshold);
+        if (error)
+            throw new Error(`expireEpisodes failed: ${error.message}`);
+        // Best-effort: clean up orphaned embeddings
+        if (this.vectorEnabled) {
+            try {
+                await this.client.rpc('cleanup_orphaned_embeddings', {
+                    filter_persona_id: this.personaId,
+                });
+            }
+            catch {
+                // Non-fatal: orphan cleanup failure is acceptable.
+            }
+        }
+        return expired;
+    }
+    // ── Utility ──
+    async indexEmbedding(id, embedding, metadata) {
+        const { error } = await this.client.from('memory_embeddings').upsert({
+            id,
+            persona_id: this.personaId,
+            type: metadata.type,
+            source_entity: metadata.sourceEntity ?? null,
+            timestamp: metadata.timestamp,
+            importance: metadata.importance ?? 0,
+            embedding,
+        });
+        if (error)
+            throw new Error(`indexEmbedding failed: ${error.message}`);
+    }
+}
+// ── Row mappers ──
+function rowToEpisode(row) {
+    return {
+        id: row.id,
+        timestamp: row.timestamp,
+        sourceEntity: row.source_entity || undefined,
+        context: row.context || undefined,
+        appraisal: row.appraisal,
+        emotionSnapshot: {
+            V: row.vad_v,
+            A: row.vad_a,
+            D: row.vad_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,
+        emotionSnapshot: {
+            V: row.vad_v,
+            A: row.vad_a,
+            D: row.vad_d,
+        },
+    };
+}

package/dist/esm/memory/supabase/semantic.d.ts

@@ -0,0 +1,44 @@
+import type { EmbeddingAdapter } from '../types';
+import type { SemanticMemory, SearchOptions, SearchResult } from '../semantic';
+export interface SupabaseSemanticMemoryOptions {
+    /** Supabase project URL. */
+    supabaseUrl: string;
+    /** Supabase anon or service-role key. */
+    supabaseKey: string;
+    /** Embedding provider (embed function + dimension). */
+    embedding: EmbeddingAdapter;
+    /** Match threshold for pgvector similarity. Default: 0.7. */
+    matchThreshold?: number;
+    /** Table name for embeddings. Default: 'memory_embeddings'. */
+    tableName?: string;
+    /** RPC function name for similarity search. Default: 'match_semantic_memory'. */
+    matchFunction?: string;
+}
+/**
+ * Supabase pgvector-backed SemanticMemory.
+ *
+ * Requires a table with columns: id (text PK), text (text), embedding (vector),
+ * metadata (jsonb), and an RPC function for similarity search.
+ *
+ * @example
+ * ```typescript
+ * const memory = new SupabaseSemanticMemory({
+ *   supabaseUrl: process.env.SUPABASE_URL!,
+ *   supabaseKey: process.env.SUPABASE_KEY!,
+ *   embedding: openaiEmbedding({ apiKey: '...' }),
+ * });
+ * await memory.store('user likes coffee', { userId: '123' });
+ * ```
+ */
+export declare class SupabaseSemanticMemory implements SemanticMemory {
+    private client;
+    private embedding;
+    private matchThreshold;
+    private tableName;
+    private matchFunction;
+    constructor(options: SupabaseSemanticMemoryOptions);
+    store(text: string, metadata?: Record<string, unknown>): Promise<string>;
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    delete(ids: string[]): Promise<void>;
+}
+//# sourceMappingURL=semantic.d.ts.map

package/dist/esm/memory/supabase/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../src/memory/supabase/semantic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE/E,MAAM,WAAW,6BAA6B;IAC5C,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,SAAS,EAAE,gBAAgB,CAAC;IAC5B,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAAS;gBAElB,OAAO,EAAE,6BAA6B;IAQ5C,KAAK,CACT,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,OAAO,CAAC,MAAM,CAAC;IAcZ,MAAM,CACV,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,EAAE,CAAC;IAwBpB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ3C"}

package/dist/esm/memory/supabase/semantic.js

@@ -0,0 +1,68 @@
+import { createClient } from '@supabase/supabase-js';
+/**
+ * Supabase pgvector-backed SemanticMemory.
+ *
+ * Requires a table with columns: id (text PK), text (text), embedding (vector),
+ * metadata (jsonb), and an RPC function for similarity search.
+ *
+ * @example
+ * ```typescript
+ * const memory = new SupabaseSemanticMemory({
+ *   supabaseUrl: process.env.SUPABASE_URL!,
+ *   supabaseKey: process.env.SUPABASE_KEY!,
+ *   embedding: openaiEmbedding({ apiKey: '...' }),
+ * });
+ * await memory.store('user likes coffee', { userId: '123' });
+ * ```
+ */
+export class SupabaseSemanticMemory {
+    constructor(options) {
+        this.client = createClient(options.supabaseUrl, options.supabaseKey);
+        this.embedding = options.embedding;
+        this.matchThreshold = options.matchThreshold ?? 0.7;
+        this.tableName = options.tableName ?? 'memory_embeddings';
+        this.matchFunction = options.matchFunction ?? 'match_semantic_memory';
+    }
+    async store(text, metadata = {}) {
+        const id = crypto.randomUUID();
+        const vector = await this.embedding.embed(text);
+        const { error } = await this.client.from(this.tableName).upsert({
+            id,
+            text,
+            embedding: vector,
+            metadata,
+        });
+        if (error)
+            throw new Error(`store failed: ${error.message}`);
+        return id;
+    }
+    async search(query, options = {}) {
+        const topK = options.topK ?? 5;
+        const threshold = options.scoreThreshold ?? this.matchThreshold;
+        const vector = await this.embedding.embed(query);
+        const { data, error } = await this.client.rpc(this.matchFunction, {
+            query_embedding: vector,
+            match_threshold: threshold,
+            match_count: topK,
+            filter_metadata: options.filter ?? null,
+        });
+        if (error)
+            throw new Error(`search failed: ${error.message}`);
+        return (data ?? []).map((row) => ({
+            id: row.id,
+            text: row.text,
+            score: row.similarity,
+            metadata: row.metadata ?? {},
+        }));
+    }
+    async delete(ids) {
+        if (ids.length === 0)
+            return;
+        const { error } = await this.client
+            .from(this.tableName)
+            .delete()
+            .in('id', ids);
+        if (error)
+            throw new Error(`delete failed: ${error.message}`);
+    }
+}