wolbarg 0.3.2 → 0.4.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { DatabaseSync } from 'node:sqlite';
+
 /**
  * Metadata filter AST for advanced recall filtering.
  */
@@ -224,8 +226,10 @@ interface PostgresDatabaseConfig {
     connectionString?: string;
     /** v0.3 preferred alias for the Postgres connection string. */
     url?: string;
-    /** Optional max pool size. Defaults to 10. */
+    /** Optional max pool size. Defaults to 64. */
     maxPoolSize?: number;
+    /** When false, uses asynchronous commit for higher write throughput. */
+    durableWrites?: boolean;
 }
 /** Discriminated union of database configs. */
 type DatabaseConfig = SqliteDatabaseConfig | PostgresDatabaseConfig;
@@ -302,6 +306,30 @@ interface InitOptions {
      */
     llm?: LlmConfig;
 }
+/** Write-time memory dedupe strategy. */
+type MemoryDedupeStrategy = "exact" | "near" | "exact-or-near";
+/** Constructor / per-call memory dedupe configuration. */
+interface MemoryDedupeConfig {
+    enabled?: boolean;
+    strategy?: MemoryDedupeStrategy;
+    /** Cosine similarity threshold for near-dup matching. Default 0.92 */
+    nearThreshold?: number;
+    /** Max vector candidates considered for near-dup. Default 8 */
+    nearCandidateLimit?: number;
+}
+/** SQLite multi-writer concurrency tuning. */
+interface ConcurrencyConfig$1 {
+    maxRetries?: number;
+    baseBackoffMs?: number;
+    maxBackoffMs?: number;
+    lockTimeoutMs?: number;
+}
+/** Transparent embedding cache configuration. */
+interface EmbeddingCacheConfig {
+    enabled?: boolean;
+    ttlMs?: number;
+    maxEntries?: number;
+}
 /** Input for {@link Wolbarg.remember}. */
 interface RememberOptions {
     /** Agent identifier that owns this memory. */
@@ -310,6 +338,14 @@ interface RememberOptions {
     content: MemoryContent;
     /** Optional opaque metadata. Stored and returned as-is. */
     metadata?: MemoryMetadata;
+    /** Per-call dedupe override; undefined uses constructor `memory.dedupe`. */
+    dedupe?: boolean | MemoryDedupeConfig;
+}
+/** Whether remember created a new row or updated an existing one. */
+type RememberAction = "created" | "updated";
+/** Result of {@link Wolbarg.remember} — MemoryRecord plus upsert action. */
+interface RememberResult extends MemoryRecord {
+    action: RememberAction;
 }
 /** Optional filter applied to recall / forget / compress operations. */
 interface MemoryFilter {
@@ -465,7 +501,7 @@ interface HistoryOptions {
 interface HistoryEvent {
     id: string;
     memoryId: string;
-    eventType: "created" | "archived" | "compressed";
+    eventType: "created" | "archived" | "compressed" | "updated";
     relatedMemoryId: string | null;
     createdAt: Date;
 }
@@ -768,6 +804,7 @@ interface MemoryRow {
     metadata_json: string;
     archived: number;
     compressed_into: string | null;
+    content_hash?: string | null;
     created_at: string;
     updated_at: string;
     rowid?: number;
@@ -776,7 +813,7 @@ interface MemoryRow {
 interface HistoryRow {
     id: string;
     memory_id: string;
-    event_type: "created" | "archived" | "compressed";
+    event_type: "created" | "archived" | "compressed" | "updated";
     related_memory_id: string | null;
     created_at: string;
 }
@@ -790,6 +827,7 @@ interface InsertMemoryInput {
     embedding: Float32Array;
     createdAt: string;
     updatedAt: string;
+    contentHash?: string | null;
 }
 /** Payload for updating memory content / metadata. */
 interface UpdateMemoryInput {
@@ -799,6 +837,7 @@ interface UpdateMemoryInput {
     metadata?: MemoryMetadata;
     embedding?: Float32Array;
     updatedAt: string;
+    contentHash?: string | null;
 }
 /** Filters used by repository queries. */
 interface RepositoryFilter {
@@ -834,6 +873,11 @@ interface StorageProvider {
     insertMemoriesBatch(inputs: InsertMemoryInput[]): Promise<MemoryRow[]>;
     /** Update memory fields and optionally replace embedding. */
     updateMemory(input: UpdateMemoryInput): Promise<MemoryRow | null>;
+    /**
+     * Find an active (non-archived) memory by content hash within org+agent.
+     * Used by write-time exact dedupe.
+     */
+    findActiveByContentHash?(organization: string, agent: string, contentHash: string): Promise<MemoryRow | null>;
     /** Fetch a memory by UUID. */
     getMemoryById(id: string, organization: string): Promise<MemoryRow | null>;
     /** Fetch a memory by its integer rowid. */
@@ -1024,6 +1068,14 @@ interface WolbargOptionsBase {
     chunking?: ChunkingStrategy;
     /** Optional retrieval defaults. */
     retrieval?: RetrievalConfig;
+    /** SQLite multi-writer concurrency tuning (ignored for Postgres). */
+    concurrency?: ConcurrencyConfig$1;
+    /** Transparent embedding cache (default enabled). */
+    embeddingCache?: EmbeddingCacheConfig;
+    /** Memory write-path options (dedupe / upsert). */
+    memory?: {
+        dedupe?: MemoryDedupeConfig;
+    };
 }
 interface WolbargOptionsWithoutLlm extends WolbargOptionsBase {
     llm?: undefined;
@@ -1034,6 +1086,29 @@ interface WolbargOptionsWithLlm extends WolbargOptionsBase {
 }
 type WolbargOptions = WolbargOptionsWithoutLlm | WolbargOptionsWithLlm;
 
+/**
+ * Public subscribe() types for real-time memory change events.
+ */
+type SubscribableEvent = "remember" | "update" | "forget" | "compress" | "ingest" | "*";
+interface SubscribeFilter {
+    organization: string;
+    agent?: string;
+    event?: SubscribableEvent | SubscribableEvent[];
+}
+interface MemoryChangeEvent {
+    event: Exclude<SubscribableEvent, "*">;
+    organization: string;
+    agent: string;
+    memoryId: string | string[];
+    timestamp: string;
+    traceId?: string;
+    sessionId?: string;
+    /** Present when upsert path ran during remember/ingest. */
+    upsertAction?: "created" | "updated" | "skipped";
+}
+type MemoryChangeCallback = (event: MemoryChangeEvent) => void;
+type Unsubscribe = () => void;
+
 /**
  * Wolbarg — modular semantic memory SDK for AI agents (v0.3).
  *
@@ -1082,6 +1157,11 @@ declare class Wolbarg<HasLlm extends boolean = false> {
     private checkpointProvider;
     private memoryDbPath;
     private readonly transfer;
+    private subscribeBackend;
+    private pgListenBackend;
+    private memoryDedupe;
+    private embeddingCacheConfig;
+    private rawEmbedding;
     constructor(options: WolbargOptionsWithLlm);
     constructor(options: WolbargOptionsWithoutLlm);
     constructor();
@@ -1092,10 +1172,31 @@ declare class Wolbarg<HasLlm extends boolean = false> {
     /** Ensure storage (and optional telemetry) are open. */
     ready(): Promise<void>;
     private boot;
-    /** Store a semantic memory for an agent. */
-    remember(options: RememberOptions): Promise<MemoryRecord>;
-    /** Batch remember — one parent event + child traces per item. */
-    rememberBatch(items: RememberOptions[]): Promise<MemoryRecord[]>;
+    /** Store a semantic memory for an agent (may upsert when dedupe is enabled). */
+    remember(options: RememberOptions): Promise<RememberResult>;
+    /** Batch remember — sequential when dedupe enabled; otherwise one TX batch. */
+    rememberBatch(items: RememberOptions[]): Promise<RememberResult[]>;
+    /**
+     * Update an existing memory by id (re-embeds when content changes).
+     */
+    update(options: {
+        id: string;
+        content?: {
+            text: string;
+        };
+        metadata?: MemoryMetadata;
+    }): Promise<RememberResult>;
+    /**
+     * Subscribe to memory change events.
+     *
+     * **SQLite:** delivers events only within this Node.js process.
+     * A second process writing the same `memory.db` will not notify subscribers here.
+     */
+    subscribe(filter: SubscribeFilter, callback: (event: MemoryChangeEvent) => void): Unsubscribe;
+    private emitChange;
+    /** Internal remember with optional upsert/dedupe. */
+    private rememberOne;
+    private findNearDuplicate;
     /**
      * Semantic / hybrid search over stored memories.
      * Pass `{ explain: true }` for enriched ranking diagnostics.
@@ -1132,6 +1233,11 @@ declare class Wolbarg<HasLlm extends boolean = false> {
     flushTelemetry(): Promise<void>;
     /** Session id for this SDK instance (telemetry traces). */
     get sessionId(): string;
+    /**
+     * Optional process-wide lock for SQLite read-modify-write (dedupe upsert).
+     * Plain inserts must NOT take this lock — the provider coalesces concurrent
+     * insertMemory calls under a single BEGIN IMMEDIATE for multi-writer throughput.
+     */
     private withWriteLock;
     close(): Promise<void>;
     get isInitialized(): boolean;
@@ -1190,6 +1296,17 @@ declare class DatabaseError extends WolbargError {
         operation?: string;
     });
 }
+/**
+ * Thrown when SQLite write-lock retries are exhausted.
+ * Stable code: WOLBARG_STORAGE_LOCKED
+ */
+declare class StorageLockedError extends WolbargError {
+    constructor(message: string, options?: ErrorOptions & {
+        reason?: string;
+        suggestion?: string;
+        operation?: string;
+    });
+}
 /** Thrown when an embedding request fails. */
 declare class EmbeddingError extends WolbargError {
     constructor(message: string, options?: ErrorOptions & {
@@ -1236,10 +1353,13 @@ declare function sqliteConfig(connectionString: string): SqliteDatabaseConfig;
 declare function postgres(options: string | {
     connectionString: string;
     maxPoolSize?: number;
+    /** Default true. Set false for higher write throughput (async commit). */
+    durableWrites?: boolean;
 }): StorageProvider;
 /** Create a PostgreSQL storage config object. */
 declare function postgresConfig(connectionString: string, options?: {
     maxPoolSize?: number;
+    durableWrites?: boolean;
 }): PostgresDatabaseConfig;
 /** Create a SQLite telemetry provider for an independent event database. */
 declare function sqliteTelemetry(url: string): TelemetryProvider;
@@ -1252,6 +1372,20 @@ declare function createTelemetryProvider(config: TelemetryConfig): TelemetryProv
  */
 declare function wolbarg(options: WolbargOptions): Wolbarg;
 
+/**
+ * SQLite multi-writer concurrency defaults and validation.
+ */
+interface ConcurrencyConfig {
+    /** Max retry attempts after SQLITE_BUSY. Default: 5 */
+    maxRetries?: number;
+    /** Base backoff in ms before jitter. Default: 50 */
+    baseBackoffMs?: number;
+    /** Cap on backoff delay in ms. Default: 2000 */
+    maxBackoffMs?: number;
+    /** SQLite busy_timeout pragma in ms. Default: 5000 */
+    lockTimeoutMs?: number;
+}
+
 /**
  * SQLite + sqlite-vec database provider (Node.js built-in `node:sqlite`).
  *
@@ -1266,10 +1400,12 @@ declare function wolbarg(options: WolbargOptions): Wolbarg;
 
 interface SqliteProviderOptions {
     connectionString: string;
+    concurrency?: ConcurrencyConfig;
 }
 declare class SqliteStorageProvider implements StorageProvider {
     readonly name = "sqlite";
     private readonly connectionString;
+    private readonly concurrency;
     private db;
     private statements;
     private vectorDimensions;
@@ -1280,17 +1416,41 @@ declare class SqliteStorageProvider implements StorageProvider {
     private memoryIndexDirty;
     /** Resolved absolute path (or `:memory:`) — avoid re-resolving on size checks. */
     private resolvedPath;
+    private retryLog;
+    /** Cached prepared statements for `rowid IN (…)` lookups keyed by list length. */
+    private rowidInStatements;
+    /** Cached list SQL statements keyed by clause shape. */
+    private listStatements;
+    /** Cached multi-row insert statements keyed by row count. */
+    private batchInsertStatements;
+    /** Cached multi-row history inserts keyed by row count. */
+    private batchHistoryStatements;
+    /** Cached multi-row FTS inserts keyed by row count. */
+    private batchFtsStatements;
+    /** Cached multi-row blob embedding inserts keyed by row count. */
+    private batchBlobEmbStatements;
+    /** Coalesce concurrent insertMemory callers into one IMMEDIATE transaction. */
+    private insertQueue;
+    private insertFlushScheduled;
     constructor(options: SqliteProviderOptions);
     /** Absolute or relative path / `:memory:` used by this provider. */
     get path(): string;
+    /** Expose DB for embedding cache store (same connection). */
+    getDatabase(): DatabaseSync | null;
+    setRetryLogger(fn: ((msg: string) => void) | null): void;
     open(): Promise<void>;
     close(): Promise<void>;
     ensureVectorSchema(dimensions: number): Promise<void>;
     getEmbeddingDimensions(): Promise<number | null>;
     setEmbeddingDimensions(dimensions: number): Promise<void>;
     insertMemory(input: InsertMemoryInput): Promise<MemoryRow>;
+    private scheduleInsertFlush;
+    private flushInsertQueue;
+    /** Single-row insert without coalescing (used by flush of size 1). */
+    private insertMemoryImmediate;
     insertMemoriesBatch(inputs: InsertMemoryInput[]): Promise<MemoryRow[]>;
     updateMemory(input: UpdateMemoryInput): Promise<MemoryRow | null>;
+    findActiveByContentHash(organization: string, agent: string, contentHash: string): Promise<MemoryRow | null>;
     searchByMetadata(filter: RepositoryFilter, limit?: number): Promise<MemoryRow[]>;
     /** Keyword search via FTS5 BM25. Returns memory IDs ranked by relevance. */
     searchKeyword(query: string, organization: string, topK: number): Promise<Array<{
@@ -1303,8 +1463,8 @@ declare class SqliteStorageProvider implements StorageProvider {
     listMemories(filter: RepositoryFilter, limit?: number): Promise<MemoryRow[]>;
     searchVectors(embedding: Float32Array, topK: number): Promise<VectorSearchHit[]>;
     /**
-     * Org-scoped KNN + memory rows.
-     * Caller (Wolbarg.recall) already passes an overfetched topK — do not multiply again.
+     * Org-scoped KNN + memory rows with adaptive overfetch.
+     * Global ANN is post-filtered by org/agent/archived; underfill triggers larger k.
      */
     searchVectorsWithMemories(embedding: Float32Array, topK: number, organization: string, options?: {
         agent?: string;
@@ -1326,9 +1486,21 @@ declare class SqliteStorageProvider implements StorageProvider {
         totalAgents: number;
     }>;
     getDatabaseSizeBytes(): Promise<number>;
-    withTransaction<T>(fn: () => T): T;
+    withTransaction<T>(fn: () => T | Promise<T>): Promise<T>;
     private tryLoadSqliteVec;
+    private static sqliteVecUnsupported;
     private runMigrations;
+    /**
+     * Schema v4: drop unused global created_at index, strip archived vectors
+     * from ANN, add agent-active covering index (via CREATE_INDEXES).
+     */
+    private migrateToV4;
+    /**
+     * Schema v3: content_hash column, history 'updated' event, embedding_cache.
+     * SQLite cannot ALTER CHECK constraints — rebuild memory_history when needed.
+     */
+    private migrateToV3;
+    private migrateHistoryAllowUpdated;
     /**
      * Rebuild FTS from active (non-archived) memories when counts diverge.
      * Guarantees keyword/hybrid correctness after crashes or interrupted writes.
@@ -1336,7 +1508,19 @@ declare class SqliteStorageProvider implements StorageProvider {
     private ensureFtsConsistency;
     private backfillFts;
     private prepareStatements;
-    private listMemoriesSync;
+    private listMemoriesIndexed;
+    /**
+     * Metadata-filtered list: push filters to json_extract when possible;
+     * otherwise page with a hard scan cap (never load unbounded orgs into RAM).
+     */
+    private listMemoriesWithMetadata;
+    private getRowidInStatement;
+    private insertMemoryChunk;
+    private insertEmbeddingsBatch;
+    private insertFtsBatch;
+    private insertHistoryBatch;
+    private deleteEmbeddingsForScope;
+    private deleteFtsForScope;
     /** Insert-only FTS row (new memory IDs never collide). */
     private insertFtsRow;
     private upsertFts;
@@ -1371,30 +1555,63 @@ declare const SqliteDatabaseProvider: typeof SqliteStorageProvider;
  * - AsyncLocalStorage for nested transactions
  * - Single-statement CTE inserts (no BEGIN/COMMIT for one memory)
  * - Named prepared statements (parse/plan once per connection)
- * - Concurrent insert coalescing into unnest batches; sequential path is immediate
- * - COPY protocol for large ingest batches
- * - Org-filtered ANN with adaptive overfetch + HNSW iterative scan when available
- * - Joined vector search returning memories in one round-trip when possible
+ * - Concurrent insert coalescing into unnest batches
+ * - float4[] vector bind (no text "[f,f,…]" parse tax)
+ * - Org/agent/archived denormalized on embeddings for filtered ANN
+ * - Large bulk inserts via sequential fat unnest (COPY-class amortization)
+ * - JSONB metadata filter pushdown
  */
 
+type PgQueryResult = {
+    rows: Record<string, unknown>[];
+    rowCount: number | null;
+};
+type PgQueryable = {
+    query: (textOrConfig: string | {
+        name?: string;
+        text: string;
+        values?: unknown[];
+    }, params?: unknown[]) => Promise<PgQueryResult>;
+};
+type PgPoolClient = PgQueryable & {
+    release: () => void;
+    query: PgQueryable["query"];
+};
+type PgPool = PgQueryable & {
+    end: () => Promise<void>;
+    connect: () => Promise<PgPoolClient>;
+    on?: (event: "connect", listener: (client: PgPoolClient) => void) => void;
+    totalCount?: number;
+    idleCount?: number;
+    waitingCount?: number;
+};
 interface PostgresProviderOptions {
     connectionString: string;
     maxPoolSize?: number;
+    /**
+     * When false, uses `synchronous_commit=off` on every pool connection.
+     * Much higher write throughput; recent commits can be lost on OS crash.
+     * Default true (full durability).
+     */
+    durableWrites?: boolean;
 }
 declare class PostgresStorageProvider implements StorageProvider {
     readonly name = "postgres";
     private readonly connectionString;
     private readonly maxPoolSize;
+    private readonly durableWrites;
     private pool;
     private vectorDimensions;
     private hasPgvector;
     private hnswIndexEnsured;
     private hnswCreateFailures;
+    /** Dedup concurrent CREATE INDEX so mixed read/write storms don't pile up. */
+    private hnswBuildInFlight;
     private hasContentTsv;
-    private iterativeScanEnabled;
     /** Coalesce concurrent insertMemory callers into one unnest batch. */
     private insertQueue;
     private insertFlushScheduled;
+    private insertFlushTimer;
     private insertFlushInFlight;
     constructor(options: PostgresProviderOptions);
     getPoolStats(): {
@@ -1403,10 +1620,26 @@ declare class PostgresStorageProvider implements StorageProvider {
         idle: number;
         waiting: number;
     };
+    /** Dedicated pool accessor for LISTEN/NOTIFY subscribe backend. */
+    getPool(): PgPool | null;
     open(): Promise<void>;
     close(): Promise<void>;
+    /**
+     * Run a search query. HNSW GUCs are baked into pool startup options —
+     * no per-recall connect()+set_config round-trip.
+     */
+    private withSearchSession;
+    /**
+     * Drop HNSW so bulk / concurrent inserts avoid graph maintenance.
+     * Next recall rebuilds the index (lazy).
+     */
+    dropVectorIndex(): Promise<void>;
+    /** Force HNSW build now (e.g. before timed recall benches). */
+    ensureVectorIndex(): Promise<void>;
     ensureVectorSchema(dimensions: number): Promise<void>;
     private ensureVectorTables;
+    /** Cross-process subscribe: NOTIFY after a committed write. */
+    notifyChange(event: MemoryChangeEvent): Promise<void>;
     /**
      * Soft reset for a single organization. Drops HNSW only when the embeddings
      * table is empty so other corpora on a shared bench DB stay intact.
@@ -1418,18 +1651,23 @@ declare class PostgresStorageProvider implements StorageProvider {
     wipeAllData(): Promise<void>;
     /** Build HNSW once before the first KNN query (bulk-friendly inserts). */
     private ensureHnswIndex;
+    private buildHnswIndex;
     getEmbeddingDimensions(): Promise<number | null>;
     setEmbeddingDimensions(dimensions: number): Promise<void>;
     insertMemory(input: InsertMemoryInput): Promise<MemoryRow>;
+    private clearInsertFlushTimer;
+    /** Flush coalesced inserts after a turn so concurrent remember() can join. */
+    private scheduleInsertFlush;
     private flushInsertQueue;
     /** Single-row insert without coalescing (used by flush + batch of 1). */
     private insertMemoryImmediate;
     insertMemoriesBatch(inputs: InsertMemoryInput[]): Promise<MemoryRow[]>;
     private insertBatchPgvector;
-    /** Split large ingest batches into parallel unnest chunks (pool pipelining). */
+    /** Parallel unnest when HNSW is absent; sequential when index must stay consistent. */
     private insertBatchChunked;
     private insertOneBlob;
     updateMemory(input: UpdateMemoryInput): Promise<MemoryRow | null>;
+    findActiveByContentHash(organization: string, agent: string, contentHash: string): Promise<MemoryRow | null>;
     getMemoryById(id: string, organization: string): Promise<MemoryRow | null>;
     getMemoryByRowid(rowid: number, organization: string): Promise<MemoryRow | null>;
     getMemoriesByRowids(rowids: number[], organization: string): Promise<Map<number, MemoryRow>>;
@@ -1463,6 +1701,8 @@ declare class PostgresStorageProvider implements StorageProvider {
     withTransaction<T>(fn: () => T | Promise<T>): Promise<T>;
     private runMigrations;
     private tryEnablePgvector;
+    private static pgvectorByConn;
+    private static vectorSchemaReady;
     private insertEmbedding;
     private deleteEmbedding;
     private query;
@@ -1474,11 +1714,9 @@ declare class PostgresStorageProvider implements StorageProvider {
     private describe;
 }
 
-/**
- * Storage provider factory and re-exports.
- */
-
-declare function createStorageProvider(config: StorageConfig | DatabaseConfig): StorageProvider;
+declare function createStorageProvider(config: StorageConfig | DatabaseConfig, options?: {
+    concurrency?: ConcurrencyConfig$1;
+}): StorageProvider;
 /** @deprecated Prefer {@link createStorageProvider}. */
 declare function createDatabaseProvider(config: DatabaseConfig): StorageProvider;
 
@@ -1690,4 +1928,4 @@ interface BenchmarkReport {
 declare function runBenchmark(name: string, iterations: number, fn: () => Promise<void> | void): Promise<BenchmarkSample[]>;
 declare function summarizeBenchmark(samples: BenchmarkSample[], startedAt: string, finishedAt: string): BenchmarkReport;
 
-export { type BenchmarkReport, type BenchmarkSample, type ChatMessage, type CheckpointInfo, type CheckpointMeta, type CheckpointOptions, type CheckpointProvider, type Chunk, type ChunkingOptions, type ChunkingStrategy, type ClearOptions, type CompressOptions, type CompressResult, CompressionError, type CompressionProvider, ConfigurationError, type CreateCheckpointOptions, type DatabaseConfig, DatabaseError, type DatabaseProvider, type DatabaseProviderName, type EmbeddingConfig, EmbeddingError, type EmbeddingProvider, type EventDatabase, type ExportResult, FixedChunkingStrategy, type ForgetByFilterOptions, type ForgetByIdOptions, type ForgetOptions, HeadingChunkingStrategy, type HistoryEvent, type HistoryOptions, type HistoryResult, type HybridConfig, type ImportResult, type IngestOptions, type IngestResult, type InitOptions, InitializationError, type KeywordDocument, type KeywordSearchHit, type KeywordSearchProvider, type LatencyBreakdown, LlmCompressionProvider, type LlmConfig, type LlmProvider, MarkdownChunkingStrategy, type MemoryContent, type MemoryFilter, type MemoryMetadata, MemoryNotFoundError, type MemoryProvider, type MemoryRecord, type MetadataFilter as MetaFilter, type MetadataComparison, type MetadataFilter, type MmrConfig, NoopTelemetryProvider, type OCRProvider, type OcrResult, ParagraphChunkingStrategy, type PersistedRecallExplainPayload, type PostgresDatabaseConfig, PostgresStorageProvider, ProviderNotConfiguredError, type RecallExplainResponse, type RecallExplanationHit, type RecallOptions, type RecallResult, type RememberOptions, type RerankDocument, type RerankHit, type RerankerProvider, type RetrievalConfig, SentenceChunkingStrategy, SqliteCheckpointProvider, type SqliteDatabaseConfig, SqliteDatabaseProvider, SqliteEventDatabase, SqliteStorageProvider, SqliteTelemetryProvider, type StageSpan, type StatsResult, type StorageConfig, type StorageProvider, type StorageProviderName, type TelemetryConfig, TelemetryEmitter, type TelemetryEvent, type TelemetryEventInput, type TelemetryLogLevel, type TelemetryOperation, type TelemetryProvider, type TelemetryQuery, type TelemetryQueryResult, type TelemetryStatus, ValidationError, type VisionProvider, type VisionResult, Wolbarg, WolbargError, WolbargLogger, type WolbargOptions, type WolbargOptionsWithLlm, type WolbargOptionsWithoutLlm, bgeReranker, bm25, cohereReranker, createChunkingStrategy, createCompressionProvider, createDatabaseProvider, createEmbeddingProvider, createLlmProvider, createStorageProvider, createTelemetryProvider, wolbarg as createWolbarg, crossEncoder, geminiEmbedding, geminiVision, jinaReranker, lmStudioEmbedding, meta, ollamaEmbedding, ollamaLlm, openRouterEmbedding, openRouterLlm, openaiCompatibleEmbedding, openaiCompatibleLlm, openaiEmbedding, openaiLlm, openaiReranker, openaiVision, postgres, postgresConfig, runBenchmark, sqlite, sqliteCheckpoint, sqliteConfig, sqliteTelemetry, summarizeBenchmark, tesseract, togetherEmbedding, vllmEmbedding, wolbarg$1 as wolbarg, wrapOperationError };
+export { type BenchmarkReport, type BenchmarkSample, type ChatMessage, type CheckpointInfo, type CheckpointMeta, type CheckpointOptions, type CheckpointProvider, type Chunk, type ChunkingOptions, type ChunkingStrategy, type ClearOptions, type CompressOptions, type CompressResult, CompressionError, type CompressionProvider, type ConcurrencyConfig$1 as ConcurrencyConfig, ConfigurationError, type CreateCheckpointOptions, type DatabaseConfig, DatabaseError, type DatabaseProvider, type DatabaseProviderName, type EmbeddingCacheConfig, type EmbeddingConfig, EmbeddingError, type EmbeddingProvider, type EventDatabase, type ExportResult, FixedChunkingStrategy, type ForgetByFilterOptions, type ForgetByIdOptions, type ForgetOptions, HeadingChunkingStrategy, type HistoryEvent, type HistoryOptions, type HistoryResult, type HybridConfig, type ImportResult, type IngestOptions, type IngestResult, type InitOptions, InitializationError, type KeywordDocument, type KeywordSearchHit, type KeywordSearchProvider, type LatencyBreakdown, LlmCompressionProvider, type LlmConfig, type LlmProvider, MarkdownChunkingStrategy, type MemoryChangeCallback, type MemoryChangeEvent, type MemoryContent, type MemoryDedupeConfig, type MemoryDedupeStrategy, type MemoryFilter, type MemoryMetadata, MemoryNotFoundError, type MemoryProvider, type MemoryRecord, type MetadataFilter as MetaFilter, type MetadataComparison, type MetadataFilter, type MmrConfig, NoopTelemetryProvider, type OCRProvider, type OcrResult, ParagraphChunkingStrategy, type PersistedRecallExplainPayload, type PostgresDatabaseConfig, PostgresStorageProvider, ProviderNotConfiguredError, type RecallExplainResponse, type RecallExplanationHit, type RecallOptions, type RecallResult, type RememberAction, type RememberOptions, type RememberResult, type RerankDocument, type RerankHit, type RerankerProvider, type RetrievalConfig, SentenceChunkingStrategy, SqliteCheckpointProvider, type SqliteDatabaseConfig, SqliteDatabaseProvider, SqliteEventDatabase, SqliteStorageProvider, SqliteTelemetryProvider, type StageSpan, type StatsResult, type StorageConfig, StorageLockedError, type StorageProvider, type StorageProviderName, type SubscribableEvent, type SubscribeFilter, type TelemetryConfig, TelemetryEmitter, type TelemetryEvent, type TelemetryEventInput, type TelemetryLogLevel, type TelemetryOperation, type TelemetryProvider, type TelemetryQuery, type TelemetryQueryResult, type TelemetryStatus, type Unsubscribe, ValidationError, type VisionProvider, type VisionResult, Wolbarg, WolbargError, WolbargLogger, type WolbargOptions, type WolbargOptionsWithLlm, type WolbargOptionsWithoutLlm, bgeReranker, bm25, cohereReranker, createChunkingStrategy, createCompressionProvider, createDatabaseProvider, createEmbeddingProvider, createLlmProvider, createStorageProvider, createTelemetryProvider, wolbarg as createWolbarg, crossEncoder, geminiEmbedding, geminiVision, jinaReranker, lmStudioEmbedding, meta, ollamaEmbedding, ollamaLlm, openRouterEmbedding, openRouterLlm, openaiCompatibleEmbedding, openaiCompatibleLlm, openaiEmbedding, openaiLlm, openaiReranker, openaiVision, postgres, postgresConfig, runBenchmark, sqlite, sqliteCheckpoint, sqliteConfig, sqliteTelemetry, summarizeBenchmark, tesseract, togetherEmbedding, vllmEmbedding, wolbarg$1 as wolbarg, wrapOperationError };