@memory-river/core 0.2.0

package/dist/ports.d.ts

@@ -0,0 +1,29 @@
+export interface LlmClient {
+    /** 回傳純文字。實作端自行負責 fallback / rate limit / circuit breaker。 */
+    generate(prompt: string, opts?: {
+        purpose?: string;
+        maxTokens?: number;
+    }): Promise<string>;
+}
+export interface EmbeddingProvider {
+    embed(text: string, mode?: 'store' | 'query'): Promise<number[]>;
+    embedBatch(texts: string[]): Promise<number[][]>;
+    getDimensions(): number;
+    healthCheck?(): Promise<boolean>;
+}
+export interface Logger {
+    info(msg: string, meta?: unknown): void;
+    warn(msg: string, meta?: unknown): void;
+    error(msg: string, meta?: unknown): void;
+}
+export interface Notifier {
+    /** 夜間日報、降級告警。沒提供就靜默跳過。 */
+    notify(message: string): Promise<void>;
+}
+export interface SessionFileAccess {
+    /** 宿主若有「session 對話檔」概念才需要實作；沒有就回 null，compact 功能自動停用。 */
+    resolveSessionFile(identity: {
+        sessionKey?: string;
+        sessionId?: string;
+    }): string | null;
+}

package/dist/ports.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/embedder-v5.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Embedder v5 - Qwen3-Embedding via Ollama (Instruction-Aware)
+ * memory-river v5
+ *
+ * [鐵律] 使用 Ollama 本地部署 Qwen3-Embedding-0.6B
+ * 向量維度：1024（與 Gemini 3072維 不相容，強制使用獨立的 lancedb-v5-qwen）
+ *
+ * Instruction-Aware 前輟綁定：
+ * - 寫入：瑪「Summarize this memory concisely:」
+ * - 讀取：「Retrieve similar memory records from Memory River knowledge base:」
+ */
+import type { PluginConfig } from "../types.js";
+export declare class Embedder {
+    private ollamaUrl;
+    private model;
+    apiKey: string;
+    dimensions: number;
+    constructor(config: PluginConfig["embedding"] & {
+        ollamaUrl: string;
+        embeddingModel?: string;
+    });
+    /**
+     * 單筆查詢向量化（Instruction-Aware）
+     * @param text 原始查詢文字
+     * @param mode 'store' → "Summarize this memory concisely:" | 'query' → "Retrieve similar..."
+     * @param retries 重試次數
+     */
+    embed(text: string, mode?: 'store' | 'query', retries?: number): Promise<number[]>;
+    /**
+     * 批次向量化（寫入時使用，無 Instruction-Aware 前輟）
+     * @param texts 字串陣列
+     */
+    embedBatch(texts: string[], retries?: number): Promise<number[][]>;
+    /** 回報維度 */
+    getDimensions(): number;
+    /** 回報模型名 */
+    getModel(): string;
+    /** Ping 測試 */
+    healthCheck(): Promise<boolean>;
+    /** embed() 的 Float32Array 版本（v4 相容） */
+    embedText(text: string): Promise<Float32Array>;
+    /** embedBatch() 的 Float32Array 版本（v4 相容） */
+    embedTextBatch(texts: string[], _concurrency?: number): Promise<Float32Array[]>;
+    /** Ollama 不支援 generate（僅相容性 stub） */
+    generate(prompt: string): Promise<string>;
+}

package/dist/providers/embedder-v5.js

@@ -0,0 +1,155 @@
+/**
+ * Embedder v5 - Qwen3-Embedding via Ollama (Instruction-Aware)
+ * memory-river v5
+ *
+ * [鐵律] 使用 Ollama 本地部署 Qwen3-Embedding-0.6B
+ * 向量維度：1024（與 Gemini 3072維 不相容，強制使用獨立的 lancedb-v5-qwen）
+ *
+ * Instruction-Aware 前輟綁定：
+ * - 寫入：瑪「Summarize this memory concisely:」
+ * - 讀取：「Retrieve similar memory records from Memory River knowledge base:」
+ */
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+// ── Ollama 全域並發限制（防止大量並發打垮 Ollama）───────────────────────────
+class Semaphore {
+    count;
+    queue = [];
+    constructor(limit) { this.count = limit; }
+    async acquire() {
+        if (this.count > 0) {
+            this.count--;
+            return;
+        }
+        return new Promise(resolve => this.queue.push(resolve));
+    }
+    release() {
+        if (this.queue.length > 0) {
+            this.queue.shift()();
+        }
+        else {
+            this.count++;
+        }
+    }
+}
+const ollamaSemaphore = new Semaphore(4); // 最多 4 路並發
+function chunkArray(arr, size) {
+    const chunks = [];
+    for (let i = 0; i < arr.length; i += size)
+        chunks.push(arr.slice(i, i + size));
+    return chunks;
+}
+export class Embedder {
+    ollamaUrl;
+    model;
+    // v4 相容性欄位（v5 不需要 apiKey，但其他模組有型別預期）
+    apiKey = "";
+    dimensions = 1024;
+    constructor(config) {
+        this.ollamaUrl = config.ollamaUrl;
+        // 綁死 Qwen3 Embedding 模型
+        this.model = config.embeddingModel || "hf.co/Qwen/Qwen3-Embedding-0.6B-GGUF";
+    }
+    /**
+     * 單筆查詢向量化（Instruction-Aware）
+     * @param text 原始查詢文字
+     * @param mode 'store' → "Summarize this memory concisely:" | 'query' → "Retrieve similar..."
+     * @param retries 重試次數
+     */
+    async embed(text, mode = 'query', retries = 3) {
+        const prefix = mode === 'store'
+            ? "Summarize this memory concisely:"
+            : "Retrieve similar memory records from Memory River knowledge base:";
+        await ollamaSemaphore.acquire();
+        try {
+            for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                    const response = await fetch(`${this.ollamaUrl}/api/embeddings`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            model: this.model,
+                            prompt: `${prefix} ${text}`,
+                        }),
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text();
+                        if (response.status === 503 || response.status === 429) {
+                            // 模型尚未載入或被限流，等待後重試
+                            if (attempt < retries) {
+                                const backoff = attempt * 2000;
+                                console.warn(`[Embedder-v5] Ollama returned ${response.status}; retrying in ${backoff}ms... (${attempt}/${retries})`);
+                                await sleep(backoff);
+                                continue;
+                            }
+                        }
+                        throw new Error(`Ollama embedding failed (${response.status}): ${errText}`);
+                    }
+                    const data = await response.json();
+                    if (!data.embedding || !Array.isArray(data.embedding)) {
+                        throw new Error(`Invalid Ollama response: missing embedding field`);
+                    }
+                    return data.embedding;
+                }
+                catch (err) {
+                    if (attempt >= retries)
+                        throw err;
+                    console.warn(`[Embedder-v5] embed() failed (${attempt}/${retries}): ${err.message}`);
+                    await sleep(attempt * 1000);
+                }
+            }
+            throw new Error("Should not reach here");
+        }
+        finally {
+            ollamaSemaphore.release();
+        }
+    }
+    /**
+     * 批次向量化（寫入時使用，無 Instruction-Aware 前輟）
+     * @param texts 字串陣列
+     */
+    async embedBatch(texts, retries = 3) {
+        // Ollama /api/embeddings 只接受單一 prompt 字串，不支援陣列
+        // 改用並發多支 embed() 呼叫，並加 concurrency 控制
+        const BATCH_CONCURRENCY = 4;
+        const results = [];
+        for (let i = 0; i < texts.length; i += BATCH_CONCURRENCY) {
+            const chunk = texts.slice(i, i + BATCH_CONCURRENCY);
+            const embeddings = await Promise.all(chunk.map(text => this.embed(text, 'store', retries)));
+            results.push(...embeddings);
+        }
+        return results;
+    }
+    /** 回報維度 */
+    getDimensions() {
+        return 1024;
+    }
+    /** 回報模型名 */
+    getModel() {
+        return this.model;
+    }
+    /** Ping 測試 */
+    async healthCheck() {
+        try {
+            const response = await fetch(`${this.ollamaUrl}/api/tags`, { method: "GET" });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── v4 相容性包裝 ──────────────────────────────────────
+    /** embed() 的 Float32Array 版本（v4 相容） */
+    async embedText(text) {
+        const vec = await this.embed(text);
+        return new Float32Array(vec);
+    }
+    /** embedBatch() 的 Float32Array 版本（v4 相容） */
+    async embedTextBatch(texts, _concurrency = 5) {
+        const vecs = await this.embedBatch(texts);
+        return vecs.map(v => new Float32Array(v));
+    }
+    /** Ollama 不支援 generate（僅相容性 stub） */
+    async generate(prompt) {
+        throw new Error("[Embedder-v5] generate() 不支援，請使用 Ollama /api/generate 接口");
+    }
+}

package/dist/providers/ollama-embedding.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OllamaEmbeddingFunction - LanceDB 0.14 compatible embedding function
+ * for Qwen3-Embedding via Ollama
+ */
+import { TextEmbeddingFunction } from "@lancedb/lancedb/embedding";
+import { Float32 } from "apache-arrow";
+export declare class OllamaEmbeddingFunction extends TextEmbeddingFunction {
+    private url;
+    private model;
+    private _initialized;
+    constructor(options?: {
+        url?: string;
+        model?: string;
+    });
+    init(): Promise<void>;
+    ndims(): number;
+    toJSON(): object;
+    embeddingDataType(): Float32;
+    /**
+     * generateEmbeddings — LanceDB calls this for source column (store mode)
+     * Uses "Summarize this memory concisely:" prefix
+     */
+    generateEmbeddings(data: string[]): Promise<number[][]>;
+    private _embedOne;
+}

package/dist/providers/ollama-embedding.js

@@ -0,0 +1,166 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+/**
+ * OllamaEmbeddingFunction - LanceDB 0.14 compatible embedding function
+ * for Qwen3-Embedding via Ollama
+ */
+import { TextEmbeddingFunction, register } from "@lancedb/lancedb/embedding";
+import { Float32 } from "apache-arrow";
+const SEMAPHORE_LIMIT = 4;
+// ── Semaphore for Ollama concurrency control ────────────────────────────────
+class Semaphore {
+    count;
+    queue = [];
+    constructor(limit) { this.count = limit; }
+    async acquire() {
+        if (this.count > 0) {
+            this.count--;
+            return;
+        }
+        return new Promise(resolve => this.queue.push(resolve));
+    }
+    release() {
+        if (this.queue.length > 0) {
+            this.queue.shift()();
+        }
+        else {
+            this.count++;
+        }
+    }
+}
+const ollamaSemaphore = new Semaphore(SEMAPHORE_LIMIT);
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ── Ollama Embedding Function ────────────────────────────────────────────────
+let OllamaEmbeddingFunction = (() => {
+    let _classDecorators = [register("ollama")];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = TextEmbeddingFunction;
+    var OllamaEmbeddingFunction = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            OllamaEmbeddingFunction = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        url;
+        model;
+        _initialized = false;
+        constructor(options) {
+            super();
+            this.url = options?.url ?? "http://localhost:11434";
+            this.model = options?.model ?? "hf.co/Qwen/Qwen3-Embedding-0.6B-GGUF";
+        }
+        async init() {
+            this._initialized = true;
+        }
+        ndims() {
+            return 1024;
+        }
+        toJSON() {
+            return {
+                url: this.url,
+                model: this.model,
+            };
+        }
+        embeddingDataType() {
+            // arrow Float32
+            return new Float32();
+        }
+        /**
+         * generateEmbeddings — LanceDB calls this for source column (store mode)
+         * Uses "Summarize this memory concisely:" prefix
+         */
+        async generateEmbeddings(data) {
+            await ollamaSemaphore.acquire();
+            try {
+                const results = [];
+                for (const text of data) {
+                    const embedding = await this._embedOne(text, "store");
+                    results.push(embedding);
+                }
+                return results;
+            }
+            finally {
+                ollamaSemaphore.release();
+            }
+        }
+        async _embedOne(text, mode) {
+            const prefix = mode === "store"
+                ? "Summarize this memory concisely:"
+                : "Retrieve similar memory records from Memory River knowledge base:";
+            for (let attempt = 1; attempt <= 3; attempt++) {
+                try {
+                    const response = await fetch(`${this.url}/api/embeddings`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            model: this.model,
+                            prompt: `${prefix} ${text}`,
+                        }),
+                    });
+                    if (!response.ok) {
+                        const errText = await response.text();
+                        if (response.status === 503 || response.status === 429) {
+                            if (attempt < 3) {
+                                await sleep(attempt * 2000);
+                                continue;
+                            }
+                        }
+                        throw new Error(`Ollama ${response.status}: ${errText}`);
+                    }
+                    const json = await response.json();
+                    if (!json.embedding || !Array.isArray(json.embedding)) {
+                        throw new Error("Missing embedding in response");
+                    }
+                    return json.embedding;
+                }
+                catch (err) {
+                    if (attempt >= 3)
+                        throw err;
+                    await sleep(attempt * 1000);
+                }
+            }
+            throw new Error("unreachable");
+        }
+    };
+    return OllamaEmbeddingFunction = _classThis;
+})();
+export { OllamaEmbeddingFunction };

package/dist/retrieval/abstractness-judge.d.ts

@@ -0,0 +1,14 @@
+export interface AbstractnessJudgement {
+    isAbstract: boolean;
+    abstractness: number;
+    reasons: string[];
+    ruleHits: {
+        entityCount: number;
+        hasMetaNarration: boolean;
+        abstractRatio: number;
+    };
+}
+export declare function countEntities(text: string): number;
+export declare function hasMetaNarration(text: string): boolean;
+export declare function abstractNounRatio(text: string): number;
+export declare function judgeAbstractness(text: string): AbstractnessJudgement;

package/dist/retrieval/abstractness-judge.js

@@ -0,0 +1,87 @@
+const ABSTRACT_STOPWORDS = new Set([
+    '用戶', '使用者', '系統', '工具', '方式', '策略', '場景', '方法', '建議',
+    '錯誤', '問題', '資訊', '資料', '內容', '結果', '過程', '操作', '執行',
+    '功能', '設定', '配置', '流程', '機制', '邏輯', '概念', '應用', '處理',
+    '根據', '調整', '傳遞', '解決', '理解', '指令', '完成', '任務', '類型',
+    '選用', '需要', '描述', '進行', '推理', '成功', '所有',
+]);
+const META_NARRATION_PATTERNS = [
+    /^(用戶|使用者|User)\s*(正在|已|將|想要|開始)/,
+    /^AI\s*(已|將|提供|選用|理解|執行|完成|建議)/,
+    /^系統\s*(已|將|正在|提供|執行)/,
+    /^(模型|Model|LLM)\s*(已|將|提供|選用)/,
+    /(已成功|已完成).{0,15}(任務|流程|操作|執行)$/,
+];
+function isAbstractChineseChunk(word) {
+    for (const stopword of ABSTRACT_STOPWORDS) {
+        if (word.includes(stopword))
+            return true;
+    }
+    return false;
+}
+export function countEntities(text) {
+    let count = 0;
+    count += (text.match(/\d+/g) || []).length;
+    count += (text.match(/(\/[a-zA-Z0-9_\-./]+|[a-zA-Z]:\\[^\s]+)/g) || []).length;
+    count += (text.match(/\b[a-z][a-zA-Z0-9_]*[A-Z][a-zA-Z0-9_]*\b/g) || []).length;
+    count += (text.match(/[a-zA-Z_][a-zA-Z0-9_]*\(\)/g) || []).length;
+    count += (text.match(/[「『"'][^」』"']+[」』"']/g) || []).length;
+    count += (text.match(/\b[A-Z][a-zA-Z0-9]+\b/g) || []).length;
+    const chineseProperNouns = text.match(/[\u4e00-\u9fa5]{2,4}/g) || [];
+    for (const word of chineseProperNouns) {
+        if (!isAbstractChineseChunk(word))
+            count += 0.3;
+    }
+    return Math.floor(count);
+}
+export function hasMetaNarration(text) {
+    return META_NARRATION_PATTERNS.some((pattern) => pattern.test(text));
+}
+export function abstractNounRatio(text) {
+    const tokens = text.match(/[\u4e00-\u9fa5]{2,4}/g) || [];
+    if (tokens.length === 0)
+        return 0;
+    const abstractCount = tokens.filter((token) => isAbstractChineseChunk(token)).length;
+    return abstractCount / tokens.length;
+}
+export function judgeAbstractness(text) {
+    const cleanText = text.replace(/\[#[^\]]+\]/g, '').trim();
+    if (text.trim().length < 15) {
+        return {
+            isAbstract: false,
+            abstractness: 0,
+            reasons: [],
+            ruleHits: { entityCount: 0, hasMetaNarration: false, abstractRatio: 0 },
+        };
+    }
+    const entityCount = countEntities(cleanText);
+    const hasMeta = hasMetaNarration(cleanText);
+    const abstractRatio = abstractNounRatio(cleanText);
+    const reasons = [];
+    if (entityCount < 2)
+        reasons.push('low_entity');
+    if (hasMeta)
+        reasons.push('meta_narration');
+    if (abstractRatio > 0.3)
+        reasons.push('high_abstract_ratio');
+    const isAbstract = entityCount < 2 && (hasMeta || abstractRatio > 0.3);
+    let abstractness = 0;
+    if (entityCount === 0)
+        abstractness += 0.4;
+    else if (entityCount === 1)
+        abstractness += 0.2;
+    if (hasMeta)
+        abstractness += 0.3;
+    abstractness += Math.min(abstractRatio, 0.5) * 0.6;
+    abstractness = Math.min(abstractness, 1.0);
+    return {
+        isAbstract,
+        abstractness,
+        reasons,
+        ruleHits: {
+            entityCount,
+            hasMetaNarration: hasMeta,
+            abstractRatio,
+        },
+    };
+}

package/dist/retrieval/coverage-selection.d.ts

@@ -0,0 +1,3 @@
+export declare function mmrOrder(relevance: number[], vectors: (Float32Array | number[] | null | undefined)[], lambda: number): number[];
+export declare function isCoverageSelectionEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function coverageLambda(env?: NodeJS.ProcessEnv): number;

package/dist/retrieval/coverage-selection.js

@@ -0,0 +1,53 @@
+function cosineNumber(a, b) {
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    const length = Math.min(a.length, b.length);
+    for (let i = 0; i < length; i++) {
+        const av = Number(a[i]);
+        const bv = Number(b[i]);
+        if (!Number.isFinite(av) || !Number.isFinite(bv))
+            continue;
+        dot += av * bv;
+        na += av * av;
+        nb += bv * bv;
+    }
+    const denom = Math.sqrt(na) * Math.sqrt(nb);
+    return denom > 0 ? dot / denom : 0;
+}
+export function mmrOrder(relevance, vectors, lambda) {
+    const lo = Math.min(...relevance);
+    const hi = Math.max(...relevance);
+    const rel = relevance.map(value => (hi > lo ? (value - lo) / (hi - lo) : 0));
+    const selected = [];
+    const remaining = new Set(relevance.map((_, index) => index));
+    while (remaining.size > 0) {
+        let best = -1;
+        let bestScore = Number.NEGATIVE_INFINITY;
+        for (const index of remaining) {
+            let maxSim = 0;
+            for (const chosen of selected) {
+                const sim = cosineNumber(vectors[index], vectors[chosen]);
+                if (sim > maxSim)
+                    maxSim = sim;
+            }
+            const score = lambda * rel[index] - (1 - lambda) * maxSim;
+            if (score > bestScore || (score === bestScore && index < best)) {
+                bestScore = score;
+                best = index;
+            }
+        }
+        selected.push(best);
+        remaining.delete(best);
+    }
+    return selected;
+}
+export function isCoverageSelectionEnabled(env = process.env) {
+    return env.MR_COVERAGE_SELECTION === "1";
+}
+export function coverageLambda(env = process.env) {
+    const parsed = Number(env.MR_COVERAGE_LAMBDA);
+    return Number.isFinite(parsed) ? parsed : 0.5;
+}

package/dist/retrieval/cross-encoder-gate.d.ts

@@ -0,0 +1,40 @@
+export interface CrossEncoderGateCandidate {
+    entry: {
+        text: string;
+    };
+    fusedScore?: number;
+    finalScore?: number;
+}
+export interface RerankPair {
+    query: string;
+    passage: string;
+}
+export interface CrossEncoderScorer {
+    scorePairs(pairs: RerankPair[]): Promise<{
+        logits: number[];
+    }>;
+}
+export interface CrossEncoderGateOptions {
+    env?: NodeJS.ProcessEnv;
+    cacheDir?: string;
+    modelDir?: string;
+    topK?: number;
+    scorer?: CrossEncoderScorer;
+    logger?: Pick<Console, "warn" | "log">;
+}
+export interface ScoredCandidate<T extends CrossEncoderGateCandidate> {
+    candidate: T;
+    logit: number;
+}
+export interface ScoreCandidatesResult<T extends CrossEncoderGateCandidate> {
+    scored: ScoredCandidate<T>[];
+    timingMs: number;
+}
+export declare function isCragCrossEncoderGateEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function containsCjk(text: string): boolean;
+export declare function cragGateThresholdForText(query: string, passage: string, env?: NodeJS.ProcessEnv): number;
+export declare function cragGateTopK(env?: NodeJS.ProcessEnv): number;
+export declare function scoreCandidates<T extends CrossEncoderGateCandidate>(query: string, candidates: T[], options?: CrossEncoderGateOptions): Promise<ScoreCandidatesResult<T> | null>;
+export declare function applyCragCrossEncoderGate<T extends CrossEncoderGateCandidate>(query: string, candidates: T[], options?: CrossEncoderGateOptions): Promise<T[]>;
+export declare function __setCragCrossEncoderScorerForTests(scorer: CrossEncoderScorer | null): void;
+export declare function __resetCragCrossEncoderForTests(): void;