@melandlabs/memory-store 1.3.7 → 1.3.8

package/dist/evidence-selector-uOHsxwch.d.ts

@@ -0,0 +1,597 @@
+import { FactType } from '@melandlabs/contracts';
+import { Peer } from '@melandlabs/contracts/peer';
+
+/**
+ * Iterative, LLM-driven memory retrieval.
+ *
+ * Instead of issuing one fixed query, a small planner model examines the
+ * original question and the evidence collected so far, then decides:
+ *   - search again with different keywords / time bounds
+ *   - save some of the last results as evidence
+ *   - finish gathering
+ *
+ * This trades latency and token cost for better evidence location on
+ * multi-hop, temporal, or underspecified questions.
+ *
+ * The module is provider-agnostic: callers inject a `complete` callback.
+ */
+interface IterativeRecallCandidate {
+    id: string;
+    content: string;
+    similarity: number;
+    metadata: Record<string, unknown>;
+}
+interface IterativeRecallSearchRequest {
+    keywords: string[];
+    dateFrom?: string;
+    dateTo?: string;
+}
+interface IterativeRecallSearchResult {
+    candidates: IterativeRecallCandidate[];
+}
+interface IterativeRecallExecutor {
+    search(request: IterativeRecallSearchRequest): Promise<IterativeRecallSearchResult>;
+}
+interface IterativeRecallStats {
+    iterations: number;
+    searches: number;
+    notes: number;
+}
+interface IterativeRecallResult {
+    /** Evidence selected by the planner, in the order it was collected. */
+    evidence: IterativeRecallCandidate[];
+    /** Diagnostic statistics. */
+    stats: IterativeRecallStats;
+    /** Opt-in action diagnostics. Never used to select or rank evidence. */
+    diagnostics?: IterativeRecallDiagnostics;
+}
+interface IterativeRecallDiagnostics {
+    steps: Array<{
+        iteration: number;
+        action: PlannerAction["type"] | "invalid" | "completion_error";
+        responseExcerpt?: string;
+        multipleActions?: boolean;
+        errorName?: string;
+        httpStatus?: number;
+    }>;
+    fallback?: "recent-hits" | "baseline";
+    searches: number;
+    notes: number;
+}
+interface IterativeRecallPlanner {
+    plan(input: {
+        query: string;
+        executor: IterativeRecallExecutor;
+        options?: IterativeRecallPlannerOptions;
+        /**
+         * Optional absolute date range for the search. The planner passes these
+         * bounds to the executor and may also emit narrower ranges in later actions.
+         */
+        dateFrom?: string;
+        dateTo?: string;
+    }): Promise<IterativeRecallResult>;
+    /**
+     * Optional. When implemented, returns true iff the most recent `plan()`
+     * could not run the planner as designed and fell back to a degraded
+     * result — for example the LLM call threw, every iteration produced an
+     * unparseable action, or the result relied on the fallback path
+     * (recent-hits or baseline search) because the planner never committed
+     * any evidence via a `note` action.
+     */
+    lastDegraded?: () => boolean;
+}
+interface IterativeRecallPlannerOptions {
+    /** Maximum planner actions. @default 4 */
+    maxIterations?: number;
+    /** Results exposed to the planner per internal search. @default 5 */
+    searchTopK?: number;
+    /** When true, skip planning and return no evidence. @default false */
+    disabled?: boolean;
+    /**
+     * When true (default), if the planner finishes without noting any
+     * evidence the planner falls back to either the most recent hits or a
+     * baseline keyword search against the original query, so the call is
+     * never a total loss. Set to false to surface empty results honestly
+     * when the planner never committed anything.
+     * @default true
+     */
+    fallbackToBaseline?: boolean;
+    /** Include bounded response excerpts and degradation causes. @default false */
+    collectDiagnostics?: boolean;
+}
+interface IterativeRecallCompletionOptions {
+    /** Preserve real chat roles instead of asking the model to continue a transcript. */
+    messages: ReadonlyArray<{
+        role: "system" | "user" | "assistant";
+        content: string;
+    }>;
+}
+interface IterativeRecallPlannerDeps {
+    /** LLM completion callback. Chat transports should send options.messages
+     * verbatim; the string prompt is also supplied for plain completion hosts. */
+    complete: (prompt: string, options?: IterativeRecallCompletionOptions) => Promise<string>;
+    /** Default options. */
+    options?: IterativeRecallPlannerOptions;
+}
+type PlannerAction = {
+    type: "search";
+    keywords: string[];
+    dateFrom?: string;
+    dateTo?: string;
+} | {
+    type: "note";
+    indices: number[];
+} | {
+    type: "finish";
+};
+declare function createIterativeRecallPlanner(deps: IterativeRecallPlannerDeps): IterativeRecallPlanner;
+/**
+ * A no-op planner that never runs iterative retrieval.
+ */
+declare function createIdentityIterativePlanner(): IterativeRecallPlanner;
+
+type UnifiedMemorySearchSource = "memory" | "insights" | "knowledge";
+/**
+ * A retrieval channel that contributed to a hit's final score.
+ *
+ *   - `semantic` — dense embedding lookup (`searchRawMessagesAnn` or
+ *     the SQLite manager's semantic-search fallback).
+ *   - `lexical`  — BM25 / FTS5 keyword match
+ *     (`searchRawMessagesLexical` or the SQLite manager's lexical
+ *     fallback).
+ *   - `planner`  — evidence selected by iterative recall.
+ *   - `entity`   — entity-link match supplied by the host's
+ *     `entitySearch` dep.
+ */
+type HitChannel = "semantic" | "lexical" | "planner" | "hybrid" | "entity";
+type UnifiedMemoryRrfWeights = Partial<Record<HitChannel, number>>;
+/**
+ * Per-hit score breakdown. Always emitted by `search()` (default merge
+ * strategy) so callers can threshold / re-rank without losing the
+ * individual channel contributions. The RRF fusion additionally
+ * populates `signals.rrf` and continues to mirror the fused score
+ * onto `metadata.rrfScore` (legacy field).
+ *
+ * Each numeric field is the raw per-channel score for the *first*
+ * (highest-ranked) appearance of the same `(type, id)` key in the
+ * channel's list. Channels that did not contribute are `undefined`.
+ */
+interface HitSignals {
+    /** Channels the hit actually appeared in. */
+    channels: HitChannel[];
+    /** Semantic sub-query similarity in [0..1] (undefined when absent). */
+    semantic?: number;
+    /** Lexical sub-query BM25 score (undefined when absent). */
+    lexical?: number;
+    /** Iterative planner evidence score (undefined when absent). */
+    planner?: number;
+    /** Native backend dense+BM25 fused score (undefined when absent). */
+    hybrid?: number;
+    /** Entity sub-query match score (undefined when absent). */
+    entity?: number;
+    /** RRF-fused score (only when mergeStrategy === "rrf"). */
+    rrf?: number;
+}
+/**
+ * Derive simple lexical keywords from a query string. Splits on any
+ * non-letter/non-digit Unicode boundary, lowercases, drops tokens
+ * shorter than 2 chars, deduplicates in first-occurrence order, and caps
+ * the unique list at 16. Used by the unified
+ * search lexical sub-query and by the `derive` primitive's candidate
+ * fetch fallback.
+ */
+declare function deriveLexicalKeywords(query: string): string[];
+type UnifiedMemoryReasoningStrategy = "none" | "rewrite" | "iterative" | "union";
+interface UnifiedMemorySearchWarning {
+    source: UnifiedMemorySearchSource;
+    code: string;
+    message: string;
+}
+interface UnifiedMemoryReasoningInfo {
+    strategy: UnifiedMemoryReasoningStrategy;
+    /**
+     * True when the caller asked for a non-`"none"` strategy but the
+     * corresponding reasoning provider was not configured (or its LLM
+     * call failed), so the unified search silently fell back to the default
+     * one-shot semantic + lexical path. Callers can use this to surface a
+     * degraded-mode warning to their users.
+     */
+    degraded?: boolean;
+    /** Query variants produced by the rewriter (original + rewritten). */
+    rewrittenQueries?: string[];
+    /** Bounded query variants actually used by the opt-in lexical rewrite path. */
+    lexicalRewrittenQueries?: string[];
+    /** Present only when RRF fusion of multiple semantic query variants ran. */
+    semanticVariantMerge?: "rrf";
+    /** Number of planner iterations executed (iterative mode only). */
+    iterations?: number;
+    /** Number of evidence items collected by the planner (iterative mode only). */
+    evidenceCount?: number;
+    /** Opt-in planner action ledger, only when retrieval diagnostics were requested. */
+    plannerDiagnostics?: IterativeRecallDiagnostics;
+    /** Date range that was applied to the memory source, if any. */
+    dateRange?: {
+        from?: string;
+        to?: string;
+    };
+}
+interface UnifiedMemorySearchInput {
+    userId: string;
+    query: string;
+    sources?: UnifiedMemorySearchSource[];
+    limit?: number;
+    /** Optional diagnostic candidate budget; defaults to max(limit, limit * 4). */
+    candidateLimit?: number;
+    threshold?: number;
+    authToken?: string;
+    includeArchivedInsights?: boolean;
+    botIds?: string[];
+    documentIds?: string[];
+    /**
+     * Optional ISO-8601 timestamp. When set, graph-aware retrieval and other
+     * snapshot consumers drop nodes / edges whose `applicability.validFrom` /
+     * `validUntil` window is closed at that instant. Backward-compatible:
+     * omitted `asOf` keeps the legacy behaviour exactly.
+     *
+     * This is a single-point snapshot, not a date range. For interval filtering
+     * over memory timestamps use `dateFrom` / `dateTo`.
+     */
+    asOf?: string;
+    /**
+     * Optional inclusive start date (ISO-8601). When set, the memory source
+     * filters out candidates whose timestamp is before this boundary. The
+     * iterative planner also receives this bound and may emit narrower ranges.
+     *
+     * This only affects the `memory` source; `insights` and `knowledge` are
+     * not filtered by this range. Candidates without a recognised timestamp are
+     * retained.
+     */
+    dateFrom?: string;
+    /**
+     * Optional inclusive end date (ISO-8601). When set, the memory source
+     * filters out candidates whose timestamp is after this boundary. Date-only
+     * strings are treated as the end of that day.
+     *
+     * This only affects the `memory` source; `insights` and `knowledge` are
+     * not filtered by this range. Candidates without a recognised timestamp are
+     * retained.
+     */
+    dateTo?: string;
+    /**
+     * How to merge per-source result lists. Defaults to `"rrf"` reciprocal-rank
+     * fusion. `"similarity"` preserves the legacy global similarity sort.
+     */
+    mergeStrategy?: UnifiedMemoryMergeStrategy;
+    /** Optional per-channel RRF weights. Omitted channels retain weight 1. */
+    rrfWeights?: UnifiedMemoryRrfWeights;
+    /** Optional reciprocal-rank damping constant. Defaults to 60. */
+    rrfK?: number;
+    /** Opt-in post-fusion session-neighbor expansion used by retrieval experiments. */
+    sessionNeighborExpansion?: SessionNeighborExpansionOptions;
+    /**
+     * Optional additive scope-narrowing filter expressed as structured
+     * peers. Coexists with `userId`/`botIds`. When supplied, the host's
+     * `UnifiedSearchDeps.peerScopeCheck` is consulted; peers that fall
+     * outside `userId` are dropped with a `peer_filter_outside_user_scope`
+     * warning rather than broadening the scope.
+     */
+    peerFilter?: ReadonlyArray<Peer>;
+    /**
+     * Optional reasoning strategy. `"rewrite"` rewrites the query before
+     * embedding; `"iterative"` runs an LLM planner that searches, notes
+     * evidence, and searches again. Defaults to `"none"`.
+     */
+    reasoningStrategy?: UnifiedMemoryReasoningStrategy;
+    /**
+     * Optional `FactType` read-side filter. When supplied, the memory
+     * source narrows candidates to rows whose `factType` is in this set.
+     * Only affects the `memory` source; `insights` and `knowledge` are
+     * not filtered by this. Empty array is treated as "no filter" so
+     * callers can pass `searchInput.factTypes ?? []` without surprises.
+     */
+    factTypes?: FactType[];
+    /** Include pre-fusion channel candidates in the response for diagnostics. */
+    includeRetrievalDiagnostics?: boolean;
+    /**
+     * Include messages that have been soft-deprecated
+     * (`raw_messages.deprecated_at IS NOT NULL`). Default `false` keeps
+     * `current-truth` retrievals clean: a row that was marked superseded
+     * via `deprecateMessages` (or the `opencontext deprecate` CLI) is
+     * excluded from results. Set to `true` for audits and historical
+     * exploration.
+     */
+    includeDeprecated?: boolean;
+}
+type UnifiedMemoryMergeStrategy = "similarity" | "rrf";
+/**
+ * A single ranked list from one retrieval channel. Used by the RRF merge to
+ * combine multiple signals (semantic + lexical + insights + knowledge) without
+ * flattening them into a single similarity score first.
+ */
+interface UnifiedMemoryRankedList {
+    /** Label for the source list (e.g. a tier or channel). Free-form; the
+     * RRF fusion only reads `hits`, so `name` is purely diagnostic. */
+    name: string;
+    hits: UnifiedMemorySearchResult[];
+}
+type SessionNeighborExpansionMode = "union" | "protected";
+interface SessionNeighborExpansionOptions {
+    /** Number of fused seed messages used to find neighbors. */
+    seedLimit?: number;
+    /** Number of messageSequence steps to inspect on each side. */
+    window?: number;
+    /** `union` lets reranking choose all candidates; `protected` reserves slots for direct hits. */
+    mode?: SessionNeighborExpansionMode;
+    /** Maximum neighbor results in `protected` mode. */
+    maxNeighborSlots?: number;
+}
+interface UnifiedMemorySearchResult {
+    type: "memory" | "insight" | "knowledge";
+    id: string;
+    content: string;
+    similarity: number;
+    metadata: Record<string, unknown>;
+    /**
+     * Optional per-channel score breakdown. Always populated by the
+     * pipeline when at least one channel contributed a non-empty list;
+     * callers should treat absence as "no channel info available".
+     */
+    signals?: HitSignals;
+}
+interface UnifiedMemorySearchOutput {
+    query: string;
+    sources: UnifiedMemorySearchSource[];
+    results: UnifiedMemorySearchResult[];
+    count: number;
+    warnings: UnifiedMemorySearchWarning[];
+    retrievalDiagnostics?: UnifiedMemoryRetrievalDiagnostics;
+    /**
+     * Diagnostic information about reasoning and date filtering. Present
+     * when (a) a non-`"none"` reasoning strategy was requested, or (b) a
+     * `dateFrom` / `dateTo` filter was applied to the memory source.
+     */
+    reasoning?: UnifiedMemoryReasoningInfo;
+}
+interface UnifiedMemoryRetrievalDiagnostics {
+    mergeStrategy: UnifiedMemoryMergeStrategy;
+    candidateLimit: number;
+    rrf?: {
+        k: number;
+        weights: UnifiedMemoryRrfWeights;
+    };
+    backend?: string;
+    semanticDegradedReason?: string;
+    /** Wall-clock timings for the retrieval stages, in milliseconds. */
+    timings?: {
+        totalMs: number;
+        memorySourceMs: number;
+        semanticMs: number;
+        lexicalMs: number;
+        hybridMs: number;
+        plannerMs: number;
+        fusionMs: number;
+        rerankerMs: number;
+        neighborMs?: number;
+    };
+    candidateCounts?: {
+        semantic: number;
+        lexical: number;
+        planner?: number;
+        hybrid: number;
+        entity: number;
+        fused: number;
+        expanded?: number;
+        final: number;
+    };
+    channels: {
+        semantic: UnifiedMemorySearchResult[];
+        lexical: UnifiedMemorySearchResult[];
+        planner?: UnifiedMemorySearchResult[];
+        hybrid?: UnifiedMemorySearchResult[];
+        entity?: UnifiedMemorySearchResult[];
+    };
+    /** Results after channel/source fusion and before an optional host reranker. */
+    fusedBeforeRerank: UnifiedMemorySearchResult[];
+    /** Candidates after optional session-neighbor expansion and before reranking. */
+    expandedBeforeRerank?: UnifiedMemorySearchResult[];
+    sessionNeighborExpansion?: {
+        enabled: boolean;
+        mode?: SessionNeighborExpansionMode;
+        seedCount: number;
+        neighborCount: number;
+        sessions: number;
+        latencyMs: number;
+    };
+    reranker?: {
+        enabled: boolean;
+        provider?: string;
+        model?: string;
+        inputCount: number;
+        outputCount: number;
+        latencyMs: number;
+        orderChanged: boolean;
+    };
+    /** Final results after optional reranking and Top-K truncation. */
+    final: UnifiedMemorySearchResult[];
+}
+/**
+ * Cross-source retrieval surface for the unified search. Mirrors
+ * `UnifiedMemorySearchSource` but is exposed under a more discoverable
+ * name.
+ */
+type SearchSource = UnifiedMemorySearchSource;
+/**
+ * Per-tier evidence bucket consulted by `reflect`-style synthesis.
+ * Includes the `summary` tier that the read-only sources do not surface.
+ */
+type SearchTier = "summary" | "raw" | "insight" | "knowledge";
+interface SearchInput {
+    userId: string;
+    query: string;
+    /** Cross-source retrieval surface (defaults to all three sources). */
+    sources?: ReadonlyArray<SearchSource>;
+    /**
+     * Per-tier subset — when omitted, defaults to all four tiers.
+     * Forwarded to the gather step so the read pipeline can scope the
+     * evidence. Most callers pass nothing; `synthesize` callers can
+     * narrow to `["raw"]` or `["summary", "raw"]` for cheaper synthesis.
+     */
+    tiers?: ReadonlyArray<SearchTier>;
+    /**
+     * Opt-in LLM synthesis. When `true`, runs `reasoning.complete` after
+     * gathering evidence and returns `answer` in the output. When
+     * omitted / `false`, no LLM call is made (matches today's
+     * `searchUnifiedMemory`). The `responseSchema` form lets the LLM
+     * return JSON; the SDK extracts `{ answer: string }` from the
+     * payload and surfaces the rest via warnings.
+     */
+    synthesize?: boolean | {
+        responseSchema?: Record<string, unknown>;
+    };
+    limit?: number;
+    /** Optional diagnostic candidate budget; defaults to max(limit, limit * 4). */
+    candidateLimit?: number;
+    threshold?: number;
+    botIds?: string[];
+    documentIds?: string[];
+    dateFrom?: string;
+    dateTo?: string;
+    asOf?: string;
+    peerFilter?: ReadonlyArray<Peer>;
+    authToken?: string;
+    factTypes?: FactType[];
+    mergeStrategy?: UnifiedMemoryMergeStrategy;
+    rrfWeights?: UnifiedMemoryRrfWeights;
+    rrfK?: number;
+    sessionNeighborExpansion?: SessionNeighborExpansionOptions;
+    reasoningStrategy?: UnifiedMemoryReasoningStrategy;
+    /**
+     * Backward-compat pass-through for callers that previously passed
+     * `responseSchema` at the top level. When set, it overrides
+     * `synthesize.responseSchema`.
+     */
+    responseSchema?: Record<string, unknown>;
+    /**
+     * Backward-compat pass-through for callers that previously passed
+     * `includeArchivedInsights` to the read-only search.
+     */
+    includeArchivedInsights?: boolean;
+    /** Include pre-fusion retrieval candidates; intended for evaluation/debugging. */
+    includeRetrievalDiagnostics?: boolean;
+    /**
+     * Include messages that have been soft-deprecated
+     * (`raw_messages.deprecated_at IS NOT NULL`). Default `false` keeps
+     * `current-truth` retrievals clean: a row that was marked superseded
+     * via `deprecateMessages` (or the `opencontext deprecate` CLI) is
+     * excluded from results. Set to `true` for audits and historical
+     * exploration.
+     */
+    includeDeprecated?: boolean;
+}
+interface SearchEvidence {
+    id: string;
+    source: SearchSource | SearchTier;
+    snippet: string;
+    score: number;
+    timestamp?: number;
+    /**
+     * Forwarded from the underlying hit's `metadata`. Surfaces per-fact
+     * provenance (`metadata.source`, `metadata.factType`, etc.) to the
+     * synthesis prompt and the CLI's `--context-only` / `--json` output.
+     */
+    metadata?: Record<string, unknown>;
+}
+interface SearchOutput {
+    query: string;
+    sources: ReadonlyArray<SearchSource>;
+    results: UnifiedMemorySearchResult[];
+    /** Same hits as `results`, with the source labelled for synthesis callers. */
+    evidence: SearchEvidence[];
+    count: number;
+    warnings: UnifiedMemorySearchWarning[];
+    retrievalDiagnostics?: UnifiedMemoryRetrievalDiagnostics;
+    reasoning?: UnifiedMemoryReasoningInfo;
+    /** Only present when `synthesize` was truthy. */
+    answer?: string;
+}
+declare function normalizeUnifiedMemorySearchSources(sources: unknown): UnifiedMemorySearchSource[];
+declare function clampUnifiedMemorySearchLimit(limit: unknown): number;
+declare function clampUnifiedMemorySearchThreshold(threshold: unknown): number;
+declare function mergeUnifiedMemorySearchResults(results: UnifiedMemorySearchResult[], limit: number, options?: {
+    strategy?: UnifiedMemoryMergeStrategy;
+    rankedLists?: UnifiedMemoryRankedList[];
+    rrfK?: number;
+    rrfWeights?: UnifiedMemoryRrfWeights;
+}): UnifiedMemorySearchResult[];
+declare function normalizeUnifiedMemoryMergeStrategy(value: unknown): UnifiedMemoryMergeStrategy;
+declare function normalizeUnifiedMemoryReasoningStrategy(value: unknown, defaultStrategy?: UnifiedMemoryReasoningStrategy): UnifiedMemoryReasoningStrategy;
+/**
+ * Reciprocal Rank Fusion across multiple ranked lists. Each list contributes
+ * `1 / (k + rank + 1)` to a hit's accumulated score. Hits are de-duplicated by
+ * `(type, id)` so the same message surfaced by both lexical and semantic
+ * channels naturally outranks single-channel matches. Tie-break is
+ * deterministic: descending RRF score, then `(type, id)` lexical.
+ */
+declare function mergeUnifiedMemorySearchResultsRrf(lists: UnifiedMemoryRankedList[], limit: number, k?: number, weights?: UnifiedMemoryRrfWeights): UnifiedMemorySearchResult[];
+declare function toKnowledgeResult(result: {
+    chunkId: string;
+    documentId: string;
+    documentName: string;
+    content: string;
+    similarity: number;
+    chunkIndex: number;
+}): UnifiedMemorySearchResult;
+declare function toMemoryResult(result: {
+    id: string;
+    content: string;
+    similarity: number;
+    metadata: Record<string, unknown>;
+}): UnifiedMemorySearchResult;
+/**
+ * Build the `signals` breakdown for a single hit from the per-channel
+ * ranked lists it appeared in. Only the highest-ranked (i.e. first)
+ * appearance of `(type, id)` per channel contributes — duplicate hits
+ * later in the same list are ignored so the breakdown stays
+ * deterministic.
+ *
+ * Used by `mergeAcrossSources` to attach `signals` to every emitted
+ * `UnifiedMemorySearchResult`. Pure; no I/O.
+ */
+declare function materializeSignals(lists: ReadonlyArray<{
+    name: string;
+    hits: UnifiedMemorySearchResult[];
+}>, hit: UnifiedMemorySearchResult): HitSignals | undefined;
+/**
+ * Map a `UnifiedMemoryRankedList.name` to a `HitChannel`. Unknown names
+ * (e.g. "insights", "knowledge", "summary") are not channels — they
+ * surface their similarity through the merge's `similarity` field and
+ * are simply skipped here so callers can still see which channel set
+ * the hit came from.
+ */
+declare function listNameToChannel(name: string): HitChannel | undefined;
+declare function isRawMemorySemanticResult(result: unknown): result is {
+    id: string;
+    content: string;
+    similarity: number;
+    metadata: Record<string, unknown>;
+};
+
+interface EvidenceSelector {
+    select(input: {
+        query: string;
+        hits: UnifiedMemorySearchResult[];
+    }): Promise<{
+        hits: UnifiedMemorySearchResult[];
+        warnings: UnifiedMemorySearchWarning[];
+    }>;
+}
+interface EvidenceSelectorOptions {
+    complete: (prompt: string) => Promise<string>;
+    /** Serialized source character budget; oversized hits remain intact. */
+    maxSourceCharacters?: number;
+}
+/** Extractive selection AFTER ranking. No writes, invented text, new sources,
+ * changed ranking, or reranker-input changes. Disabled unless explicitly wired. */
+declare function createExtractiveEvidenceSelector(options: EvidenceSelectorOptions): EvidenceSelector;
+
+export { toMemoryResult as A, type EvidenceSelectorOptions as B, type IterativeRecallCandidate as C, type IterativeRecallCompletionOptions as D, type EvidenceSelector as E, type IterativeRecallExecutor as F, type IterativeRecallPlannerOptions as G, type HitChannel as H, type IterativeRecallPlanner as I, type IterativeRecallResult as J, type IterativeRecallSearchRequest as K, type IterativeRecallSearchResult as L, type IterativeRecallStats as M, type UnifiedMemoryReasoningInfo as N, createExtractiveEvidenceSelector as O, createIdentityIterativePlanner as P, createIterativeRecallPlanner as Q, type SearchTier as S, type UnifiedMemorySearchWarning as U, type SearchEvidence as a, type SearchInput as b, type SearchOutput as c, type UnifiedMemorySearchInput as d, type UnifiedMemorySearchOutput as e, type UnifiedMemorySearchResult as f, type HitSignals as g, type SearchSource as h, type SessionNeighborExpansionOptions as i, type UnifiedMemoryMergeStrategy as j, type UnifiedMemoryRankedList as k, type UnifiedMemoryReasoningStrategy as l, type UnifiedMemoryRrfWeights as m, type UnifiedMemorySearchSource as n, clampUnifiedMemorySearchLimit as o, clampUnifiedMemorySearchThreshold as p, deriveLexicalKeywords as q, isRawMemorySemanticResult as r, listNameToChannel as s, materializeSignals as t, mergeUnifiedMemorySearchResults as u, mergeUnifiedMemorySearchResultsRrf as v, normalizeUnifiedMemoryMergeStrategy as w, normalizeUnifiedMemoryReasoningStrategy as x, normalizeUnifiedMemorySearchSources as y, toKnowledgeResult as z };

package/dist/http.d.ts

@@ -1,6 +1,7 @@
-import { M as MemoryStoreConfig } from './config-BuWr-nvt.js';
+import { M as MemoryStoreConfig } from './config-9RzSCdXG.js';
 import '@melandlabs/memory-consolidation';
 import '@melandlabs/contracts/peer';
+import './evidence-selector-uOHsxwch.js';
 import '@melandlabs/contracts';
 import '@melandlabs/contracts/derived-fact';
 import '@melandlabs/contracts/entity-edge';