hippo-memory 1.71.0 → 2.0.0

package/dist/api/on-store.js

@@ -1,38 +0,0 @@
-// The one place an api function picks between a served store and hippo.db, so each operation has one body.
-// Only functions published as StoreReply use this carrier (see "Sync core, async port" in docs/ARCHITECTURE.md);
-// a new operation is async and goes through storeFor(ctx).
-import { SqliteBlockedError, StoreNotPortedError } from '../util/sqlite-blocked.js';
-import { REFUSED_ON_A_STORE, sqliteLocal } from '../store/sqlite/local.js';
-import { sqliteSyncStore } from '../store/sqlite/store.js';
-/** `next` on the reply's value, at once for a value, so hippo.db's path never becomes a Promise. */
-export function andThen(reply, next) {
-    return reply instanceof Promise ? reply.then(next) : next(reply);
-}
-/** Stands in for a group the store lacks, as `port.keyAudit ?? notPorted(port, 'keyAudit')`; it answers 501 as any unported path does. */
-export function notPorted(port, group) {
-    throw new StoreNotPortedError(port.kind, group);
-}
-/** A served store's stand-in for SqliteLocal. The last recall sits in hippo.db's
- * meta table, so only a store that is hippo.db keeps and reads it, on `hippoRoot`. */
-function servedLocal(store, hippoRoot) {
-    if (store.kind === 'sqlite')
-        return { ...sqliteLocal(hippoRoot), ...REFUSED_ON_A_STORE };
-    return {
-        ...REFUSED_ON_A_STORE,
-        applyOutcomeToLastRecall() {
-            throw new SqliteBlockedError(store.kind);
-        },
-        finishLastRecall: (writes) => store.finishRecall(writes).then(() => null),
-    };
-}
-/** Runs `run` on `ctx.store`, where a throw rejects, else on hippo.db under `ctx.hippoRoot`, where it throws. The store path never reads `hippoRoot`.
- *  `local` runs what needs hippo.db's own handle or meta table; a served store refuses it, or does without where the write allows. */
-export function onStore(ctx, run) {
-    const { store } = ctx;
-    // No await before `run`: an add-on relies on the first port call starting inside this call.
-    const reply = store ? (async () => run(store, servedLocal(store, ctx.hippoRoot)))() : run(sqliteSyncStore(ctx.hippoRoot), sqliteLocal(ctx.hippoRoot));
-    // SAFETY: the store path is an async function's Promise and hippo.db's port calls answer
-    // values, so the Promise comes back exactly when ctx has a store, as StoreReply says.
-    return reply;
-}
-//# sourceMappingURL=on-store.js.map

package/dist/store/embeddings/local.d.ts

@@ -1,15 +0,0 @@
-export declare const DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
-/** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS degrades mean-trained models. */
-export declare function poolingFor(model: string): 'cls' | 'mean';
-/** `query` is search input, `passage` is a document being indexed; no role means no prefix on any model. */
-export type EmbeddingRole = 'query' | 'passage';
-/** e5 models only match a query to a passage when each side carries its trained prefix. */
-export declare function prefixFor(model: string, role?: EmbeddingRole): string;
-/** Check (synchronously) if @xenova/transformers or @huggingface/transformers is installed. */
-export declare function isEmbeddingAvailable(): boolean;
-/** Throws, with the reason, when the model's pipeline cannot load: a provider-level failure, not a per-item skip. */
-export declare function requireLocalPipeline(model: string): Promise<void>;
-export declare function resolveEmbeddingModel(hippoRoot: string, explicitModel?: string): string;
-/** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds e5-style prefixes. */
-export declare function getEmbedding(text: string, model?: string, role?: EmbeddingRole): Promise<number[]>;
-//# sourceMappingURL=local.d.ts.map

package/dist/store/embeddings/local.js

@@ -1,175 +0,0 @@
-// The local Transformers.js embedder, a leaf so provider.ts can wrap it without importing index.ts.
-import { envModelCache } from '../../util/env.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { createRequire } from 'module';
-import { loadConfig } from '../../core/config.js';
-import { errorMessage, log } from '../../util/log.js';
-const _require = createRequire(import.meta.url);
-let _embeddingAvailable = null;
-// A pipeline is expensive to load, so one instance per model is kept for the process.
-const _pipelineInstances = new Map();
-const _pipelineLoading = new Map();
-const _pipelineErrors = new Map();
-export const DEFAULT_EMBEDDING_MODEL = 'Xenova/all-MiniLM-L6-v2';
-/** BGE was trained with CLS pooling; everything else gets mean, the sentence-transformers default, since CLS degrades mean-trained models. */
-export function poolingFor(model) {
-    return /\bbge\b/i.test(model) ? 'cls' : 'mean';
-}
-/** e5 models only match a query to a passage when each side carries its trained prefix. */
-export function prefixFor(model, role) {
-    if (!role)
-        return '';
-    if (/\be5\b/i.test(model)) {
-        return role === 'query' ? 'query: ' : 'passage: ';
-    }
-    return '';
-}
-/** Check (synchronously) if @xenova/transformers or @huggingface/transformers is installed. */
-export function isEmbeddingAvailable() {
-    if (_embeddingAvailable !== null)
-        return _embeddingAvailable;
-    try {
-        _require.resolve('@xenova/transformers');
-        _embeddingAvailable = true;
-        return true;
-    }
-    catch {
-        // fall through
-    }
-    try {
-        _require.resolve('@huggingface/transformers');
-        _embeddingAvailable = true;
-        return true;
-    }
-    catch {
-        // fall through
-    }
-    _embeddingAvailable = false;
-    return false;
-}
-// Importing both packages loads two incompatible onnxruntime-node builds whose finalizers can double-free on exit,
-// so pick one first: the maintained package hippo ships, with Xenova only as a fallback a user installed.
-function resolveTransformersPackage() {
-    try {
-        _require.resolve('@huggingface/transformers');
-        return '@huggingface/transformers';
-    }
-    catch {
-        // fall through
-    }
-    try {
-        _require.resolve('@xenova/transformers');
-        return '@xenova/transformers';
-    }
-    catch {
-        return null; // neither optional package is installed; callers fall back to no local embeddings
-    }
-}
-async function loadPipeline(model) {
-    const loaded = _pipelineInstances.get(model);
-    if (loaded)
-        return loaded;
-    const inFlight = _pipelineLoading.get(model);
-    if (inFlight)
-        return inFlight;
-    const loading = createPipeline(model);
-    _pipelineLoading.set(model, loading);
-    return loading;
-}
-/** The model's pipeline, or null with the reason recorded in `_pipelineErrors`. */
-async function createPipeline(model) {
-    const pkg = resolveTransformersPackage();
-    if (!pkg) {
-        _pipelineErrors.set(model, 'no transformers package is installed');
-        return null;
-    }
-    const pipelineFn = await importPipelineFactory(pkg, model);
-    if (!pipelineFn)
-        return null;
-    // The offline bundle used in egress-blocked sandboxes ships only the FP32 model, so use whichever file is on disk.
-    const cacheRoot = envModelCache();
-    const quantized = !cacheRoot
-        || fs.existsSync(path.join(cacheRoot, model, 'onnx', 'model_quantized.onnx'));
-    try {
-        const instance = await pipelineFn('feature-extraction', model, { quantized });
-        _pipelineInstances.set(model, instance);
-        return instance;
-    }
-    catch (err) {
-        const reason = `embedding pipeline load failed (${model}): ${String(err)}`;
-        log.debug(reason);
-        _pipelineErrors.set(model, reason);
-        return null;
-    }
-    finally {
-        _pipelineLoading.delete(model);
-    }
-}
-/** The package's `pipeline` function, or null with the reason recorded in `_pipelineErrors`. */
-async function importPipelineFactory(pkg, model) {
-    let pipelineFn = null;
-    try {
-        // The package is an optional peer, so the dynamic import is typed by what this file reads; a missing export falls to the null below.
-        const mod = await import(/* @vite-ignore */ pkg);
-        const cache = envModelCache();
-        if (cache && mod.env) {
-            mod.env.cacheDir = cache;
-            mod.env.localModelPath = cache;
-            mod.env.allowRemoteModels = false;
-        }
-        pipelineFn = mod.pipeline ?? mod.default?.pipeline ?? null;
-    }
-    catch (err) {
-        // String(err) keeps a Node error's [ERR_...] code, which callers match on.
-        const reason = `transformers import failed (${pkg}): ${String(err)}`;
-        log.debug(reason);
-        _pipelineErrors.set(model, reason);
-        return null;
-    }
-    if (!pipelineFn) {
-        _pipelineErrors.set(model, `${pkg} exports no pipeline function`);
-        return null;
-    }
-    return pipelineFn;
-}
-/** Throws, with the reason, when the model's pipeline cannot load: a provider-level failure, not a per-item skip. */
-export async function requireLocalPipeline(model) {
-    if (await loadPipeline(model))
-        return;
-    throw new Error(`local embedding model did not load: ${_pipelineErrors.get(model) ?? 'unknown reason'}`);
-}
-export function resolveEmbeddingModel(hippoRoot, explicitModel) {
-    const direct = explicitModel?.trim();
-    if (direct)
-        return direct;
-    try {
-        const configured = loadConfig(hippoRoot).embeddings.model?.trim();
-        if (configured)
-            return configured;
-    }
-    catch {
-        // Fall back to the default model when config cannot be read.
-    }
-    return DEFAULT_EMBEDDING_MODEL;
-}
-/** Embeds `text` with the local model, or returns `[]` when Transformers.js is missing or fails; `role` adds e5-style prefixes. */
-export async function getEmbedding(text, model = DEFAULT_EMBEDDING_MODEL, role) {
-    if (!isEmbeddingAvailable())
-        return [];
-    try {
-        const pipe = await loadPipeline(model);
-        if (!pipe)
-            return [];
-        const prefix = prefixFor(model, role);
-        const input = prefix ? `${prefix}${text}` : text;
-        const output = await pipe(input, { pooling: poolingFor(model), normalize: true });
-        return Array.from(output.data);
-    }
-    catch (err) {
-        // The caller sees `[]` and names the memory; the reason only shows at debug.
-        log.debug(`local embedding failed: ${errorMessage(err)}`);
-        return [];
-    }
-}
-//# sourceMappingURL=local.js.map