@memstack/core 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-type MemoryType = "interaction" | "summary" | "observation" | "gossip";
+type MemoryType = "interaction" | "summary" | "observation" | "fact" | "reflection";
 interface Memory {
     id: string;
     actorId: string;
@@ -18,6 +18,10 @@ interface CompiledContext {
     recentMemories: Memory[];
     importantMemories: Memory[];
     tokenEstimate: number;
+    messages?: {
+        role: string;
+        content: string;
+    }[];
 }
 interface ProcessResult {
     memory: Memory;
@@ -33,7 +37,22 @@ interface HealthStatus {
     llm: boolean;
     embedding: boolean;
 }
+interface MemoryStats {
+    total: number;
+    expired: number;
+    oldest: Date | null;
+    newest: Date | null;
+    avgImportance: number;
+    byType: Record<MemoryType, number>;
+    byActor: Record<string, {
+        count: number;
+        oldest: Date;
+        newest: Date;
+        avgImportance: number;
+    }>;
+}
 
+type TokenCounter = (text: string) => number;
 interface MemoryStoreInput {
     actorId: string;
     content: string;
@@ -53,6 +72,8 @@ interface MemoryCountFilter {
     actorId?: string;
     memoryType?: MemoryType;
     minImportance?: number;
+    createdAfter?: Date;
+    createdBefore?: Date;
 }
 interface MemoryRetrieveQuery {
     actorId?: string;
@@ -61,11 +82,15 @@ interface MemoryRetrieveQuery {
     tags?: string[];
     limit?: number;
     strategy?: "semantic" | "hybrid" | "recent" | "important";
+    createdAfter?: Date;
+    createdBefore?: Date;
 }
 interface ContextOptions {
     actorId: string;
     maxTokens?: number;
     memoryTypes?: MemoryType[];
+    retrieveStrategy?: "recent" | "important" | "hybrid";
+    format?: "markdown" | "messages";
 }
 interface SummarizeOptions {
     actorId?: string;
@@ -74,15 +99,21 @@ interface SummarizeOptions {
     targetCount?: number;
     memoryTypes?: MemoryType[];
     keepOriginals?: boolean;
+    /** Maximum memories per LLM call. When exceeded, memories are split into chunks, summarized independently, then recursively merged. Default 50. */
+    chunkSize?: number;
+    /** Per-call override for the summarization system prompt. Falls back to constructor prompt. */
+    prompt?: string;
 }
 interface PruneStrategy {
-    type: "byAge" | "byImportance" | "byCount" | "byType" | "custom";
+    type: "byAge" | "byImportance" | "byCount" | "byType" | "custom" | "compose";
     maxAge?: number;
     minImportance?: number;
     maxPerActor?: number;
     memoryTypes?: MemoryType[];
     /** Custom predicate: return true for memories that should be REMOVED. */
     shouldRemove?: (memory: Memory) => boolean;
+    /** For "compose" type: sub-strategies applied cumulatively (kept memories must pass ALL). */
+    strategies?: PruneStrategy[];
 }
 interface LLMProvider {
     complete(request: {
@@ -170,6 +201,16 @@ interface MemoryStoreConfig {
     llm?: LLMProvider;
     embedOnStore?: boolean;
     summarizationPrompt?: string;
+    tokenCounter?: TokenCounter;
+    contextImportantRatio?: number;
+    limits?: {
+        dedupScan?: number;
+        contextScan?: number;
+        summarizeScan?: number;
+        pruneScan?: number;
+        exportScan?: number;
+        purgeScan?: number;
+    };
 }
 declare class MemoryStore {
     private storage;
@@ -178,6 +219,10 @@ declare class MemoryStore {
     private pruner;
     private compiler;
     private embedOnStore;
+    private limits;
+    private contentHashIndex;
+    private initialized;
+    private _ensureInit;
     constructor(config: MemoryStoreConfig);
     store(input: MemoryStoreInput): Promise<Memory>;
     storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
@@ -192,6 +237,10 @@ declare class MemoryStore {
         summary: Memory;
         deletedCount: number;
     }>;
+    summarizeStream(options: SummarizeOptions): AsyncIterable<{
+        chunk: string;
+        text: string;
+    }>;
     prune(strategy: PruneStrategy): Promise<{
         pruned: string[];
         count: number;
@@ -200,7 +249,11 @@ declare class MemoryStore {
         wouldPrune: string[];
         count: number;
     }>;
-    export(): Promise<Memory[]>;
+    export(actorId?: string): Promise<Memory[]>;
+    stats(actorId?: string): Promise<MemoryStats>;
+    purgeActor(actorId: string): Promise<number>;
+    merge(ids: string[]): Promise<Memory>;
+    private _ensureHashIndex;
     private _hashContent;
 }
 
@@ -208,10 +261,11 @@ declare class MemStack {
     readonly memory: MemoryStore;
     private config;
     private storage;
-    private processCount;
+    private processCounts;
+    private pruneCheckCount;
     constructor(config: MemStackConfig);
     process(input: ProcessInput): Promise<ProcessResult>;
-    export(): Promise<MemStackSnapshot>;
+    export(actorId?: string): Promise<MemStackSnapshot>;
     import(snapshot: MemStackSnapshot): Promise<void>;
     health(): Promise<HealthStatus>;
     close(): Promise<void>;
@@ -236,7 +290,7 @@ declare function validationError(message: string, details?: Record<string, unkno
 declare function storageError(message: string, cause?: unknown): MemStackError;
 declare function configError(message: string): MemStackError;
 
-declare class InMemoryStorage implements StorageProvider {
+declare class InMemoryStorageAdapter implements StorageProvider {
     private memories;
     initialize(): Promise<void>;
     generateId(): string;
@@ -256,9 +310,10 @@ interface DiskStorageConfig {
     /** Directory to store memory files. Default: "./memstack-data" */
     storageDir?: string;
 }
-declare class DiskStorage implements StorageProvider {
+declare class DiskStorageAdapter implements StorageProvider {
     private dir;
     private _writeLocks;
+    private _idIndex;
     constructor(config?: DiskStorageConfig);
     initialize(): Promise<void>;
     generateId(): string;
@@ -276,25 +331,126 @@ declare class DiskStorage implements StorageProvider {
     private _writeFile;
     private _withWriteLock;
     private _listActors;
+    private _buildIndex;
     private _toExternal;
 }
 
+interface MarkdownStorageConfig {
+    dir: string;
+    oneFilePerActor?: boolean;
+}
+declare class MarkdownStorageAdapter implements StorageProvider {
+    private dir;
+    private oneFilePerActor;
+    private _cache;
+    private _deletedIds;
+    private _cacheDirty;
+    constructor(config: MarkdownStorageConfig);
+    initialize(): Promise<void>;
+    generateId(): string;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    retrieve(query: MemoryRetrieveQuery, _embedding?: number[]): Promise<Memory[]>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    close(): Promise<void>;
+    vacuum(): Promise<void>;
+    private _filePath;
+    private _formatBlock;
+    private _formatTombstone;
+    private _ensureCache;
+    private _parseFile;
+    private _vacuumFile;
+    private _listActors;
+}
+
+interface HybridStorageConfig {
+    cache: StorageProvider;
+    durable: StorageProvider;
+    writeBoth?: boolean;
+    readFromCache?: boolean;
+    syncOnInit?: boolean;
+}
+declare class HybridStorageAdapter implements StorageProvider {
+    private cache;
+    private durable;
+    private writeBoth;
+    private readFromCache;
+    private syncOnInit;
+    constructor(config: HybridStorageConfig);
+    initialize(): Promise<void>;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    touch(id: string): Promise<void>;
+    close(): Promise<void>;
+}
+
+type PgPool = {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: unknown[];
+    }>;
+    end?: () => Promise<void>;
+};
+interface PostgresStorageConfig {
+    pool?: PgPool;
+    connectionString?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    tableName?: string;
+    vectorDimensions?: number;
+    ssl?: boolean | object;
+}
+declare class PostgresStorageAdapter implements StorageProvider {
+    private pool;
+    private table;
+    private vectorDimensions;
+    private _ownsPool;
+    constructor(config: PostgresStorageConfig);
+    private _connectionString?;
+    private _connParts?;
+    private _ssl?;
+    initialize(): Promise<void>;
+    private _createPool;
+    private _buildConnString;
+    private _runMigration;
+    generateId(): string;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    touch(id: string): Promise<void>;
+    retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    close(): Promise<void>;
+    private _semanticRetrieve;
+    private _rowToMemory;
+}
+
 type RedisClient = {
     set(key: string, value: string): Promise<unknown>;
     get(key: string): Promise<string | null>;
-    mget(...keys: string[]): Promise<(string | null)[]>;
     del(key: string | string[]): Promise<number>;
     sadd(key: string, ...members: string[]): Promise<number>;
     srem(key: string, ...members: string[]): Promise<number>;
     smembers(key: string): Promise<string[]>;
+    mget(...keys: string[]): Promise<(string | null)[]>;
 };
 interface RedisStorageConfig {
-    /** An active ioredis client instance (or compatible) */
     redis: RedisClient;
-    /** Key prefix. Default: "memstack" */
     keyPrefix?: string;
 }
-declare class RedisStorage implements StorageProvider {
+declare class RedisStorageAdapter implements StorageProvider {
     private redis;
     private prefix;
     constructor(config: RedisStorageConfig);
@@ -305,6 +461,7 @@ declare class RedisStorage implements StorageProvider {
     get(id: string): Promise<Memory | null>;
     delete(id: string): Promise<void>;
     deleteMany(ids: string[]): Promise<number>;
+    touch(id: string): Promise<void>;
     retrieve(query: MemoryRetrieveQuery, _embedding?: number[]): Promise<Memory[]>;
     count(filter?: MemoryCountFilter): Promise<number>;
     close(): Promise<void>;
@@ -316,24 +473,285 @@ declare class RedisStorage implements StorageProvider {
     private _toExternal;
 }
 
-type PgPool = {
-    query(text: string, params?: unknown[]): Promise<{
-        rows: unknown[];
+type QdrantClient = {
+    createCollection(name: string, config: {
+        vectors: {
+            size: number;
+            distance: string;
+        };
+    }): Promise<unknown>;
+    getCollection(name: string): Promise<unknown>;
+    upsert(name: string, opts: {
+        points: {
+            id: string;
+            vector: number[];
+            payload: Record<string, unknown>;
+        }[];
+    }): Promise<unknown>;
+    retrieve(name: string, opts: {
+        ids: string[];
+    }): Promise<unknown[]>;
+    search(name: string, opts: {
+        vector: number[];
+        limit: number;
+        filter?: {
+            must: unknown[];
+        };
+    }): Promise<unknown[]>;
+    delete(name: string, opts: {
+        points: string[];
+    }): Promise<unknown>;
+    count(name: string, opts?: {
+        filter?: {
+            must: unknown[];
+        };
+    }): Promise<{
+        count: number;
+    }>;
+    scroll(name: string, opts?: {
+        filter?: {
+            must: unknown[];
+        };
+        limit?: number;
+    }): Promise<{
+        points: unknown[];
     }>;
 };
-interface PostgresStorageConfig {
-    /** An active pg Pool instance */
-    pool: PgPool;
-    /** Table name. Default: "memstack_memories" */
+interface QdrantStorageConfig {
+    client: QdrantClient;
+    collectionName?: string;
+    vectorSize?: number;
+}
+declare class QdrantStorageAdapter implements StorageProvider {
+    private client;
+    private collectionName;
+    private vectorSize;
+    private _idToQdrant;
+    constructor(config: QdrantStorageConfig);
+    initialize(): Promise<void>;
+    generateId(): string;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    close(): Promise<void>;
+    private _toPayload;
+    private _fromPoint;
+}
+
+type Neo4jDriver = {
+    session(opts?: {
+        database?: string;
+    }): Neo4jSession;
+    close(): Promise<void>;
+};
+type Neo4jSession = {
+    run(query: string, params?: Record<string, unknown>): Promise<{
+        records: {
+            get(key: string): unknown;
+            toObject(): Record<string, unknown>;
+        }[];
+    }>;
+    close(): Promise<void>;
+};
+interface Neo4jStorageConfig {
+    driver: Neo4jDriver;
+    database?: string;
+}
+declare class Neo4jStorageAdapter implements StorageProvider {
+    private driver;
+    private database;
+    constructor(config: Neo4jStorageConfig);
+    initialize(): Promise<void>;
+    generateId(): string;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    graphQuery(cypher: string, params?: Record<string, unknown>): Promise<Memory[]>;
+    close(): Promise<void>;
+    private _semanticRetrieve;
+    private _postFilter;
+    private _nodeToMemory;
+}
+
+type WeaviateClient = {
+    collections: {
+        create(opts: {
+            name: string;
+            properties: {
+                name: string;
+                dataType: string;
+            }[];
+            vectorizers?: unknown;
+        }): Promise<unknown>;
+        get(name: string): WeaviateCollection;
+        delete(name: string): Promise<void>;
+        exists(name: string): Promise<boolean>;
+        listAll(): Promise<string[]>;
+    };
+};
+type WeaviateCollection = {
+    data: {
+        insert(opts: {
+            properties: Record<string, unknown>;
+            vectors: number[];
+            id?: string;
+        }): Promise<string>;
+        deleteById(id: string): Promise<void>;
+    };
+    query: {
+        fetchObjectById(id: string, opts?: {
+            includeVector?: boolean;
+        }): Promise<{
+            properties: Record<string, unknown>;
+            vectors?: {
+                default?: number[];
+            };
+        } | null>;
+        fetchObjects(opts: {
+            limit: number;
+            filters?: unknown;
+            includeVector?: boolean;
+        }): Promise<{
+            objects: {
+                uuid: string;
+                properties: Record<string, unknown>;
+                vectors?: {
+                    default?: number[];
+                };
+                metadata?: {
+                    creationTimeUnix: number;
+                };
+            }[];
+        }>;
+        nearVector(vector: number[], opts: {
+            limit: number;
+            returnProperties?: string[];
+            returnMetadata?: string[];
+            filters?: unknown;
+            includeVector?: boolean;
+        }): Promise<{
+            objects: {
+                uuid: string;
+                properties: Record<string, unknown>;
+                vectors?: {
+                    default?: number[];
+                };
+                metadata?: {
+                    creationTimeUnix: number;
+                };
+            }[];
+        }>;
+    };
+    config: {
+        get(): Promise<{
+            name: string;
+        }>;
+        update(opts: {
+            vectorIndexConfig: Record<string, unknown>;
+        }): Promise<void>;
+    };
+};
+interface WeaviateStorageConfig {
+    client: WeaviateClient;
+    className?: string;
+}
+declare class WeaviateStorageAdapter implements StorageProvider {
+    private client;
+    private className;
+    private _collection;
+    private _idToWv;
+    constructor(config: WeaviateStorageConfig);
+    initialize(): Promise<void>;
+    private collection;
+    generateId(): string;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    close(): Promise<void>;
+    private _buildFilter;
+    private _toProperties;
+    private _fromProperties;
+}
+
+type LanceDBConnection = {
+    createTable(name: string, data: {
+        id: string;
+        vector: number[];
+        actor_id: string;
+        memory_type: string;
+        content: string;
+        importance: number;
+        emotional_valence: number;
+        tags: string;
+        source_id: string;
+        metadata: string;
+        expires_at: string;
+        created_at: string;
+    }[]): Promise<LanceDBTable>;
+    openTable(name: string): Promise<LanceDBTable>;
+    tableNames(): Promise<string[]>;
+};
+type LanceDBTable = {
+    add(data: {
+        id: string;
+        vector: number[];
+        actor_id: string;
+        memory_type: string;
+        content: string;
+        importance: number;
+        emotional_valence: number;
+        tags: string;
+        source_id: string;
+        metadata: string;
+        expires_at: string;
+        created_at: string;
+    }[]): Promise<void>;
+    search(vector: number[]): {
+        limit(n: number): {
+            where(predicate: string): {
+                execute(): Promise<{
+                    id: string;
+                    _distance: number;
+                    vector: number[];
+                    actor_id: string;
+                    memory_type: string;
+                    content: string;
+                    importance: number;
+                    emotional_valence: number;
+                    tags: string;
+                    source_id: string;
+                    metadata: string;
+                    expires_at: string;
+                    created_at: string;
+                }[]>;
+            };
+        };
+    };
+    delete(predicate: string): Promise<void>;
+    countRows(predicate?: string): Promise<number>;
+};
+interface LanceDBStorageConfig {
+    connection: LanceDBConnection;
     tableName?: string;
-    /** Automatically run CREATE TABLE IF NOT EXISTS on init. Default: true */
-    autoMigrate?: boolean;
 }
-declare class PostgresStorage implements StorageProvider {
-    private pool;
+declare class LanceDBStorageAdapter implements StorageProvider {
+    private connection;
     private table;
-    private autoMigrate;
-    constructor(config: PostgresStorageConfig);
+    private tableName;
+    private _zeroVector;
+    constructor(config: LanceDBStorageConfig);
     initialize(): Promise<void>;
     generateId(): string;
     store(input: MemoryStoreInput): Promise<Memory>;
@@ -344,10 +762,61 @@ declare class PostgresStorage implements StorageProvider {
     retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
     count(filter?: MemoryCountFilter): Promise<number>;
     close(): Promise<void>;
-    private _semanticRetrieve;
     private _rowToMemory;
 }
 
+type MongoCollection = {
+    insertOne(doc: Record<string, unknown>): Promise<{
+        insertedId: string;
+    }>;
+    findOne(filter: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+    updateOne(filter: Record<string, unknown>, update: Record<string, unknown>, opts?: {
+        upsert?: boolean;
+    }): Promise<{
+        upsertedId?: string;
+    }>;
+    deleteOne(filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+    deleteMany(filter: Record<string, unknown>): Promise<{
+        deletedCount: number;
+    }>;
+    find(filter: Record<string, unknown>): {
+        sort(sort: Record<string, number>): {
+            limit(n: number): {
+                toArray(): Promise<Record<string, unknown>[]>;
+            };
+        };
+    };
+    countDocuments(filter?: Record<string, unknown>): Promise<number>;
+    aggregate(pipeline: Record<string, unknown>[]): {
+        toArray(): Promise<Record<string, unknown>[]>;
+    };
+};
+interface MongoDBStorageConfig {
+    collection: MongoCollection;
+    vectorDimensions?: number;
+}
+declare class MongoDBStorageAdapter implements StorageProvider {
+    private collection;
+    private vectorDimensions;
+    constructor(config: MongoDBStorageConfig);
+    initialize(): Promise<void>;
+    generateId(): string;
+    store(input: MemoryStoreInput): Promise<Memory>;
+    storeBatch(inputs: MemoryStoreInput[]): Promise<Memory[]>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<void>;
+    deleteMany(ids: string[]): Promise<number>;
+    retrieve(query: MemoryRetrieveQuery, embedding?: number[]): Promise<Memory[]>;
+    count(filter?: MemoryCountFilter): Promise<number>;
+    close(): Promise<void>;
+    private retrieveStandard;
+    private retrieveSemantic;
+    private toMemory;
+    private toDoc;
+}
+
 interface OpenAILLMConfig {
     apiKey: string;
     baseURL?: string;
@@ -403,7 +872,7 @@ declare class AnthropicLLMAdapter implements LLMProvider {
     private baseURL;
     private defaultModel;
     private defaultMaxTokens;
-    private sdk;
+    private sdk?;
     constructor(config: AnthropicLLMConfig);
     complete(request: {
         system: string;
@@ -533,4 +1002,4 @@ declare class GroqLLMAdapter implements LLMProvider {
     }>;
 }
 
-export { AnthropicLLMAdapter, type AnthropicLLMConfig, CohereEmbeddingAdapter, type CohereEmbeddingConfig, type CompiledContext, type ContextOptions, DiskStorage, type DiskStorageConfig, type EmbeddingProvider, GroqLLMAdapter, type GroqLLMConfig, type HealthStatus, InMemoryStorage, type LLMProvider, MemStack, type MemStackConfig, MemStackError, type MemStackErrorCode, type MemStackSnapshot, type Memory, type MemoryCountFilter, type MemoryRetrieveQuery, type MemoryStoreInput, type MemoryType, OllamaLLMAdapter, type OllamaLLMConfig, OpenAIEmbeddingAdapter, type OpenAIEmbeddingConfig, OpenAILLMAdapter, type OpenAILLMConfig, PostgresStorage, type PostgresStorageConfig, type ProcessInput, type ProcessResult, type PruneStrategy, RedisStorage, type RedisStorageConfig, type StorageProvider, type SummarizeOptions, configError, notFound, storageError, validationError };
+export { AnthropicLLMAdapter, type AnthropicLLMConfig, CohereEmbeddingAdapter, type CohereEmbeddingConfig, type CompiledContext, type ContextOptions, DiskStorageAdapter, type DiskStorageConfig, type EmbeddingProvider, GroqLLMAdapter, type GroqLLMConfig, type HealthStatus, HybridStorageAdapter, type HybridStorageConfig, InMemoryStorageAdapter, type LLMProvider, LanceDBStorageAdapter, type LanceDBStorageConfig, MarkdownStorageAdapter, type MarkdownStorageConfig, MemStack, type MemStackConfig, MemStackError, type MemStackErrorCode, type MemStackSnapshot, type Memory, type MemoryCountFilter, type MemoryRetrieveQuery, type MemoryStats, type MemoryStoreInput, type MemoryType, MongoDBStorageAdapter, type MongoDBStorageConfig, Neo4jStorageAdapter, type Neo4jStorageConfig, OllamaLLMAdapter, type OllamaLLMConfig, OpenAIEmbeddingAdapter, type OpenAIEmbeddingConfig, OpenAILLMAdapter, type OpenAILLMConfig, PostgresStorageAdapter, type PostgresStorageConfig, type ProcessInput, type ProcessResult, type PruneStrategy, QdrantStorageAdapter, type QdrantStorageConfig, RedisStorageAdapter, type RedisStorageConfig, type StorageProvider, type SummarizeOptions, WeaviateStorageAdapter, type WeaviateStorageConfig, configError, notFound, storageError, validationError };