@oh-my-pi/pi-mnemosyne 15.6.0

package/dist/types/core/beam/types.d.ts

@@ -0,0 +1,233 @@
+import type { Database } from "bun:sqlite";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type Metadata = Record<string, JsonValue>;
+export type MemoryScope = "global" | "session" | "channel" | string;
+export type TrustTier = "STATED" | "OBSERVED" | "INFERRED" | "SYSTEM" | string;
+export type Veracity = "unknown" | "likely_true" | "true" | "false" | "stated" | "inferred" | "tool" | "imported" | "contested" | string;
+export interface BeamPluginManager {
+    emit?(event: BeamEvent): void | Promise<void>;
+    close?(): void | Promise<void>;
+}
+export interface AnnotationStoreLike {
+    add?(memoryId: string, kind: string, value: string, options?: AnnotationWriteOptions): unknown;
+    addMany?(memoryId: string, kind: string, values: readonly string[], options?: AnnotationWriteOptions): unknown;
+    queryByMemory?(memoryId: string, kind?: string): unknown;
+    queryByKind?(kind: string, value?: string): unknown;
+    getDistinctValues?(kind: string): string[];
+}
+export interface TripleStoreLike {
+    add?(subject: string, predicate: string, object: string, options?: TripleWriteOptions): unknown;
+    query?(subject?: string, predicate?: string, asOf?: string): unknown;
+}
+export interface BeamCaches {
+    timestampParse: Map<string, Date>;
+    polyphonicEngine?: unknown;
+    extractionClient?: unknown;
+    extractionBuffer: unknown[];
+    [key: string]: unknown;
+}
+export interface BeamConfig {
+    workingMemoryLimit: number;
+    workingMemoryTtlHours: number;
+    recencyHalflifeHours: number;
+    vecWeight: number;
+    ftsWeight: number;
+    importanceWeight: number;
+    useCloud: boolean;
+    localLlmEnabled: boolean;
+}
+export interface BeamMemoryOptions {
+    sessionId?: string;
+    dbPath?: string;
+    authorId?: string | null;
+    authorType?: string | null;
+    channelId?: string | null;
+    useCloud?: boolean;
+    eventEmitter?: (event: BeamEvent) => void;
+    pluginManager?: BeamPluginManager | null;
+    annotations?: AnnotationStoreLike | null;
+    triples?: TripleStoreLike | null;
+    config?: Partial<BeamConfig>;
+}
+export interface BeamMemoryState {
+    db: Database;
+    dbPath?: string;
+    sessionId: string;
+    authorId: string | null;
+    authorType: string | null;
+    channelId: string;
+    useCloud: boolean;
+    eventEmitter?: (event: BeamEvent) => void;
+    pluginManager: BeamPluginManager | null;
+    annotations: AnnotationStoreLike | null;
+    triples: TripleStoreLike | null;
+    episodicGraph: unknown | null;
+    veracityConsolidator: unknown | null;
+    caches: BeamCaches;
+    config: BeamConfig;
+    /** Tracks in-flight background fact-extraction tasks scheduled by `remember(..., { extract: true })`. */
+    pendingExtractions?: Set<Promise<void>>;
+}
+export interface AnnotationWriteOptions {
+    source?: string;
+    confidence?: number;
+}
+export interface TripleWriteOptions {
+    validFrom?: string;
+    source?: string;
+    confidence?: number;
+}
+export interface BeamEvent {
+    type: string;
+    memoryId?: string;
+    content?: string;
+    source?: string;
+    importance?: number;
+    sessionId: string;
+    timestamp: string;
+    metadata?: Metadata;
+}
+export interface RememberOptions {
+    source?: string;
+    importance?: number;
+    metadata?: Metadata | null;
+    extract?: boolean;
+    extractEntities?: boolean;
+    veracity?: Veracity;
+    memoryType?: string;
+    scope?: MemoryScope;
+    trustTier?: TrustTier;
+    timestamp?: string;
+}
+export interface RememberBatchOptions {
+    extract?: boolean;
+    extractEntities?: boolean;
+    veracity?: Veracity;
+    memoryType?: string;
+    scope?: MemoryScope;
+    trustTier?: TrustTier;
+}
+export interface RememberBatchItem extends RememberOptions {
+    content: string;
+}
+export interface RecallOptions {
+    fromDate?: string | null;
+    toDate?: string | null;
+    authorId?: string | null;
+    authorType?: string | null;
+    channelId?: string | null;
+    includeWorking?: boolean;
+    queryTime?: string | Date | null;
+    temporalWeight?: number;
+    temporalHalflife?: number;
+    vecWeight?: number;
+    ftsWeight?: number;
+    importanceWeight?: number;
+    queryEmbedding?: readonly number[] | null;
+    useSynonyms?: boolean;
+    useIntent?: boolean;
+    useMmr?: boolean;
+    mmrLambda?: number;
+}
+export interface RecallEnhancedOptions extends RecallOptions {
+    useCache?: boolean;
+    includeFacts?: boolean;
+}
+export interface MemoryRow {
+    id: string;
+    content: string;
+    source: string | null;
+    timestamp: string | null;
+    session_id: string;
+    importance: number;
+    metadata_json: string | null;
+    veracity: Veracity;
+    memory_type?: string | null;
+    recall_count?: number;
+    last_recalled?: string | null;
+    valid_until?: string | null;
+    superseded_by?: string | null;
+    scope?: MemoryScope;
+    author_id?: string | null;
+    author_type?: string | null;
+    channel_id?: string | null;
+    trust_tier?: TrustTier;
+    validator?: string | null;
+    validated_at?: string | null;
+    validation_count?: number;
+    event_date?: string | null;
+    event_date_precision?: string | null;
+    temporal_tags?: string | null;
+    corrected_by?: number | null;
+    created_at: string;
+}
+export interface WorkingMemoryRow extends MemoryRow {
+    consolidated_at?: string | null;
+}
+export interface EpisodicMemoryRow extends MemoryRow {
+    rowid: number;
+    summary_of: string;
+    tier: number;
+    degraded_at?: string | null;
+    binary_vector?: Uint8Array | null;
+}
+export type RecallTierLabel = "working" | "episodic" | "fact" | string;
+export interface RecallVoiceScores {
+    vec?: number;
+    fts?: number;
+    keyword?: number;
+    importance?: number;
+    recency_decay?: number;
+    temporal?: number;
+    [key: string]: number | undefined;
+}
+type RecallRowFields = Omit<Partial<EpisodicMemoryRow>, "tier"> & Partial<WorkingMemoryRow>;
+export type RecallResult = RecallRowFields & {
+    [key: string]: unknown;
+    id: string;
+    content: string;
+    score?: number;
+    distance?: number;
+    rank?: number;
+    tier?: RecallTierLabel;
+    tier_label?: RecallTierLabel;
+    degradation_tier?: number;
+    keyword_score?: number;
+    dense_score?: number;
+    fts_score?: number;
+    importance_score?: number;
+    recency_score?: number;
+    temporal_score?: number;
+    explanation?: string;
+    voice_scores?: RecallVoiceScores;
+    metadata?: Metadata;
+};
+export interface BeamStats {
+    count: number;
+    by_source?: Record<string, number>;
+    by_session?: Record<string, number>;
+    oldest?: string | null;
+    newest?: string | null;
+    [key: string]: JsonValue | Record<string, number> | undefined;
+}
+export interface MemoriaRetrieveResult {
+    ability: string;
+    query: string;
+    results: unknown[];
+}
+export interface SleepResult {
+    dry_run: boolean;
+    sessions?: Record<string, unknown>;
+    items_consolidated?: number;
+    [key: string]: unknown;
+}
+export interface ImportStats {
+    working_memory: Record<string, number>;
+    episodic_memory: Record<string, number>;
+    scratchpad: Record<string, number>;
+    consolidation_log: Record<string, number>;
+}
+export {};

package/dist/types/core/binary-vectors.d.ts

@@ -0,0 +1,54 @@
+import type { Database } from "bun:sqlite";
+import { type VecType } from "../config";
+import { type DatabasePath } from "../db";
+export declare const BITS_PER_BYTE = 8;
+export declare const EMBEDDING_DIM: number;
+export declare const BYTES_PER_VECTOR: number;
+export interface BinaryVectorSearchResult {
+    memory_id: string;
+    distance: number;
+    score: number;
+}
+export interface BinaryVectorStats {
+    total_vectors: number;
+    avg_bytes_per_vector: number;
+    max_bytes: number;
+    min_bytes: number;
+    compression_ratio: number;
+    theoretical_size_mb: number;
+}
+export interface BinaryVectorStoreOptions {
+    dbPath?: DatabasePath;
+    tableName?: string;
+    conn?: Database;
+}
+export declare function getVecType(env?: NodeJS.ProcessEnv): VecType;
+export declare const VEC_TYPE: VecType;
+export declare function quantizeInt8(embedding: readonly number[]): Int8Array;
+export declare function maximallyInformativeBinarization(embedding: readonly number[]): Uint8Array;
+export declare function hammingDistance(binaryA: Uint8Array | ArrayBuffer, binaryB: Uint8Array | ArrayBuffer): number;
+export declare function informationTheoreticScore(distance: number, dim?: number): number;
+export declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
+export declare class BinaryVectorStore {
+    readonly conn: Database;
+    readonly dbPath: DatabasePath;
+    readonly tableName: string;
+    private readonly ownsConnection;
+    constructor(options?: BinaryVectorStoreOptions);
+    private initTable;
+    static maximallyInformativeBinarization(embedding: readonly number[]): Uint8Array;
+    static hammingDistance(binaryA: Uint8Array | ArrayBuffer, binaryB: Uint8Array | ArrayBuffer): number;
+    static informationTheoreticScore(distance: number, dim?: number): number;
+    storeVector(memoryId: string, embedding: readonly number[]): void;
+    search(queryEmbedding: readonly number[], topK?: number): BinaryVectorSearchResult[];
+    searchBatch(queryEmbeddings: readonly (readonly number[])[], topK?: number): BinaryVectorSearchResult[][];
+    deleteVector(memoryId: string): void;
+    getStats(): BinaryVectorStats;
+    close(): void;
+}
+export declare class FastBinarySearch {
+    private readonly memoryIds;
+    private readonly vectors;
+    constructor(binaryVectors: ReadonlyMap<string, Uint8Array | ArrayBuffer> | Record<string, Uint8Array | ArrayBuffer>);
+    search(queryBinary: Uint8Array | ArrayBuffer, topK?: number): BinaryVectorSearchResult[];
+}

package/dist/types/core/chat-normalize.d.ts

@@ -0,0 +1,13 @@
+type ExtractionRate = {
+    total: number;
+    survived: number;
+    dropped: number;
+    rate: number;
+    dropped_samples: string[];
+};
+export declare function normalizeChat(text: string, options?: {
+    add_implicit_subjects?: boolean;
+}): string | null;
+export declare function normalizeBatch(messages: string[]): (string | null)[];
+export declare function extractionRate(messages: string[]): ExtractionRate;
+export {};

package/dist/types/core/content-sanitizer.d.ts

@@ -0,0 +1,18 @@
+export declare const SIZE_HARD_CAP = 1000000;
+export declare const SIZE_BASE64_CHECK = 100000;
+export declare const ENTROPY_THRESHOLD = 5;
+export interface BlobMetadata {
+    blob_ref?: string;
+    original_size?: number;
+    mime?: string;
+    extraction_reason?: "data_uri" | "size_cap" | "high_entropy";
+    entropy?: number;
+}
+export declare function blobRoot(env?: NodeJS.ProcessEnv): string;
+export declare function computeSha256(data: Uint8Array | string): string;
+export declare function isDataUri(content: string): boolean;
+export declare function parseDataUri(content: string): [mimeType: string, raw: Buffer] | null;
+export declare function shannonEntropy(text: string): number;
+export declare function looksLikeBase64Blob(content: string): boolean;
+export declare function storeBlob(rawBytes: Uint8Array): string;
+export declare function sanitizeContent(content: string): [sanitizedContent: string, blobMetadata: BlobMetadata];

package/dist/types/core/cost-log.d.ts

@@ -0,0 +1,13 @@
+import { Database } from "bun:sqlite";
+export declare const DEFAULT_LOG_DIR: string;
+export declare const DEFAULT_LOG_DB: string;
+export interface CostStats {
+    total_calls: number;
+    total_memories_injected: number;
+    total_tokens: number;
+    total_estimated_cost_usd: number;
+}
+export declare function getConn(dbPath?: string): Database;
+export declare function initCostLog(dbPath?: string): void;
+export declare function logCost(sessionId: string, memoryCount: number, tokenCount: number, estimatedCostUsd: number, model?: string, dbPath?: string): void;
+export declare function getCostStats(sessionId?: string, dbPath?: string): CostStats;

package/dist/types/core/embeddings.d.ts

@@ -0,0 +1,35 @@
+import { EmbeddingModel } from "fastembed";
+export type Vector = number[];
+export type EmbeddingMatrix = Vector[];
+export interface EmbeddingProvider {
+    embed(texts: readonly string[]): unknown | Promise<unknown>;
+    available?(): boolean | Promise<boolean>;
+}
+type StandardEmbeddingModel = Exclude<EmbeddingModel, EmbeddingModel.CUSTOM>;
+interface LocalEmbeddingModel {
+    embed(texts: string[], batchSize?: number): unknown;
+    queryEmbed?(query: string): Promise<number[]>;
+}
+type LocalModelInitOptions = {
+    model: StandardEmbeddingModel;
+    cacheDir?: string;
+    showDownloadProgress?: boolean;
+};
+type LocalModelInitializer = (options: LocalModelInitOptions) => Promise<LocalEmbeddingModel>;
+export declare function isApiModel(modelName: string): boolean;
+export declare function embeddingDimFor(modelName: string): number;
+export declare function setEmbeddingProviderForTests(provider: EmbeddingProvider | null | undefined): void;
+export declare const setEmbeddingProvider: typeof setEmbeddingProviderForTests;
+export declare function setLocalModelInitializerForTests(initializer: LocalModelInitializer | null | undefined): void;
+export declare function resetEmbeddingProviderForTests(): void;
+export declare const resetEmbeddingStateForTests: typeof resetEmbeddingProviderForTests;
+export declare function available(): Promise<boolean>;
+export declare function availableApi(): boolean;
+export declare function embedQuery(text: string): Promise<Vector | null>;
+export declare function embed(texts: readonly string[]): Promise<EmbeddingMatrix | null>;
+export declare function serialize(vec: readonly number[]): string;
+export declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;
+export declare function getEmbeddingApiCallCountForTests(): number;
+export declare const DEFAULT_MODEL: string;
+export declare const EMBEDDING_DIM: number;
+export {};

package/dist/types/core/entities.d.ts

@@ -0,0 +1,7 @@
+export declare const ENTITY_EXTRACTION_STOP_WORDS: ReadonlySet<string>;
+export declare function levenshteinDistance(s1: string, s2: string): number;
+export declare function similarity(s1: string, s2: string): number;
+export declare function extractEntitiesRegex(text: string): string[];
+export type SimilarEntity = readonly [entity: string, score: number];
+export declare function findSimilarEntities(entity: string, knownEntities: readonly string[], threshold?: number): SimilarEntity[];
+export declare function entityExtractionPerformance(text: string, iterations?: number): number;

package/dist/types/core/episodic-graph.d.ts

@@ -0,0 +1,89 @@
+import type { Database } from "bun:sqlite";
+import { type DatabasePath } from "../db";
+export interface Gist {
+    readonly id: string;
+    readonly text: string;
+    readonly timestamp: string;
+    readonly participants: readonly string[];
+    readonly location: string | null;
+    readonly emotion: string | null;
+    readonly timeScope: string | null;
+}
+export interface Fact {
+    readonly id: string;
+    readonly subject: string;
+    readonly predicate: string;
+    readonly object: string;
+    readonly timestamp: string;
+    readonly confidence: number;
+    readonly temporalQualifier?: string | null;
+}
+export interface GraphEdge {
+    readonly source: string;
+    readonly target: string;
+    readonly edgeType: string;
+    readonly weight: number;
+    readonly timestamp: string;
+}
+export interface RelatedMemory {
+    readonly memoryId: string;
+    readonly edgeType: string;
+    readonly weight: number;
+    readonly depth: number;
+}
+export interface GraphStats {
+    readonly gists: number;
+    readonly facts: number;
+    readonly edges: number;
+    readonly totalNodes: number;
+}
+export interface IngestOptions {
+    readonly sessionId?: string;
+    readonly linkExisting?: boolean;
+    readonly minLinkScore?: number;
+    readonly extractEntities?: boolean;
+}
+export interface IngestResult {
+    readonly memoryId: string;
+    readonly gist: Gist;
+    readonly facts: readonly Fact[];
+    readonly edges: readonly GraphEdge[];
+}
+export interface EpisodicGraphOptions {
+    readonly db?: Database;
+    readonly dbPath?: DatabasePath;
+}
+export declare class EpisodicGraph {
+    readonly db: Database;
+    readonly dbPath: DatabasePath;
+    readonly ownsConnection: boolean;
+    constructor(options?: EpisodicGraphOptions);
+    private initTables;
+    extractGist(content: string, memoryId: string): Gist;
+    extractFacts(content: string, memoryId: string): Fact[];
+    storeGist(gist: Gist, memoryId: string): void;
+    getGist(id: string): Gist | null;
+    storeFact(fact: Fact, memoryId: string, sessionId?: string): void;
+    getFact(id: string): Fact | null;
+    addEdge(edge: GraphEdge): void;
+    getEdges(source?: string | null): GraphEdge[];
+    findRelatedMemories(memoryId: string, depth?: number, edgeType?: string, minWeight?: number): RelatedMemory[];
+    findFactsBySubject(subject: string): Fact[];
+    findGistsByParticipant(participant: string): Gist[];
+    scoreMemoryLink(sourceMemoryId: string, targetMemoryId: string): number;
+    ingestMemory(content: string, memoryId: string, options?: IngestOptions): IngestResult;
+    getStats(): GraphStats;
+    close(): void;
+    private count;
+    private extractParticipants;
+    private extractTemporalScope;
+    private extractLocation;
+    private extractEmotion;
+    private createSummary;
+    private knownMemoryIds;
+    private memoryContent;
+    private entityOverlapScore;
+    private temporalContextScore;
+    private memoryFeatures;
+    private scoreFeatures;
+}

package/dist/types/core/extraction/client.d.ts

@@ -0,0 +1,31 @@
+export declare const DEFAULT_EXTRACTION_MODEL: string;
+export declare const OPENROUTER_BASE_URL: string;
+export declare const FALLBACK_MODELS: readonly ["google/gemini-flash-latest"];
+export interface ChatMessage {
+    role: string;
+    content: string;
+}
+export interface ExtractedFact {
+    subject?: string;
+    predicate?: string;
+    object?: string;
+    timestamp?: string;
+    source?: number;
+    confidence?: number;
+    [key: string]: unknown;
+}
+export declare class ExtractionClient {
+    model: string;
+    apiKey: string;
+    baseUrl: string;
+    callCount: number;
+    constructor(opts?: {
+        model?: string | null;
+        apiKey?: string | null;
+        baseUrl?: string | null;
+    });
+    chat(messages: readonly ChatMessage[], temperature?: number, maxTokens?: number): Promise<string>;
+    callApi(model: string, messages: readonly ChatMessage[], temperature: number, maxTokens: number): Promise<string>;
+    extractFacts(messages: readonly ChatMessage[]): Promise<ExtractedFact[]>;
+    xtractFacts(messages: readonly ChatMessage[]): Promise<ExtractedFact[]>;
+}

package/dist/types/core/extraction/diagnostics.d.ts

@@ -0,0 +1,51 @@
+export declare const EXTRACTION_TIERS: readonly ["host", "remote", "local", "cloud", "wrapper"];
+export type ExtractionTier = (typeof EXTRACTION_TIERS)[number];
+export interface ErrorSample {
+    at: string;
+    type: string;
+    msg: string;
+    reason?: string;
+}
+export interface TierStatsSnapshot {
+    attempts: number;
+    successes: number;
+    no_output: number;
+    failures: number;
+    error_samples: ErrorSample[];
+}
+export interface ExtractionStatsSnapshot {
+    created_at: string;
+    snapshot_at: string;
+    totals: {
+        calls: number;
+        successes: number;
+        failures: number;
+        empty: number;
+        success_rate: number;
+    };
+    by_tier: Record<ExtractionTier, TierStatsSnapshot>;
+}
+export declare function safeForLog(value: unknown): string;
+export declare class ExtractionDiagnostics {
+    private tierStats;
+    private totalCalls;
+    private totalSuccesses;
+    private totalFailures;
+    private totalEmpty;
+    private createdAt;
+    private validateTier;
+    recordAttempt(tier: ExtractionTier): void;
+    recordSuccess(tier: ExtractionTier, _factCount?: number): void;
+    recordNoOutput(tier: ExtractionTier): void;
+    recordFailure(tier: ExtractionTier, exc?: unknown, reason?: string): void;
+    recordCall(opts: {
+        succeeded: boolean;
+        allEmpty?: boolean;
+    }): void;
+    successRate(): number;
+    snapshot(): ExtractionStatsSnapshot;
+    reset(): void;
+}
+export declare function getDiagnostics(): ExtractionDiagnostics;
+export declare function getExtractionStats(): ExtractionStatsSnapshot;
+export declare function resetExtractionStats(): void;

package/dist/types/core/extraction/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare const EXTRACTION_SYSTEM_PROMPT = "You extract structured facts from conversation messages. For each message or group of related messages, identify:\n\n1. ENTITIES: People, projects, tools, versions, dates, numbers mentioned\n2. RELATIONSHIPS: How entities relate to each other (uses, created, set, changed, prefers)\n3. TEMPORAL ANCHORS: When something happened, deadlines, durations\n4. CONTRADICTIONS: When a fact was later changed or updated\n\nReturn ONLY a JSON array of fact objects. Each fact must have:\n- subject: the entity the fact is about (string)\n- predicate: the relationship or action (string)\n- object: the value or related entity (string)\n- timestamp: ISO timestamp when this was stated (string, from message context)\n- source: which message index this came from (integer, 0-based)\n- confidence: 0.0-1.0 how certain you are (float)\n\nRULES:\n- One fact per relationship. \"I use React 18.2 and Node.js 18\" = 2 facts.\n- Use lowercase for predicates: \"uses\", \"set\", \"changed\", \"created\", \"prefers\"\n- Include versions and numbers as objects when available\n- If a message states something changed, extract BOTH old and new facts\n- If unclear, use confidence < 0.8\n\nFormat: [{\"subject\": \"...\", \"predicate\": \"...\", \"object\": \"...\", \"timestamp\": \"...\", \"source\": 0, \"confidence\": 0.95}]\n";
+export declare const EXTRACTION_USER_TEMPLATE = "Extract all structured facts from the following conversation messages. Return ONLY the JSON array, no other text.\n\nCONVERSATION:\n{conversation_text}\n\nFACTS:";

package/dist/types/core/extraction.d.ts

@@ -0,0 +1,6 @@
+export declare const EXTRACTION_PROMPT_TEMPLATE: string;
+export declare function buildExtractionPrompt(text: string, detectedLang?: string): string;
+export declare function parseFacts(rawOutput: string | null | undefined): string[];
+export declare function heuristicExtractFacts(text: string): string[];
+export declare function extractFacts(text: string | null | undefined): Promise<string[]>;
+export declare function extractFactsSafe(text: string | null | undefined): Promise<string[]>;

package/dist/types/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./banks";
+export * from "./beam/index";
+export * from "./memory";
+export { addMemory, forget, get, getBank, getContext, getDefaultInstance, getStats, Mnemosyne, query, recall, recallEnhanced, remember, resetDefaultInstanceForTests, resetMemoryForTests, resetModuleStateForTests, saveMemory, scratchpadClear, scratchpadRead, scratchpadWrite, search, setBank, sleep, sleepAllSessions, storeMemory, update, } from "./memory";

package/dist/types/core/llm-backends.d.ts

@@ -0,0 +1,21 @@
+export interface CompleteOptions {
+    maxTokens?: number;
+    temperature?: number;
+    timeout?: number;
+    provider?: string | null;
+    model?: string | null;
+}
+export interface LlmBackend {
+    name?: string;
+    complete(prompt: string, opts?: CompleteOptions): string | null | Promise<string | null>;
+}
+export declare function setHostLlmBackend(backend: LlmBackend | null | undefined): void;
+export declare function getHostLlmBackend(): LlmBackend | null;
+export declare function resetHostLlmBackendForTests(): void;
+export declare function callHostLlm(prompt: string, opts?: CompleteOptions): Promise<string | null>;
+export declare class CallableLlmBackend implements LlmBackend {
+    name: string;
+    private readonly fn;
+    constructor(name: string, fn: (prompt: string, opts?: CompleteOptions) => string | null | Promise<string | null>);
+    complete(prompt: string, opts?: CompleteOptions): string | null | Promise<string | null>;
+}

package/dist/types/core/local-llm.d.ts

@@ -0,0 +1,15 @@
+import { type MnemosyneLlmCompleteOptions } from "./runtime-options";
+export declare const DEFAULT_MODEL_REPO: string;
+export declare const DEFAULT_MODEL_FILE: string;
+export declare function buildPrompt(memories: readonly string[], source?: string): string;
+export declare function callConfiguredCompletion(prompt: string, temperature: number, opts?: MnemosyneLlmCompleteOptions): Promise<string | null>;
+export declare function buildHostPrompt(memories: readonly string[], source?: string): string;
+export declare function configuredLlmWillHandleCall(): boolean;
+export declare function cleanOutput(text: string): string;
+export declare function chunkMemoriesByBudget(memories: readonly string[], source?: string): string[][];
+export declare function llmAvailable(): boolean;
+export declare function callRemoteLlm(prompt: string, temperature?: number): Promise<string | null>;
+export declare function localGgufAvailable(): false;
+export declare function callLocalLlm(_prompt: string): Promise<string | null>;
+export declare function summarizeMemories(memories: readonly string[], source?: string): Promise<string | null>;
+export declare function complete(prompt: string, temperature?: number): Promise<string | null>;