@anuma/sdk 6.31.4 → 6.33.0

package/dist/expo/index.d.mts

@@ -5051,6 +5051,13 @@ declare class MemoryEntity extends Model {
 declare const ENTITY_KINDS: readonly ["person", "organization", "place", "event", "product", "thing", "concept", "other"];
 /** @public */
 type EntityKind = (typeof ENTITY_KINDS)[number];
+interface StoredEntity {
+    uniqueId: string;
+    canonicalName: string;
+    kind: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
 /**
  * Who put a topic on a memory. Written to `memory_vault.topics` but not yet
  * READ anywhere — it exists so a later improvement can refresh the `auto`
@@ -5079,6 +5086,16 @@ interface StoredTopic {
     source: TopicSource;
 }
 
+/**
+ * Accepted entity shape for {@link linkMemoryEntitiesOp}. A bare string is
+ * a name with no kind (back-compat with the original signature); the object
+ * form carries an optional classification.
+ * @public
+ */
+type EntityInput = string | {
+    name: string;
+    kind?: EntityKind | (string & {});
+};
 interface EntityOperationsContext {
     database: Database;
     entityCollection: Collection<Entity>;
@@ -7095,9 +7112,13 @@ interface VaultMemoryOperationsContext {
      */
     entityCtx?: EntityOperationsContext;
 }
+/** @deprecated App code: use `MemoryStore.create` (`createLocalMemoryStore`). */
 declare function createVaultMemoryOp(ctx: VaultMemoryOperationsContext, opts: CreateVaultMemoryOptions): Promise<StoredVaultMemory>;
+/** @deprecated App code: use `MemoryStore.createMany` (`createLocalMemoryStore`). */
 declare function createVaultMemoriesBatchOp(ctx: VaultMemoryOperationsContext, optionsArray: CreateVaultMemoryOptions[]): Promise<StoredVaultMemory[]>;
+/** @deprecated App code: use `MemoryStore.get` (`createLocalMemoryStore`). */
 declare function getVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: string): Promise<StoredVaultMemory | null>;
+/** @deprecated App code: use `MemoryStore.list` (`createLocalMemoryStore`). */
 declare function getAllVaultMemoriesOp(ctx: VaultMemoryOperationsContext, options?: {
     scopes?: string[];
     since?: Date;
@@ -7164,6 +7185,8 @@ declare function getVaultRankingProjectionsOp(ctx: VaultMemoryOperationsContext,
  * Reuses `baseVaultConditions`, so deleted / superseded / cross-user rows are
  * excluded exactly as they are from recall — a caller can pass any id list and
  * only its own live rows come back.
+ *
+ * @deprecated App code: use `MemoryStore.list({ memoryIds })` (`createLocalMemoryStore`).
  */
 declare function getVaultMemoriesByIdsOp(ctx: VaultMemoryOperationsContext, ids: string[], 
 /** See {@link getVaultEmbeddingsByIdsOp} — must match what admitted these ids. */
@@ -7173,6 +7196,7 @@ options?: {
 declare function getAllVaultMemoryContentsOp(ctx: VaultMemoryOperationsContext, options?: {
     since?: Date;
 }): Promise<string[]>;
+/** @deprecated App code: use `MemoryStore.update` (`createLocalMemoryStore`). */
 declare function updateVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: string, opts: UpdateVaultMemoryOptions): Promise<StoredVaultMemory | null>;
 /**
  * Set a memory's People Nearby visibility (and optionally its twin opt-in).
@@ -7186,12 +7210,15 @@ declare function updateVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: stri
  * Preserves `updated_at`: a visibility change is metadata, not a
  * re-observation, so it must not inflate the recency multiplier (mirrors
  * {@link setMemoryEntitiesOp}).
+ *
+ * @deprecated App code: use `MemoryStore.setVisibility` (`createLocalMemoryStore`).
  */
 declare function setMemoryVisibilityOp(ctx: VaultMemoryOperationsContext, id: string, opts: {
     visibility: VaultMemoryVisibility;
     /** If provided, sets the twin opt-in flag alongside the visibility. */
     twinOptIn?: boolean;
 }): Promise<StoredVaultMemory | null>;
+/** @deprecated App code: use `MemoryStore.delete` (`createLocalMemoryStore`). */
 declare function deleteVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: string): Promise<boolean>;
 /**
  * Mark a memory as superseded by a newer one (A2 write-time supersession).
@@ -7203,6 +7230,8 @@ declare function deleteVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: stri
  *
  * @param id - the memory being retired (e.g. "Lives in Portland")
  * @param supersededById - the newer memory that replaced it (e.g. "Lives in SF")
+ *
+ * @deprecated App code: use `MemoryStore.supersede` (`createLocalMemoryStore`).
  */
 declare function supersedeVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: string, supersededById: string): Promise<boolean>;
 /**
@@ -7293,6 +7322,8 @@ interface MemoriesNeedingTopicExtraction {
  * a contradiction only a pre-v42 restore produces, and this is the one place
  * that can see all three facts at once, so it clears the flag there (capped by
  * `limit`) before returning. See the branch for why that's safe.
+ *
+ * @deprecated App code: use `MemoryStore.maintenance.getTopicBacklog` (`createLocalMemoryStore`).
  */
 declare function getMemoriesNeedingTopicExtractionOp(ctx: VaultMemoryOperationsContext, options?: {
     limit?: number;
@@ -7322,6 +7353,8 @@ declare function getMemoriesNeedingTopicExtractionOp(ctx: VaultMemoryOperationsC
  * Callers bound the input via `getMemoriesNeedingTopicExtractionOp`'s `limit`
  * (both `pending` and `linkedUnstamped` are capped), so the per-row Model load
  * needed to `prepareUpdate` stays bounded and never spikes the RecordCache.
+ *
+ * @deprecated App code: use `MemoryStore.maintenance.stampTopicsExtracted` (`createLocalMemoryStore`).
  */
 declare function stampTopicsExtractedAtOp(ctx: VaultMemoryOperationsContext, memoryIds: readonly string[], extractedAt: number, version?: number): Promise<string[]>;
 /**
@@ -7338,6 +7371,8 @@ declare function stampTopicsExtractedAtOp(ctx: VaultMemoryOperationsContext, mem
  *
  * Skips deleted rows, foreign-user rows, and rows with null topics.
  * Empty topics remove stale links. Returns the relinked IDs.
+ *
+ * @deprecated App code: use `MemoryStore.maintenance.relinkTopics` (`createLocalMemoryStore`).
  */
 declare function relinkMemoryTopicsOp(ctx: VaultMemoryOperationsContext, memoryIds: readonly string[]): Promise<string[]>;
 /**
@@ -7362,6 +7397,8 @@ declare function relinkMemoryTopicsOp(ctx: VaultMemoryOperationsContext, memoryI
  * per memory (~107 on a single dev launch, sdk#891); it also cost N writes.
  * Same treatment as {@link stampTopicsExtractedAtOp}, including its
  * transpilation hazard — the prepare pass MUST stay a `.map()`.
+ *
+ * @deprecated App code: use `MemoryStore.maintenance.backfillTopics` (`createLocalMemoryStore`).
  */
 declare function backfillMemoryTopicsOp(ctx: VaultMemoryOperationsContext, memoryIds: readonly string[]): Promise<string[]>;
 declare function deleteAllVaultMemoriesForUserOp(ctx: VaultMemoryOperationsContext, userId: string): Promise<number>;
@@ -7416,6 +7453,8 @@ declare function getDecayCandidatesRawOp(ctx: VaultMemoryOperationsContext): Pro
  *
  * @returns `true` if this call archived the row; `false` if it was stale
  *   (deleted / not owned / already archived / refreshed under us).
+ *
+ * @deprecated App code: use `MemoryStore.archive` (`createLocalMemoryStore`).
  */
 declare function archiveVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: string, opts?: {
     /** Timestamp to stamp into `archived_at`. Default `Date.now()`. */
@@ -7433,6 +7472,8 @@ declare function archiveVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: str
  *
  * @returns `true` if the row was restored (or already active); `false` if it was
  *   deleted / not owned / missing.
+ *
+ * @deprecated App code: use `MemoryStore.restore` (`createLocalMemoryStore`).
  */
 declare function restoreVaultMemoryOp(ctx: VaultMemoryOperationsContext, id: string): Promise<boolean>;
 /**
@@ -8947,6 +8988,397 @@ declare class RerankerUnavailableError extends Error {
  */
 declare function isRerankerAvailable(): boolean | undefined;
 
+/**
+ * Standalone topic (entity) extraction for EXISTING memories.
+ *
+ * The conversation pipeline (autoExtract.ts) assigns entities only to facts it
+ * extracts from a live transcript — manually created, imported, and edited
+ * memories never get LLM topics and used to fall back to a client-side regex.
+ * This module is the LLM half of "continuously LLM-managed topics": a batched
+ * pass that takes memories already in the vault, asks the extraction model for
+ * their named entities, REPLACES their auto-managed links (guarded — a manual
+ * edit or delete always wins), and stamps `topics_extracted_at` so the sweep
+ * query (`getMemoriesNeedingTopicExtractionOp`) only revisits edited memories.
+ *
+ * Batching: memories are classified ~10 per LLM call (mirroring the folder
+ * Auto-Sort harness) with per-memory content truncation, so a whole-vault
+ * backfill or a bulk import costs ceil(n/10) requests, not n.
+ */
+
+/** Memories per LLM call. Mirrors the folder Auto-Sort batch size — the cost
+ * lever that makes a whole-vault backfill viable. */
+declare const TOPIC_EXTRACTION_BATCH_SIZE = 10;
+/** One memory to extract topics for. `content` must be the DECRYPTED text. */
+interface TopicExtractionInput {
+    id: string;
+    content: string;
+}
+/**
+ * Options for the topic-extraction LLM call. Auth follows the portal dual
+ * pattern — one of `apiKey` / `getToken` is required (see {@link PortalLlmAuth}).
+ */
+interface TopicExtractOptions extends PortalLlmAuth {
+    baseUrl?: string;
+    /**
+     * Optional per-call request path override, forwarded to
+     * {@link callPortalJsonCompletion}. When set, topic extraction POSTs to
+     * `baseUrl + endpointOverride` instead of the default
+     * `/api/v1/chat/completions`. The body follows the transport, not the path: a
+     * model that needs the Responses API is moved from a `.../chat/completions`
+     * override to its sibling `.../responses` with a Responses-shaped body. Lets callers route
+     * this internal-utility pass to a dedicated endpoint. Invalid values throw at
+     * call time (see {@link validateEndpointOverride}).
+     */
+    endpointOverride?: string;
+    /** Defaults to {@link DEFAULT_EXTRACTION_MODEL} — the sanctioned extraction
+     * model. Don't point this at a second model without an eval. */
+    model?: string;
+    /** Override the global fetch implementation (useful for tests). */
+    fetchFn?: typeof fetch;
+    maxAttempts?: number;
+    timeoutMs?: number;
+    totalTimeoutMs?: number;
+    backoffMs?: (attempt: number) => number;
+    /**
+     * The user's existing entity vocabulary (canonical names). Included in the
+     * prompt so independent batches reuse canonical names instead of fragmenting
+     * ("ZetaChain" / "Zetachain" / "zeta chain" as three graph nodes). Truncated
+     * to the first {@link MAX_VOCABULARY_NAMES} names — pass the most-linked
+     * names first.
+     */
+    existingEntityNames?: readonly string[];
+    /**
+     * When set, PII in memory contents is replaced with tagged placeholders
+     * before the LLM call and returned entity names are de-anonymized (entities
+     * whose placeholders can't be restored are dropped) — mirrors
+     * `ExtractFactsOptions.piiRedaction`. Vault contents hold REAL values, so
+     * callers that redact the conversation pipeline must redact this pass too.
+     */
+    piiRedaction?: boolean | PiiRedactor;
+}
+/**
+ * Ask the extraction LLM for the named entities of each memory, in batches of
+ * {@link TOPIC_EXTRACTION_BATCH_SIZE}. Pure LLM step — no persistence.
+ *
+ * Returns memoryId → entities. A memory PRESENT with an empty array is a
+ * successful, explicit "no named entities" answer; a memory ABSENT from the
+ * map is UNANSWERED — its batch failed after retries, returned an unusable
+ * shape, or the model omitted its id. Callers must retry absent ids in a
+ * later sweep, never stamp them.
+ */
+declare function extractEntitiesForMemories(memories: readonly TopicExtractionInput[], options: TopicExtractOptions): Promise<Map<string, ExtractedEntity[]>>;
+/**
+ * Why one memory was skipped by a topic sweep.
+ *
+ * Split along the line that actually matters operationally — did the sweep
+ * DECLINE this row on purpose, or did something BREAK:
+ *
+ * Deliberate (healthy; a sweep of nothing but these is a success):
+ * - `excluded`        — deleted, owned by another user, or `topicsUserManaged`.
+ * - `link-declined`   — the entity-link write's in-row guard declined (the row
+ *                       became user-managed / deleted / absent mid-run).
+ * - `stamp-declined`  — same, caught by the stamp op's own re-check.
+ *
+ * Degraded (something is wrong; see {@link isDegradedTopicSkip}):
+ * - `llm-unanswered`  — the batch failed or the model omitted this id. THE one
+ *                       to alarm on: it is how a wholly broken sweep looks.
+ * - `unreadable`      — the row could not be loaded/decrypted.
+ * - `not-found`       — the lookup threw (absent row or read fault).
+ * - `link-failed`     — the entity-link write threw.
+ *
+ * @public
+ */
+type TopicSkipReason = "excluded" | "link-declined" | "stamp-declined" | "llm-unanswered" | "unreadable" | "not-found" | "link-failed";
+/**
+ * Whether a skip reason means the sweep FAILED on that row, rather than
+ * deliberately passing over it.
+ *
+ * Exported so callers classify identically instead of each re-deriving the
+ * split — the reason this type exists is that one wrong grouping turns a broken
+ * sweep back into a healthy-looking one.
+ *
+ * @public
+ */
+declare function isDegradedTopicSkip(reason: TopicSkipReason): boolean;
+/** Outcome of one {@link extractAndLinkEntitiesForMemoriesOp} run. */
+interface TopicExtractionRunResult {
+    /** memoryId → entities the LLM returned (post-validation, post-linking). */
+    entitiesByMemory: Map<string, ExtractedEntity[]>;
+    /** Memories stamped `topics_extracted_at` this run — includes zero-entity
+     * results so quiet memories aren't re-asked every sweep. */
+    stampedIds: string[];
+    /** Memories NOT processed: missing/deleted/foreign rows, user-managed rows
+     * (including ones that became user-managed mid-run), and members of failed
+     * LLM batches. Skipped ids are not stamped, so failed batches are retried
+     * by a later sweep — callers should apply their own attempt caps. */
+    skippedIds: string[];
+    /**
+     * Why each id in {@link skippedIds} was skipped.
+     *
+     * `skippedIds` alone cannot distinguish a sweep that deliberately declined
+     * work from one that FAILED: a run where every LLM batch errored and a run
+     * over rows the user has taken manual control of produce an identical array.
+     * That is the same blindness `outcome: 'empty-after-retry'` had before #888 —
+     * a degradation wearing the shape of normal control flow.
+     *
+     * It matters here because topics feed the entity recall lane, so a silently
+     * failing sweep means memories that exist but cannot be found by entity, with
+     * nothing in production saying so.
+     *
+     * Populated in lockstep with `skippedIds` (single `skip()` helper), so the two
+     * cannot drift. Group by {@link isDegradedTopicSkip} to separate "declined" from
+     * "broke".
+     */
+    skippedReasons: Map<string, TopicSkipReason>;
+}
+/**
+ * Run LLM topic extraction over existing vault memories and persist the
+ * results: REPLACE each memory's auto-managed entity links with the extracted
+ * set (via {@link replaceMemoryEntitiesGuardedOp} — an edited memory drops the
+ * entities its previous content mentioned) and stamp `topics_extracted_at`.
+ *
+ * User intent is enforced twice: rows already user-managed are skipped up
+ * front, and the replace write re-checks the vault row INSIDE its writer
+ * (user-managed / deleted / absent ⇒ null, and the memory is neither linked
+ * nor stamped) so a manual topic edit or delete landing during the LLM
+ * round-trip wins — a manual edit's own replace semantics also erase anything
+ * this pass linked just before it. The watermark is captured BEFORE contents
+ * are read: an edit landing mid-run keeps `updated_at` > stamp, so the next
+ * sweep re-extracts it rather than trusting this run's stale read.
+ *
+ * Requires `ctx.entityCtx`. Contents are decrypted via the ctx's wallet
+ * fields, exactly like the vault read ops; a memory whose decryption fails is
+ * skipped (retried next sweep), not fatal to the run.
+ *
+ * @deprecated App code: use `MemoryStore.maintenance.extractTopics` (`createLocalMemoryStore`).
+ */
+declare function extractAndLinkEntitiesForMemoriesOp(ctx: VaultMemoryOperationsContext, memoryIds: readonly string[], options: TopicExtractOptions & {
+    /** Watermark timestamp (Unix ms) recorded as `topics_extracted_at`.
+     * Defaults to now; tests pass a fixed value. */
+    now?: number;
+}): Promise<TopicExtractionRunResult>;
+
+/**
+ * Read filter for {@link MemoryStore.list}. Same semantics as the vault read
+ * ops: every non-visible state (deleted, archived, quarantined, superseded) is
+ * hidden by default and has its own opt-in flag.
+ * @public
+ */
+interface MemoryListOptions {
+    scopes?: string[];
+    /** Only memories updated after this instant (results then sort by `updatedAt`). */
+    since?: Date;
+    limit?: number;
+    /** Restrict to these ids. Absent or foreign ids are dropped, never an error. */
+    memoryIds?: string[];
+    factTypes?: string[];
+    /** People Nearby visibility filter; a legacy NULL column reads as "private". */
+    visibility?: VaultMemoryVisibility[];
+    /** Memory Graph "forgotten" nodes — rows carry `isDeleted: true`. */
+    includeDeleted?: boolean;
+    includeArchived?: boolean;
+    includeQuarantined?: boolean;
+    /** Memory history — rows carry `supersededBy`. */
+    includeSuperseded?: boolean;
+}
+/**
+ * A manual memory save. Creation uses private visibility, manual provenance
+ * and a proof count of one. Missing embeddings are filled in the background.
+ * Publication uses `setVisibility`; extraction uses `retain`. Migration and
+ * restore use the dedicated lower-level vault/import operations rather than
+ * passing provenance, trust or publication metadata through manual creation.
+ * @public
+ */
+type MemoryCreate = Pick<CreateVaultMemoryOptions, "content" | "scope" | "factType" | "eventTime" | "embedding" | "embeddingModel" | "geohash">;
+/**
+ * The edits an app makes to an existing memory. Deliberately narrower than
+ * {@link UpdateVaultMemoryOptions}: the re-observation knobs (`proofCountIncrement`,
+ * `observationSourceIds`, `preserveUpdatedAt`, `restore`, `lastObservedAt`, …)
+ * belong to `retain()` and backup sync, and an HTTP backend should never have
+ * to accept them from a client. No `folderId` either: vault folders are gone
+ * from the server surface (they leaked across tenants), so a remote backend
+ * could not honour it.
+ *
+ * Omitting `embedding` drops the stored vector (and its model tag) and the
+ * store re-embeds the new content in the background — useChatStorage's edit
+ * behaviour, so an edit never keeps a vector for text that is gone. Pass
+ * `embedding` (with `embeddingModel`) only when you already have the new one.
+ * @public
+ */
+type MemoryUpdate = Pick<UpdateVaultMemoryOptions, "content" | "scope" | "factType" | "eventTime" | "embedding" | "embeddingModel">;
+/**
+ * Fact-only recall. Conversation chunks are message storage, not memory, so
+ * the chunk-lane knobs are not part of this surface; nor is `folderId` (see
+ * {@link MemoryUpdate}).
+ *
+ * DEVICE-LOCAL: `decomposeOptions` (portal credentials) and `onDiagnostics` (a
+ * callback) configure work on the device, including with a remote store.
+ * Query embedding/decomposition and the decrypted recall pipeline stay on the
+ * device. Nearby ranks encrypted rows using embeddings and metadata; credentials
+ * and callbacks are never forwarded to it.
+ * @public
+ */
+type MemoryRecallOptions = Omit<RecallOptions, "types" | "includeChunks" | "conversationId" | "excludeConversationId" | "folderId">;
+/**
+ * `retain()` options minus `folderId` (see {@link MemoryUpdate}).
+ *
+ * DEVICE-LOCAL: `consolidateOptions` carries portal credentials, an `onFallback`
+ * callback and possibly a `PiiRedactor` instance — it configures the
+ * consolidation LLM call on the device. A remote store fetches encrypted
+ * candidates, decrypts and consolidates them on the device, then persists
+ * encrypted results through versioned writes. Nearby holds no decryption key
+ * and never receives these credentials, callbacks or redactor instances.
+ * @public
+ */
+type MemoryRetainOptions = Omit<RetainOptions, "folderId">;
+/** @public */
+interface MemorySubscribeOptions {
+    /**
+     * Watch the whole table, soft-deleted rows included, and fire on row-SET
+     * changes only (create / delete / undelete) — the Memory Graph's mode. A
+     * column-aware watch would re-fire on every row a decay sweep archives.
+     * Default `false`: watch live rows for user-visible edits and list membership
+     * changes. Background embedding, proof and watermark bookkeeping does not
+     * trigger default notifications.
+     */
+    includeDeleted?: boolean;
+    /** Also fire when topic (entity / link) state changes. Default `false`. */
+    topics?: boolean;
+    /**
+     * Also fire for embedding vector/model changes. Default `false`.
+     * Ignored when `includeDeleted` is `true`, which remains membership-only.
+     */
+    embeddings?: boolean;
+}
+/**
+ * Background jobs that keep a LOCAL store healthy.
+ *
+ * TRANSITIONAL local-vault plumbing. A remote store may omit these hooks, but
+ * their absence does not mean plaintext-dependent work moves to nearby.
+ * Topic extraction and other jobs that need decrypted memory content remain
+ * on the device and persist encrypted rows/metadata through the remote store.
+ * Metadata-only maintenance can run server-side. Nothing here should gain a
+ * new caller that isn't a background worker.
+ *
+ * Not here on purpose: the client's quality sweep (`list` + `delete`) and
+ * folder→topic migration (`list` + `topicsByMemories` + `addTopics`) compose
+ * from the main interface.
+ * @public
+ */
+interface MemoryMaintenance {
+    /** Decay sweeper bound to this store's vault (see `createDecaySweeper`). */
+    createDecaySweeper(options?: Omit<CreateDecaySweeperOptions, "vaultCtx">): DecaySweeper;
+    /** One page of the topic-extraction backlog (see `getMemoriesNeedingTopicExtractionOp`). */
+    getTopicBacklog(options?: {
+        limit?: number;
+    }): Promise<MemoriesNeedingTopicExtraction>;
+    /** LLM topic extraction + link + stamp for these memories. */
+    extractTopics(memoryIds: readonly string[], options: TopicExtractOptions & {
+        now?: number;
+    }): Promise<TopicExtractionRunResult>;
+    /** Grandfather already-linked rows without an LLM call. Returns the ids stamped. */
+    stampTopicsExtracted(memoryIds: readonly string[], extractedAt: number, version?: number): Promise<string[]>;
+    /** Rebuild the local link index from each row's synced `topics`. Returns the ids relinked. */
+    relinkTopics(memoryIds: readonly string[]): Promise<string[]>;
+    /** Fill `topics` on pre-v42 rows from their existing links. Returns the ids filled. */
+    backfillTopics(memoryIds: readonly string[]): Promise<string[]>;
+}
+/**
+ * One user's memories, pitched at what the apps do with them rather than at
+ * the storage ops underneath. Two backends are intended: the on-device
+ * WatermelonDB vault ({@link createLocalMemoryStore}) and, later, an HTTP
+ * client for the server-side store.
+ *
+ * Every value crossing this interface is plain data — no WatermelonDB Model,
+ * Query or Collection — so a remote backend can serialize it. The one
+ * exception is the DEVICE-LOCAL LLM-call knobs on {@link MemoryRecallOptions}
+ * and {@link MemoryRetainOptions}, which a remote store uses on the device
+ * rather than forwarding to nearby. Server persistence is authoritative;
+ * content decryption and plaintext-dependent processing remain on the device. Reads are
+ * whole-result rather than per-row so a chat turn costs a handful of calls
+ * (`recall`, then `retain` per fact), not one per memory.
+ *
+ * Writes resolve `null` / `false` for a memory that is missing, deleted or
+ * not owned by this store's user; they don't throw for it.
+ * @public
+ */
+interface MemoryStore {
+    /** Memories newest-first, decrypted, WITH `embedding` (Memory Graph edges read it). */
+    list(options?: MemoryListOptions): Promise<StoredVaultMemory[]>;
+    get(id: string): Promise<StoredVaultMemory | null>;
+    /** Decay-archived memories (not deleted, quarantined or superseded), most recently archived first. */
+    listArchived(): Promise<StoredVaultMemory[]>;
+    /** Memory id → which of `names` it is linked to. Names are matched case-insensitively. */
+    memoriesByTopics(names: readonly string[]): Promise<Map<string, Set<string>>>;
+    /** Memory id → its canonical (lowercased) topic names. Unlinked ids are absent. */
+    topicsByMemories(memoryIds: readonly string[]): Promise<Map<string, Set<string>>>;
+    /** Manual save; missing embeddings are filled in the background. */
+    create(input: MemoryCreate): Promise<StoredVaultMemory>;
+    /** One write for a batch of manual saves; migration/restore uses lower-level operations. */
+    createMany(inputs: MemoryCreate[]): Promise<StoredVaultMemory[]>;
+    update(id: string, patch: MemoryUpdate): Promise<StoredVaultMemory | null>;
+    /** Soft delete; also drops the memory's topic links. */
+    delete(id: string): Promise<boolean>;
+    /** Retire `id` behind the newer `supersededById` (both must be live and owned). */
+    supersede(id: string, supersededById: string): Promise<boolean>;
+    archive(id: string): Promise<boolean>;
+    restore(id: string): Promise<boolean>;
+    /** Replace the memory's topics with a user-chosen set and stop auto-tagging it. */
+    setTopics(memoryId: string, topics: readonly EntityInput[]): Promise<StoredVaultMemory | null>;
+    /** Add topics alongside the existing ones (auto-tagging stays on). */
+    addTopics(memoryId: string, topics: readonly EntityInput[]): Promise<StoredEntity[]>;
+    setVisibility(id: string, visibility: VaultMemoryVisibility, options?: {
+        twinOptIn?: boolean;
+    }): Promise<StoredVaultMemory | null>;
+    recall(query: string, options?: MemoryRecallOptions): Promise<RecallResult>;
+    retain(content: string, options?: MemoryRetainOptions): Promise<RetainResult>;
+    /**
+     * Call `onChange` after the store's memories change; re-read to see what
+     * changed. Does not fire for the state at subscription time — read once
+     * after subscribing. Returns the unsubscribe function.
+     */
+    subscribe(onChange: () => void, options?: MemorySubscribeOptions): () => void;
+    /** TRANSITIONAL — see {@link MemoryMaintenance}. Absent on a remote backend. */
+    maintenance?: MemoryMaintenance;
+}
+
+/** @public */
+interface LocalMemoryStoreOptions {
+    /** A database built from `sdkSchema` (memory_vault + entity + memory_entity). */
+    database: Database;
+    /** With `signMessage`, encrypts content on write and decrypts on read. */
+    walletAddress?: string;
+    signMessage?: SignMessageFn;
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+    /**
+     * Scope every read/write to this user — for a shared, multi-tenant database
+     * whose rows all carry their `user_id`. Rows with no `user_id` are invisible
+     * to a scoped store, so the per-wallet client DBs (every useChatStorage row is
+     * `user_id = null`) use `singleTenant` instead, exactly like useChatStorage's
+     * vault ctx.
+     */
+    userId?: string;
+    /**
+     * The database holds exactly one owner's rows (the per-wallet client DBs).
+     * Required for the decay sweep to run without `userId` — see
+     * `VaultMemoryOperationsContext.singleTenant`.
+     */
+    singleTenant?: boolean;
+    /** Admit pre-v31 `user_id = null` link rows alongside `userId`'s (LokiJS web). */
+    allowUnscopedRows?: boolean;
+    /** Embedding API options for `recall` / `retain`. */
+    embeddingOptions: EmbeddingOptions;
+    /** Share a warm cache with other recall surfaces; one is created when omitted. */
+    vaultCache?: VaultEmbeddingCache;
+}
+/**
+ * {@link MemoryStore} over the on-device WatermelonDB vault. Builds the vault +
+ * entity contexts once and delegates every method to the existing ops, so
+ * behavior is exactly theirs.
+ * @public
+ */
+declare function createLocalMemoryStore(options: LocalMemoryStoreOptions): MemoryStore;
+
 /**
  * synthesizeProfile — client-side profile synthesis for People Nearby (C1).
  *
@@ -9131,174 +9563,6 @@ interface SynthesizeProfileOptions extends PortalLlmAuth {
  */
 declare function synthesizeProfile(ctx: RecallContext, options?: SynthesizeProfileOptions): Promise<ProfileDoc>;
 
-/**
- * Standalone topic (entity) extraction for EXISTING memories.
- *
- * The conversation pipeline (autoExtract.ts) assigns entities only to facts it
- * extracts from a live transcript — manually created, imported, and edited
- * memories never get LLM topics and used to fall back to a client-side regex.
- * This module is the LLM half of "continuously LLM-managed topics": a batched
- * pass that takes memories already in the vault, asks the extraction model for
- * their named entities, REPLACES their auto-managed links (guarded — a manual
- * edit or delete always wins), and stamps `topics_extracted_at` so the sweep
- * query (`getMemoriesNeedingTopicExtractionOp`) only revisits edited memories.
- *
- * Batching: memories are classified ~10 per LLM call (mirroring the folder
- * Auto-Sort harness) with per-memory content truncation, so a whole-vault
- * backfill or a bulk import costs ceil(n/10) requests, not n.
- */
-
-/** Memories per LLM call. Mirrors the folder Auto-Sort batch size — the cost
- * lever that makes a whole-vault backfill viable. */
-declare const TOPIC_EXTRACTION_BATCH_SIZE = 10;
-/** One memory to extract topics for. `content` must be the DECRYPTED text. */
-interface TopicExtractionInput {
-    id: string;
-    content: string;
-}
-/**
- * Options for the topic-extraction LLM call. Auth follows the portal dual
- * pattern — one of `apiKey` / `getToken` is required (see {@link PortalLlmAuth}).
- */
-interface TopicExtractOptions extends PortalLlmAuth {
-    baseUrl?: string;
-    /**
-     * Optional per-call request path override, forwarded to
-     * {@link callPortalJsonCompletion}. When set, topic extraction POSTs to
-     * `baseUrl + endpointOverride` instead of the default
-     * `/api/v1/chat/completions`. The body follows the transport, not the path: a
-     * model that needs the Responses API is moved from a `.../chat/completions`
-     * override to its sibling `.../responses` with a Responses-shaped body. Lets callers route
-     * this internal-utility pass to a dedicated endpoint. Invalid values throw at
-     * call time (see {@link validateEndpointOverride}).
-     */
-    endpointOverride?: string;
-    /** Defaults to {@link DEFAULT_EXTRACTION_MODEL} — the sanctioned extraction
-     * model. Don't point this at a second model without an eval. */
-    model?: string;
-    /** Override the global fetch implementation (useful for tests). */
-    fetchFn?: typeof fetch;
-    maxAttempts?: number;
-    timeoutMs?: number;
-    totalTimeoutMs?: number;
-    backoffMs?: (attempt: number) => number;
-    /**
-     * The user's existing entity vocabulary (canonical names). Included in the
-     * prompt so independent batches reuse canonical names instead of fragmenting
-     * ("ZetaChain" / "Zetachain" / "zeta chain" as three graph nodes). Truncated
-     * to the first {@link MAX_VOCABULARY_NAMES} names — pass the most-linked
-     * names first.
-     */
-    existingEntityNames?: readonly string[];
-    /**
-     * When set, PII in memory contents is replaced with tagged placeholders
-     * before the LLM call and returned entity names are de-anonymized (entities
-     * whose placeholders can't be restored are dropped) — mirrors
-     * `ExtractFactsOptions.piiRedaction`. Vault contents hold REAL values, so
-     * callers that redact the conversation pipeline must redact this pass too.
-     */
-    piiRedaction?: boolean | PiiRedactor;
-}
-/**
- * Ask the extraction LLM for the named entities of each memory, in batches of
- * {@link TOPIC_EXTRACTION_BATCH_SIZE}. Pure LLM step — no persistence.
- *
- * Returns memoryId → entities. A memory PRESENT with an empty array is a
- * successful, explicit "no named entities" answer; a memory ABSENT from the
- * map is UNANSWERED — its batch failed after retries, returned an unusable
- * shape, or the model omitted its id. Callers must retry absent ids in a
- * later sweep, never stamp them.
- */
-declare function extractEntitiesForMemories(memories: readonly TopicExtractionInput[], options: TopicExtractOptions): Promise<Map<string, ExtractedEntity[]>>;
-/**
- * Why one memory was skipped by a topic sweep.
- *
- * Split along the line that actually matters operationally — did the sweep
- * DECLINE this row on purpose, or did something BREAK:
- *
- * Deliberate (healthy; a sweep of nothing but these is a success):
- * - `excluded`        — deleted, owned by another user, or `topicsUserManaged`.
- * - `link-declined`   — the entity-link write's in-row guard declined (the row
- *                       became user-managed / deleted / absent mid-run).
- * - `stamp-declined`  — same, caught by the stamp op's own re-check.
- *
- * Degraded (something is wrong; see {@link isDegradedTopicSkip}):
- * - `llm-unanswered`  — the batch failed or the model omitted this id. THE one
- *                       to alarm on: it is how a wholly broken sweep looks.
- * - `unreadable`      — the row could not be loaded/decrypted.
- * - `not-found`       — the lookup threw (absent row or read fault).
- * - `link-failed`     — the entity-link write threw.
- *
- * @public
- */
-type TopicSkipReason = "excluded" | "link-declined" | "stamp-declined" | "llm-unanswered" | "unreadable" | "not-found" | "link-failed";
-/**
- * Whether a skip reason means the sweep FAILED on that row, rather than
- * deliberately passing over it.
- *
- * Exported so callers classify identically instead of each re-deriving the
- * split — the reason this type exists is that one wrong grouping turns a broken
- * sweep back into a healthy-looking one.
- *
- * @public
- */
-declare function isDegradedTopicSkip(reason: TopicSkipReason): boolean;
-/** Outcome of one {@link extractAndLinkEntitiesForMemoriesOp} run. */
-interface TopicExtractionRunResult {
-    /** memoryId → entities the LLM returned (post-validation, post-linking). */
-    entitiesByMemory: Map<string, ExtractedEntity[]>;
-    /** Memories stamped `topics_extracted_at` this run — includes zero-entity
-     * results so quiet memories aren't re-asked every sweep. */
-    stampedIds: string[];
-    /** Memories NOT processed: missing/deleted/foreign rows, user-managed rows
-     * (including ones that became user-managed mid-run), and members of failed
-     * LLM batches. Skipped ids are not stamped, so failed batches are retried
-     * by a later sweep — callers should apply their own attempt caps. */
-    skippedIds: string[];
-    /**
-     * Why each id in {@link skippedIds} was skipped.
-     *
-     * `skippedIds` alone cannot distinguish a sweep that deliberately declined
-     * work from one that FAILED: a run where every LLM batch errored and a run
-     * over rows the user has taken manual control of produce an identical array.
-     * That is the same blindness `outcome: 'empty-after-retry'` had before #888 —
-     * a degradation wearing the shape of normal control flow.
-     *
-     * It matters here because topics feed the entity recall lane, so a silently
-     * failing sweep means memories that exist but cannot be found by entity, with
-     * nothing in production saying so.
-     *
-     * Populated in lockstep with `skippedIds` (single `skip()` helper), so the two
-     * cannot drift. Group by {@link isDegradedTopicSkip} to separate "declined" from
-     * "broke".
-     */
-    skippedReasons: Map<string, TopicSkipReason>;
-}
-/**
- * Run LLM topic extraction over existing vault memories and persist the
- * results: REPLACE each memory's auto-managed entity links with the extracted
- * set (via {@link replaceMemoryEntitiesGuardedOp} — an edited memory drops the
- * entities its previous content mentioned) and stamp `topics_extracted_at`.
- *
- * User intent is enforced twice: rows already user-managed are skipped up
- * front, and the replace write re-checks the vault row INSIDE its writer
- * (user-managed / deleted / absent ⇒ null, and the memory is neither linked
- * nor stamped) so a manual topic edit or delete landing during the LLM
- * round-trip wins — a manual edit's own replace semantics also erase anything
- * this pass linked just before it. The watermark is captured BEFORE contents
- * are read: an edit landing mid-run keeps `updated_at` > stamp, so the next
- * sweep re-extracts it rather than trusting this run's stale read.
- *
- * Requires `ctx.entityCtx`. Contents are decrypted via the ctx's wallet
- * fields, exactly like the vault read ops; a memory whose decryption fails is
- * skipped (retried next sweep), not fatal to the run.
- */
-declare function extractAndLinkEntitiesForMemoriesOp(ctx: VaultMemoryOperationsContext, memoryIds: readonly string[], options: TopicExtractOptions & {
-    /** Watermark timestamp (Unix ms) recorded as `topics_extracted_at`.
-     * Defaults to now; tests pass a fixed value. */
-    now?: number;
-}): Promise<TopicExtractionRunResult>;
-
 /**
  * Post-hoc support verification for extracted memories (#707).
  *
@@ -11401,4 +11665,4 @@ declare function createNotionTools(getAccessToken: () => string | null, requestN
  */
 declare function createNotionProxyTools(callMcp: NotionMcpCaller): ToolConfig[];
 
-export { type AutoExtractMessage, type AutoExtractor, type Budget, CHUNKS_DISCARDED_ORIGIN, type CachedChunkVectors, type CachedServerTools, Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type ChunkVectorCache, type ChunkingOptions, type ConsolidationAction, type ConsolidationFallbackReason, type ConversationMemoryInput, ConversationMemory as ConversationMemoryModel, type ConversationMemoryOperationsContext, type CreateAutoExtractorOptions, type CreateConversationOptions, type CreateDecaySweeperOptions, type CreateMessageOptions, type CreateVaultFolderOptions, type CreateVaultMemoryOptions, type CryptoPriceClassification, type CryptoPricePreProcessorOptions, DEFAULT_CACHE_EXPIRATION_MS, DEFAULT_CHUNK_CACHE_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_DECAY_POLICY, DEFAULT_MAX_CLASSIFIER_CALLS_PER_SWEEP, DEFAULT_MIN_CHUNK_SIZE, DEFAULT_PROFILE_FACETS, DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, DEFAULT_PROFILE_PROOF_ALPHA, DEFAULT_PROFILE_TREND_MULTIPLIERS, DEFAULT_VAULT_CACHE_SIZE, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type DecayCandidateRaw, type DecayClassifier, type DecayInput, type DecayPolicy, type DecaySweepResult, type DecaySweeper, type DecayVerdict, type DurableAutoExtractorOptions, ENTITY_FANOUT, type EmbeddedWalletSignerFn, EncryptionKeyMissingError, type ExtractFactsOptions, type ExtractOutcome, type ExtractedCandidate, type ExtractedEntity, type ExtractionCursorStore, type ExtractionFunnel, type ExtractionTimings, type FactType, type FileMetadata, type FileProcessingReason, type FileProcessingStatus, type FlushResult, type GetConversationsPageOptions, type GetMessagesPageOptions, type GraphTraversalOptions, HARD_DELETE_WINDOW_MS, INFERENCE_ID_HEADER, type InjectionClassifierOptions, type InjectionReason, type LazyStoredConversation, type LlmDecayClassifierOptions, type LlmNeighborRefinerOptions, type Logger, LoggerProvider, type LoggerProviderProps, MAX_HOPS, MEDIUM_TTL_MS, type ManualFactType, type MemoriesNeedingTopicExtraction, type MemoryContextItem, type MemoryContextLane, type MemoryContextOptions, type MemoryContextResult, type EmbeddingOptions as MemoryEngineEmbeddingOptions, type MemoryEngineResult, type MemoryEngineSearchOptions, type MemoryExtractedEvent, type MemoryKind, type MemoryQuarantinedEvent, type MemoryToVerify, type MemoryVaultSearchOptions, type MemoryVaultToolOptions, type MemoryVerification, type MessageRedactionResult, type MessageSkeleton, NEVER_TTL_MS, NODE_BUDGET, NOTION_OAUTH_CONFIG, type NeighborRefiner, type NotionAuthUrlParams, type NotionClientRegistration, type NotionExchangeCodeParams, type NotionMcpCaller, type NotionOAuthEndpoints, type NotionPKCEChallenge, type NotionRefreshTokenParams, type NotionTokenResponse, type NowSource, type ObservationTrend, type ObservationTrendInput, PAST_EVENT_GRACE_MS, PII_PATTERNS, PROFILE_DOC_VERSION, type PhotoIngestResult, type PhotoMediaRef, type PiiCategory, type PiiMatch, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PlatformStorage, type PortalLlmAuth, type PortalLlmFailure, type PortalLlmFailureReason, type ProfileConfigFingerprint, type ProfileDoc, type ProfileFacet, type ProfileFacetKey, type ProfileSalienceInput, type ProfileSection, type PromptPreProcessor, type PromptPreProcessorContext, type PublishedPhotoMemory, type QuantizedEmbedding, type QuarantinedMemoryInfo, QueueManager, type QueueStatus, RECALL_MAX_LIMIT, RECALL_TOOL_NAME, type RankableVaultMemory, type RankedMemory, type RankedProfileCandidate, type RecallContext, type RecallDegradation, type RecallDiagnostics, type RecallEmptyReason, type RecallOptions, type RecallResult, type RecallToolCallbacks, type RecallToolOptions, type RecencyOptions, type RedactionResult, type ReflectOptions, type ReflectResult, type RequestEncryptionKeyOptions, RerankerUnavailableError, type ResumeStreamOptions, type ResumeStreamResult, type ResumeStreamWithStorageResult, type RetainAction, type RetainContext, type RetainOptions, type RetainResult, type RetainSource, SDK_SCHEMA_VERSION, SHORT_TTL_MS, STREAM_RESUMABLE_HEADER, type ScoreBreakdown, type ScoreProfileSalienceOptions, type ScreenResult, type ScreenedCandidate, type SearchSource, type SendMessageWithStorageArgs, type SendMessageWithStorageDetachedResult, type SendMessageWithStorageResult, type ServerToolsOptions, type ServerToolsResponse, type SignMessageFn, type StockPriceClassification, type StockPricePreProcessorOptions, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredConversationMemory, type StoredMessage, type StoredMessageWithSimilarity, type StoredVaultFolder, VaultFolder as StoredVaultFolderModel, type StoredVaultMemory, VaultMemory as StoredVaultMemoryModel, StreamExpiredError, type StreamMetaEvent, type StreamResumeHandle, type StreamSmoothingConfig, type SynthesizeProfileOptions, TOOL_RESULT_ORIGIN, TOPICS_EXTRACTION_VERSION, TOPIC_EXTRACTION_BATCH_SIZE, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS, type TextChunk, type TopicExtractOptions, type TopicExtractionInput, type TopicExtractionRunResult, type TopicSkipReason, type TurnCompleteEvent, type TurnSkippedEvent, type UncheckedReason, type UnverifiableReason, type UpdateVaultFolderOptions, type UpdateVaultMemoryOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseModelsOptions, type UseModelsResult, VAULT_SIZE_HOP_CAP, type VaultEmbeddingCache, type VaultEmbeddingExpectation, type VaultFolderOperationsContext, type VaultMemoryOperationsContext, type VaultMemoryVisibility, type VaultMemoryWriter, type VaultSaveOperation, type VaultSearchResult, type VaultWriteAction, type VaultWriteInput, type VaultWriteOutcome, type VerificationSources, type VerifyMemoriesForPublishOptions, WalletPoller, type WeatherClassification, type WeatherPreProcessorOptions, type WebSearchClassification, type WebSearchPreProcessorOptions, addConversationMemoriesOp, archiveVaultMemoryOp, assembleMemoryContext, attachFileContextToLastUserMessage, backfillMemoryTopicsOp, buildAttachedFilesText, buildNotionAuthUrl, capHopsForDensity, chatStorageMigrations, chatStorageSchema, chunkAndEmbedAllMessages, chunkAndEmbedMessage, chunkText, classifyCryptoPrice, classifyCryptoPriceBatch, classifyDecay, classifyInjectionCandidates, classifyObservationTrend, classifyStockPrice, classifyStockPriceBatch, classifyWeather, classifyWeatherBatch, classifyWebSearch, classifyWebSearchBatch, clearAllEncryptionKeys, clearAllEncryptionState, clearConversationMemoriesOp, clearEncryptionKey, clearLazyTitleCache, clearServerToolsCache, consoleLogger, conversationMemoryToStored, cosineInt8, createAutoExtractor, createChunkVectorCache, createCryptoPricePreProcessor, createDecaySweeper, createDurableAutoExtractor, createLlmDecayClassifier, createLlmNeighborRefiner, createMemoryEngineTool, createMemoryVaultSearchTool, createMemoryVaultTool, createMessageSourceResolver, createNotionProxyTools, createNotionTools, createPlatformCursorStore, createRecallTool, createStockPricePreProcessor, createStreamingDeAnonymizer, createVaultEmbeddingCache, createVaultFolderOp, createVaultMemoriesBatchOp, createVaultMemoryOp, createWeatherPreProcessor, createWebSearchPreProcessor, decodeChunkVector, decryptConversationTitle, deleteAllVaultMemoriesForUserOp, deleteMessageOp, deleteVaultFolderOp, deleteVaultMemoryOp, dequantizeEmbedding, deriveKeyFromSignatureBytes, discoverNotionOAuthEndpoints, eagerEmbedContent, embedAllMessages, embedMessage, encodeChunkVector, ensureDefaultFoldersOp, exchangeNotionCode, extractAndLinkEntitiesForMemoriesOp, extractAndRetain, extractEntitiesForMemories, extractFacts, formatFileProcessingNotes, generateConversationId, generateEmbedding, generateEmbeddings, generateNotionPKCE, getAllVaultFoldersOp, getAllVaultMemoriesOp, getAllVaultMemoryContentsOp, getCachedServerTools, getConversationMemoriesOp, getConversationsByProjectLazyOp, getConversationsLazyOp, getConversationsPageOp, getDecayCandidatesRawOp, getLogger, getMemoriesNeedingTopicExtractionOp, getServerTools, getUnfiledVaultMemoriesOp, getVaultFolderMemoryCountOp, getVaultMemoriesByIdsOp, getVaultMemoryOp, getVaultRankingProjectionsOp, hardDeleteDecayedOp, hasEncryptionKey, ingestPublishedPhotoMemoriesOp, injectionSignatureCatalog, isAttachedFilesText, isDegradedTopicSkip, isEncrypted, isPiiRedactor, isRerankerAvailable, maskScopedEmbeddingCache, moveMemoriesToFolderOp, noopLogger, onKeyAvailable, parseMedia, preEmbedVaultMemories, quantizeEmbedding, queueManager, rankProfileCandidates, recall, reflect, refreshEncryptionKeyIfMatches, refreshNotionAccessToken, registerNotionClient, relinkMemoryTopicsOp, requestEncryptionKey, resolvePiiRedactor, restoreVaultMemoryOp, resumeStream, retain, scoreProfileSalience, screenCandidatesForInjection, sdkMigrations, sdkModelClasses, sdkSchema, searchVaultMemories, seedEncryptionKeys, setLogger, setMemoryVisibilityOp, shouldChunkMessage, shouldRecallMemory, stampTopicsExtractedAtOp, streamCancelPath, streamReplayPath, stripLegacyChunkTextOp, summarizeObservationTrends, supersedeVaultMemoryOp, synthesizeProfile, traverseGraphLane, ttlForType, updateVaultFolderContextOp, updateVaultFolderOp, updateVaultMemoryEmbeddingOp, updateVaultMemoryOp, upsertMessageOp, useChat, useChatStorage, useCredits, useEncryption, useModels, verifyMemoriesForPublish, xhrTransport };
+export { type AutoExtractMessage, type AutoExtractor, type Budget, CHUNKS_DISCARDED_ORIGIN, type CachedChunkVectors, type CachedServerTools, Conversation as ChatConversation, Message as ChatMessage, type ChatRole, type ChunkVectorCache, type ChunkingOptions, type ConsolidationAction, type ConsolidationFallbackReason, type ConversationMemoryInput, ConversationMemory as ConversationMemoryModel, type ConversationMemoryOperationsContext, type CreateAutoExtractorOptions, type CreateConversationOptions, type CreateDecaySweeperOptions, type CreateMessageOptions, type CreateVaultFolderOptions, type CreateVaultMemoryOptions, type CryptoPriceClassification, type CryptoPricePreProcessorOptions, DEFAULT_CACHE_EXPIRATION_MS, DEFAULT_CHUNK_CACHE_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_DECAY_POLICY, DEFAULT_MAX_CLASSIFIER_CALLS_PER_SWEEP, DEFAULT_MIN_CHUNK_SIZE, DEFAULT_PROFILE_FACETS, DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, DEFAULT_PROFILE_PROOF_ALPHA, DEFAULT_PROFILE_TREND_MULTIPLIERS, DEFAULT_VAULT_CACHE_SIZE, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type DecayCandidateRaw, type DecayClassifier, type DecayInput, type DecayPolicy, type DecaySweepResult, type DecaySweeper, type DecayVerdict, type DurableAutoExtractorOptions, ENTITY_FANOUT, type EmbeddedWalletSignerFn, EncryptionKeyMissingError, type ExtractFactsOptions, type ExtractOutcome, type ExtractedCandidate, type ExtractedEntity, type ExtractionCursorStore, type ExtractionFunnel, type ExtractionTimings, type FactType, type FileMetadata, type FileProcessingReason, type FileProcessingStatus, type FlushResult, type GetConversationsPageOptions, type GetMessagesPageOptions, type GraphTraversalOptions, HARD_DELETE_WINDOW_MS, INFERENCE_ID_HEADER, type InjectionClassifierOptions, type InjectionReason, type LazyStoredConversation, type LlmDecayClassifierOptions, type LlmNeighborRefinerOptions, type LocalMemoryStoreOptions, type Logger, LoggerProvider, type LoggerProviderProps, MAX_HOPS, MEDIUM_TTL_MS, type ManualFactType, type MemoriesNeedingTopicExtraction, type MemoryContextItem, type MemoryContextLane, type MemoryContextOptions, type MemoryContextResult, type MemoryCreate, type EmbeddingOptions as MemoryEngineEmbeddingOptions, type MemoryEngineResult, type MemoryEngineSearchOptions, type MemoryExtractedEvent, type MemoryKind, type MemoryListOptions, type MemoryMaintenance, type MemoryQuarantinedEvent, type MemoryRecallOptions, type MemoryRetainOptions, type MemoryStore, type MemorySubscribeOptions, type MemoryToVerify, type MemoryUpdate, type MemoryVaultSearchOptions, type MemoryVaultToolOptions, type MemoryVerification, type MessageRedactionResult, type MessageSkeleton, NEVER_TTL_MS, NODE_BUDGET, NOTION_OAUTH_CONFIG, type NeighborRefiner, type NotionAuthUrlParams, type NotionClientRegistration, type NotionExchangeCodeParams, type NotionMcpCaller, type NotionOAuthEndpoints, type NotionPKCEChallenge, type NotionRefreshTokenParams, type NotionTokenResponse, type NowSource, type ObservationTrend, type ObservationTrendInput, PAST_EVENT_GRACE_MS, PII_PATTERNS, PROFILE_DOC_VERSION, type PhotoIngestResult, type PhotoMediaRef, type PiiCategory, type PiiMatch, type PiiPattern, PiiRedactor, type PiiRedactorOptions, type PlatformStorage, type PortalLlmAuth, type PortalLlmFailure, type PortalLlmFailureReason, type ProfileConfigFingerprint, type ProfileDoc, type ProfileFacet, type ProfileFacetKey, type ProfileSalienceInput, type ProfileSection, type PromptPreProcessor, type PromptPreProcessorContext, type PublishedPhotoMemory, type QuantizedEmbedding, type QuarantinedMemoryInfo, QueueManager, type QueueStatus, RECALL_MAX_LIMIT, RECALL_TOOL_NAME, type RankableVaultMemory, type RankedMemory, type RankedProfileCandidate, type RecallContext, type RecallDegradation, type RecallDiagnostics, type RecallEmptyReason, type RecallOptions, type RecallResult, type RecallToolCallbacks, type RecallToolOptions, type RecencyOptions, type RedactionResult, type ReflectOptions, type ReflectResult, type RequestEncryptionKeyOptions, RerankerUnavailableError, type ResumeStreamOptions, type ResumeStreamResult, type ResumeStreamWithStorageResult, type RetainAction, type RetainContext, type RetainOptions, type RetainResult, type RetainSource, SDK_SCHEMA_VERSION, SHORT_TTL_MS, STREAM_RESUMABLE_HEADER, type ScoreBreakdown, type ScoreProfileSalienceOptions, type ScreenResult, type ScreenedCandidate, type SearchSource, type SendMessageWithStorageArgs, type SendMessageWithStorageDetachedResult, type SendMessageWithStorageResult, type ServerToolsOptions, type ServerToolsResponse, type SignMessageFn, type StockPriceClassification, type StockPricePreProcessorOptions, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredConversationMemory, type StoredMessage, type StoredMessageWithSimilarity, type StoredVaultFolder, VaultFolder as StoredVaultFolderModel, type StoredVaultMemory, VaultMemory as StoredVaultMemoryModel, StreamExpiredError, type StreamMetaEvent, type StreamResumeHandle, type StreamSmoothingConfig, type SynthesizeProfileOptions, TOOL_RESULT_ORIGIN, TOPICS_EXTRACTION_VERSION, TOPIC_EXTRACTION_BATCH_SIZE, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS, type TextChunk, type TopicExtractOptions, type TopicExtractionInput, type TopicExtractionRunResult, type TopicSkipReason, type TurnCompleteEvent, type TurnSkippedEvent, type UncheckedReason, type UnverifiableReason, type UpdateVaultFolderOptions, type UpdateVaultMemoryOptions, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseModelsOptions, type UseModelsResult, VAULT_SIZE_HOP_CAP, type VaultEmbeddingCache, type VaultEmbeddingExpectation, type VaultFolderOperationsContext, type VaultMemoryOperationsContext, type VaultMemoryVisibility, type VaultMemoryWriter, type VaultSaveOperation, type VaultSearchResult, type VaultWriteAction, type VaultWriteInput, type VaultWriteOutcome, type VerificationSources, type VerifyMemoriesForPublishOptions, WalletPoller, type WeatherClassification, type WeatherPreProcessorOptions, type WebSearchClassification, type WebSearchPreProcessorOptions, addConversationMemoriesOp, archiveVaultMemoryOp, assembleMemoryContext, attachFileContextToLastUserMessage, backfillMemoryTopicsOp, buildAttachedFilesText, buildNotionAuthUrl, capHopsForDensity, chatStorageMigrations, chatStorageSchema, chunkAndEmbedAllMessages, chunkAndEmbedMessage, chunkText, classifyCryptoPrice, classifyCryptoPriceBatch, classifyDecay, classifyInjectionCandidates, classifyObservationTrend, classifyStockPrice, classifyStockPriceBatch, classifyWeather, classifyWeatherBatch, classifyWebSearch, classifyWebSearchBatch, clearAllEncryptionKeys, clearAllEncryptionState, clearConversationMemoriesOp, clearEncryptionKey, clearLazyTitleCache, clearServerToolsCache, consoleLogger, conversationMemoryToStored, cosineInt8, createAutoExtractor, createChunkVectorCache, createCryptoPricePreProcessor, createDecaySweeper, createDurableAutoExtractor, createLlmDecayClassifier, createLlmNeighborRefiner, createLocalMemoryStore, createMemoryEngineTool, createMemoryVaultSearchTool, createMemoryVaultTool, createMessageSourceResolver, createNotionProxyTools, createNotionTools, createPlatformCursorStore, createRecallTool, createStockPricePreProcessor, createStreamingDeAnonymizer, createVaultEmbeddingCache, createVaultFolderOp, createVaultMemoriesBatchOp, createVaultMemoryOp, createWeatherPreProcessor, createWebSearchPreProcessor, decodeChunkVector, decryptConversationTitle, deleteAllVaultMemoriesForUserOp, deleteMessageOp, deleteVaultFolderOp, deleteVaultMemoryOp, dequantizeEmbedding, deriveKeyFromSignatureBytes, discoverNotionOAuthEndpoints, eagerEmbedContent, embedAllMessages, embedMessage, encodeChunkVector, ensureDefaultFoldersOp, exchangeNotionCode, extractAndLinkEntitiesForMemoriesOp, extractAndRetain, extractEntitiesForMemories, extractFacts, formatFileProcessingNotes, generateConversationId, generateEmbedding, generateEmbeddings, generateNotionPKCE, getAllVaultFoldersOp, getAllVaultMemoriesOp, getAllVaultMemoryContentsOp, getCachedServerTools, getConversationMemoriesOp, getConversationsByProjectLazyOp, getConversationsLazyOp, getConversationsPageOp, getDecayCandidatesRawOp, getLogger, getMemoriesNeedingTopicExtractionOp, getServerTools, getUnfiledVaultMemoriesOp, getVaultFolderMemoryCountOp, getVaultMemoriesByIdsOp, getVaultMemoryOp, getVaultRankingProjectionsOp, hardDeleteDecayedOp, hasEncryptionKey, ingestPublishedPhotoMemoriesOp, injectionSignatureCatalog, isAttachedFilesText, isDegradedTopicSkip, isEncrypted, isPiiRedactor, isRerankerAvailable, maskScopedEmbeddingCache, moveMemoriesToFolderOp, noopLogger, onKeyAvailable, parseMedia, preEmbedVaultMemories, quantizeEmbedding, queueManager, rankProfileCandidates, recall, reflect, refreshEncryptionKeyIfMatches, refreshNotionAccessToken, registerNotionClient, relinkMemoryTopicsOp, requestEncryptionKey, resolvePiiRedactor, restoreVaultMemoryOp, resumeStream, retain, scoreProfileSalience, screenCandidatesForInjection, sdkMigrations, sdkModelClasses, sdkSchema, searchVaultMemories, seedEncryptionKeys, setLogger, setMemoryVisibilityOp, shouldChunkMessage, shouldRecallMemory, stampTopicsExtractedAtOp, streamCancelPath, streamReplayPath, stripLegacyChunkTextOp, summarizeObservationTrends, supersedeVaultMemoryOp, synthesizeProfile, traverseGraphLane, ttlForType, updateVaultFolderContextOp, updateVaultFolderOp, updateVaultMemoryEmbeddingOp, updateVaultMemoryOp, upsertMessageOp, useChat, useChatStorage, useCredits, useEncryption, useModels, verifyMemoriesForPublish, xhrTransport };