@arnilo/prism-rag 0.3.0 → 0.3.2

package/dist/retrieve.js

@@ -1,14 +1,15 @@
 import { resolveRedactor } from "@arnilo/prism";
-import { RagScopeError, RagValidationError } from "./errors.js";
-import { HARD_CHUNK_SIZE_CAP, resolveRagLimits } from "./limits.js";
+import { RagError, RagLimitError, RagScopeError, RagValidationError } from "./errors.js";
+import { fuseReciprocalRankLists } from "./fusion.js";
+import { HARD_CHUNK_SIZE_CAP, HARD_RETRIEVE_SCOPE_CAP, resolveRagLimits } from "./limits.js";
 import { rerankHits } from "./rerank.js";
-import { assertBytes, assertNotAborted, assertScope, byteLength, isJsonObject, matchesFilter, nonEmpty, requireScope, requireSourceId, truncateUtf8, } from "./util.js";
+import { assertBytes, assertNotAborted, byteLength, isJsonObject, matchesFilter, nonEmpty, requireScope, requireSourceId, truncateUtf8, } from "./util.js";
 const RETRIEVED_CONTENT_TRUST = Object.freeze({ untrusted: true, inert: true, injectionCapable: true });
 export async function retrieveContext(query, options) {
     nonEmpty(query, "query");
     if (query.length > HARD_CHUNK_SIZE_CAP)
         throw new RagValidationError(`query exceeds ${HARD_CHUNK_SIZE_CAP} characters`);
-    const scope = requireScope(options.scope);
+    const scopes = resolveRetrieveScopes(options);
     const limits = resolveRagLimits({
         topK: options.topK,
         queryCandidates: options.queryCandidates,
@@ -19,6 +20,7 @@ export async function retrieveContext(query, options) {
         maxRerankBytes: options.maxRerankBytes,
         maxRerankMs: options.maxRerankMs,
         rerankConcurrency: options.rerankConcurrency,
+        rrfK: options.rrfK,
     });
     if (!Number.isInteger(options.embedder.dimensions) ||
         options.embedder.dimensions <= 0 ||
@@ -27,100 +29,220 @@ export async function retrieveContext(query, options) {
     }
     if (options.filter)
         assertBytes(options.filter, limits.maxMetadataBytes, "metadata filter");
-    const redactor = resolveRedactor(options.redactor, options.secrets);
-    const safeQuery = redactor?.redact(query) ?? query;
-    assertNotAborted(options.signal);
-    const vectors = await options.embedder.embed([safeQuery], { signal: options.signal });
-    const embedding = vectors[0];
-    if (vectors.length !== 1 ||
-        !embedding ||
-        embedding.length !== options.embedder.dimensions ||
-        embedding.some((value) => !Number.isFinite(value))) {
-        throw new RagValidationError("embedder returned invalid query vector");
+    const lexical = options.lexical ?? (options.store.lexicalQuery ? "fts" : "off");
+    if (lexical !== "fts" && lexical !== "bm25" && lexical !== "off") {
+        throw new RagValidationError('lexical must be "fts", "bm25", or "off"');
     }
-    const candidates = await options.store.query({
-        tenantId: scope.tenantId,
-        resourceId: scope.resourceId,
-        threadId: scope.corpusId,
-        embedding,
-        topK: limits.queryCandidates,
-        signal: options.signal,
-    });
-    assertNotAborted(options.signal);
-    const retrievedAt = new Date().toISOString();
-    const retrieved = [];
-    for (const candidate of candidates.slice(0, limits.queryCandidates)) {
-        assertScope(scope, candidate);
-        const parsed = parseHit(candidate, retrieved.length, retrievedAt);
-        if (!matchesFilter(parsed.metadata, options.filter))
-            continue;
-        retrieved.push(Object.freeze(redactor?.redact(parsed) ?? parsed));
+    if (options.fusion !== undefined && options.fusion !== "rrf") {
+        throw new RagValidationError('fusion must be "rrf"');
+    }
+    if (lexical !== "off" && !options.store.lexicalQuery) {
+        throw new RagValidationError(`lexical "${lexical}" requested but the store has no lexicalQuery capability`);
+    }
+    if (lexical === "bm25" && !options.store.lexicalModes?.includes("bm25")) {
+        throw new RagValidationError('lexical "bm25" requested but the store does not declare BM25 support');
     }
-    const ranked = options.reranker
-        ? await rerankHits(safeQuery, retrieved, {
-            reranker: options.reranker,
-            maxBytes: limits.maxRerankBytes,
-            maxMs: limits.maxRerankMs,
-            concurrency: limits.rerankConcurrency,
-            signal: options.signal,
-            redactor: options.redactor,
-            secrets: options.secrets,
-        })
-        : retrieved;
-    const hits = [];
-    const citations = [];
-    const rendered = [];
-    const maxChars = limits.maxContextTokens * 4;
-    let usedBytes = 0;
-    let usedChars = 0;
-    let truncated = false;
-    for (const hit of ranked) {
-        if (hits.length >= limits.topK)
-            break;
-        const prefix = `[${hit.citationId}] `;
-        const separator = rendered.length ? "\n\n" : "";
-        const availableBytes = limits.maxResultBytes - usedBytes - byteLength(separator + prefix);
-        const availableChars = maxChars - usedChars - separator.length - prefix.length;
-        if (availableBytes <= 0 || availableChars <= 0) {
-            truncated = true;
-            break;
+    const useLexical = lexical !== "off";
+    const redactor = resolveRedactor(options.redactor, options.secrets);
+    const telemetry = options.telemetry;
+    const root = telemetry?.startSpan("rag_request", {
+        ...(scopes[0] ? { "rag.scope.tenant_id": scopes[0].tenantId } : {}),
+        "rag.scope_count": scopes.length,
+        "rag.embedder_id": options.embedder.id,
+        "rag.top_k": limits.topK,
+        "rag.lexical_mode": lexical,
+    });
+    try {
+        const safeQuery = redactor?.redact(query) ?? query;
+        assertNotAborted(options.signal);
+        if (scopes.length === 0) {
+            return emptyResult(safeQuery);
+        }
+        if (scopes.length === 1) {
+            const currentGeneration = await options.store.getCurrentGeneration?.({
+                tenantId: scopes[0].tenantId,
+                resourceId: scopes[0].resourceId,
+                threadId: scopes[0].corpusId,
+            });
+            if (currentGeneration !== undefined)
+                root?.setAttribute("rag.index_generation", Number(currentGeneration));
+        }
+        const vectors = await span(telemetry, "embedding.query", undefined, root, () => options.embedder.embed([safeQuery], { signal: options.signal }));
+        const embedding = vectors[0];
+        if (vectors.length !== 1 ||
+            !embedding ||
+            embedding.length !== options.embedder.dimensions ||
+            embedding.some((value) => !Number.isFinite(value))) {
+            throw new RagValidationError("embedder returned invalid query vector");
         }
-        let text = hit.text.slice(0, availableChars);
-        text = truncateUtf8(text, availableBytes);
-        if (!text) {
-            truncated = true;
-            break;
+        const vectorLists = [];
+        await span(telemetry, "retrieval.vector_search", undefined, root, async (leg) => {
+            let total = 0;
+            for (const scope of scopes) {
+                assertNotAborted(options.signal);
+                const found = await options.store.query({
+                    tenantId: scope.tenantId,
+                    resourceId: scope.resourceId,
+                    threadId: scope.corpusId,
+                    embedding,
+                    topK: limits.queryCandidates,
+                    signal: options.signal,
+                });
+                const sliced = found.slice(0, limits.queryCandidates);
+                vectorLists.push(sliced);
+                total += sliced.length;
+            }
+            leg?.setAttribute("rag.vector_candidates", total);
+        });
+        const lexicalLists = [];
+        if (useLexical && options.store.lexicalQuery) {
+            await span(telemetry, "retrieval.lexical", undefined, root, async (leg) => {
+                let total = 0;
+                for (const scope of scopes) {
+                    assertNotAborted(options.signal);
+                    const found = await options.store.lexicalQuery({
+                        tenantId: scope.tenantId,
+                        resourceId: scope.resourceId,
+                        threadId: scope.corpusId,
+                        text: safeQuery,
+                        topK: limits.queryCandidates,
+                        signal: options.signal,
+                    });
+                    const sliced = found.slice(0, limits.queryCandidates);
+                    lexicalLists.push(sliced);
+                    total += sliced.length;
+                }
+                leg?.setAttribute("rag.lexical_candidates", total);
+            });
+        }
+        const retrievedAt = new Date().toISOString();
+        const retrieved = [];
+        const fused = await span(telemetry, "retrieval.fusion", undefined, root, (fusion) => {
+            const lists = [
+                ...vectorLists.map((hits) => ({ hits, leg: "vector" })),
+                ...lexicalLists.map((hits) => ({ hits, leg: "lexical" })),
+            ];
+            const fusedCandidates = fuseReciprocalRankLists(lists, limits.rrfK);
+            fusion?.setAttribute("rag.fused_candidates", fusedCandidates.length);
+            return fusedCandidates;
+        });
+        for (const { hit: candidate, retrieval } of fused) {
+            assertRequestedScope(scopes, candidate);
+            if (candidate.embedderId === undefined) {
+                throw new RagError(`stored record ${candidate.id} has no embedderId; re-index the source to stamp embedder identity`, "ERR_PRISM_RAG_EMBEDDER_MISMATCH");
+            }
+            if (candidate.embedderId !== options.embedder.id || candidate.embedding.length !== options.embedder.dimensions) {
+                throw new RagError(`embedder mismatch: record ${candidate.id} was embedded by "${candidate.embedderId}" (${candidate.embedding.length} dims) but the query embedder is "${options.embedder.id}" (${options.embedder.dimensions} dims)`, "ERR_PRISM_RAG_EMBEDDER_MISMATCH");
+            }
+            const parsed = parseHit(candidate, retrieved.length, retrievedAt, retrieval);
+            if (!matchesFilter(parsed.metadata, options.filter))
+                continue;
+            retrieved.push(Object.freeze(redactor?.redact(parsed) ?? parsed));
+        }
+        const reranker = options.reranker;
+        const ranked = reranker
+            ? await span(telemetry, "retrieval.rerank", undefined, root, () => rerankHits(safeQuery, retrieved, {
+                reranker,
+                maxBytes: limits.maxRerankBytes,
+                maxMs: limits.maxRerankMs,
+                concurrency: limits.rerankConcurrency,
+                signal: options.signal,
+                redactor: options.redactor,
+                secrets: options.secrets,
+            }))
+            : retrieved;
+        const hits = [];
+        const citations = [];
+        const rendered = [];
+        const maxChars = limits.maxContextTokens * 4;
+        let usedBytes = 0;
+        let usedChars = 0;
+        let truncated = false;
+        const assemblySpan = telemetry?.startSpan("prompt.assembly", undefined, root);
+        for (const hit of ranked) {
+            if (hits.length >= limits.topK)
+                break;
+            const prefix = `[${hit.citationId}] `;
+            const separator = rendered.length ? "\n\n" : "";
+            const availableBytes = limits.maxResultBytes - usedBytes - byteLength(separator + prefix);
+            const availableChars = maxChars - usedChars - separator.length - prefix.length;
+            if (availableBytes <= 0 || availableChars <= 0) {
+                truncated = true;
+                break;
+            }
+            let text = hit.text.slice(0, availableChars);
+            text = truncateUtf8(text, availableBytes);
+            if (!text) {
+                truncated = true;
+                break;
+            }
+            if (text.length < hit.text.length)
+                truncated = true;
+            const renderedHit = Object.freeze({ ...hit, text });
+            const citation = Object.freeze({
+                id: renderedHit.citationId,
+                sourceId: renderedHit.sourceId,
+                chunkId: renderedHit.id,
+                provenance: renderedHit.provenance,
+                trust: renderedHit.trust,
+                ...(renderedHit.metadata ? { metadata: renderedHit.metadata } : {}),
+            });
+            const block = `${separator}${prefix}${text}`;
+            rendered.push(block);
+            usedBytes += byteLength(block);
+            usedChars += block.length;
+            hits.push(renderedHit);
+            citations.push(citation);
+            if (truncated)
+                break;
+        }
+        assemblySpan?.setAttribute("rag.result_count", hits.length);
+        assemblySpan?.end();
+        for (const hit of hits) {
+            root?.addEvent("chunk_retrieved", {
+                "rag.chunk.source_id": hit.sourceId,
+                "rag.chunk.id": hit.id,
+                "rag.chunk.rank": hit.retrievalRank,
+                "rag.chunk.score": hit.score,
+                "rag.chunk.embedder_id": options.embedder.id,
+                "rag.chunk.tenant_id": hit.provenance.tenantId,
+                "rag.chunk.corpus_id": hit.provenance.corpusId,
+            });
         }
-        if (text.length < hit.text.length)
-            truncated = true;
-        const renderedHit = Object.freeze({ ...hit, text });
-        const citation = Object.freeze({
-            id: renderedHit.citationId,
-            sourceId: renderedHit.sourceId,
-            chunkId: renderedHit.id,
-            provenance: renderedHit.provenance,
-            trust: renderedHit.trust,
-            ...(renderedHit.metadata ? { metadata: renderedHit.metadata } : {}),
+        return Object.freeze({
+            query: safeQuery,
+            trust: RETRIEVED_CONTENT_TRUST,
+            text: rendered.join(""),
+            hits: Object.freeze(hits),
+            citations: Object.freeze(citations),
+            truncated,
         });
-        const block = `${separator}${prefix}${text}`;
-        rendered.push(block);
-        usedBytes += byteLength(block);
-        usedChars += block.length;
-        hits.push(renderedHit);
-        citations.push(citation);
-        if (truncated)
-            break;
     }
-    return Object.freeze({
-        query: safeQuery,
-        trust: RETRIEVED_CONTENT_TRUST,
-        text: rendered.join(""),
-        hits: Object.freeze(hits),
-        citations: Object.freeze(citations),
-        truncated,
-    });
+    catch (error) {
+        root?.recordError();
+        throw error;
+    }
+    finally {
+        root?.end();
+    }
+}
+/** Opens a child span only when telemetry is present; otherwise runs the section untouched. */
+async function span(telemetry, name, attributes, parent, fn) {
+    if (!telemetry)
+        return await fn(undefined);
+    const child = telemetry.startSpan(name, attributes, parent);
+    try {
+        return await fn(child);
+    }
+    catch (error) {
+        child.recordError();
+        throw error;
+    }
+    finally {
+        child.end();
+    }
 }
-function parseHit(hit, retrievalRank, retrievedAt) {
+function parseHit(hit, retrievalRank, retrievedAt, retrieval) {
     const metadata = hit.metadata;
     const rag = metadata?._rag;
     if (!isJsonObject(rag))
@@ -144,7 +266,17 @@ function parseHit(hit, retrievalRank, retrievedAt) {
             userMetadata[key] = value;
     const web = isJsonObject(userMetadata.web) ? userMetadata.web : undefined;
     const provider = typeof web?.provider === "string" && web.provider.trim() ? web.provider : "host";
-    const provenance = Object.freeze({ sourceId, chunkId: hit.id, citationId, provider, retrieval: "vector", retrievedAt });
+    const provenance = Object.freeze({
+        sourceId,
+        chunkId: hit.id,
+        citationId,
+        provider,
+        tenantId: hit.tenantId,
+        resourceId: hit.resourceId,
+        corpusId: hit.threadId,
+        retrieval,
+        retrievedAt,
+    });
     return {
         id: hit.id,
         citationId,
@@ -160,4 +292,42 @@ function parseHit(hit, retrievalRank, retrievedAt) {
         ...(Object.keys(userMetadata).length ? { metadata: userMetadata } : {}),
     };
 }
+function resolveRetrieveScopes(options) {
+    const hasScope = options.scope !== undefined;
+    const hasScopes = options.scopes !== undefined;
+    if (hasScope && hasScopes)
+        throw new RagValidationError("provide either scope or scopes, not both");
+    if (!hasScope && !hasScopes)
+        throw new RagValidationError("scope or scopes is required");
+    const raw = hasScopes ? options.scopes : [options.scope];
+    if (raw.length > HARD_RETRIEVE_SCOPE_CAP)
+        throw new RagLimitError(`scopes exceeds hard cap ${HARD_RETRIEVE_SCOPE_CAP}`);
+    const seen = new Set();
+    const resolved = [];
+    for (const item of raw) {
+        const scope = requireScope(item);
+        const key = `${scope.tenantId}${scope.resourceId}${scope.corpusId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        resolved.push(scope);
+    }
+    return resolved;
+}
+function assertRequestedScope(scopes, actual) {
+    if (scopes.some((scope) => scope.tenantId === actual.tenantId && scope.resourceId === actual.resourceId && scope.corpusId === actual.threadId)) {
+        return;
+    }
+    throw new RagScopeError("vector hit crossed tenant/resource/corpus boundary");
+}
+function emptyResult(query) {
+    return Object.freeze({
+        query,
+        trust: RETRIEVED_CONTENT_TRUST,
+        text: "",
+        hits: Object.freeze([]),
+        citations: Object.freeze([]),
+        truncated: false,
+    });
+}
 //# sourceMappingURL=retrieve.js.map

package/dist/sources.d.ts

@@ -3,6 +3,8 @@ export interface SourceMutationResult {
     readonly sourceId: string;
     readonly deleted: number;
     readonly indexed: number;
+    /** Set when an unchanged document hash short-circuited the replace. */
+    readonly skipped?: true;
 }
 export declare function replaceSource(options: ReplaceSourceOptions): Promise<SourceMutationResult>;
 export declare function deleteSource(options: DeleteSourceOptions): Promise<SourceMutationResult>;

package/dist/sources.js

@@ -1,9 +1,14 @@
 import { resolveRedactor } from "@arnilo/prism";
 import { chunkText } from "./chunk.js";
 import { RagScopeError, RagValidationError } from "./errors.js";
+import { isValidContentHash } from "./hash.js";
 import { indexChunkBatches } from "./indexing.js";
 import { ingestionStatus } from "./ingestion-status.js";
 import { assertNotAborted, byteLength, requireScope, requireSourceId } from "./util.js";
+function storedDocHash(record) {
+    const value = record.metadata?._rag?.contentHash;
+    return isValidContentHash(value) ? value : undefined;
+}
 export async function replaceSource(options) {
     const sourceId = requireSourceId(options.sourceId);
     const scope = requireScope(options.scope);
@@ -12,6 +17,10 @@ export async function replaceSource(options) {
         throw new RagValidationError("replaceSource chunks must all belong to sourceId");
     }
     const redactor = resolveRedactor(options.redactor, options.secrets);
+    if (options.contentHash !== undefined && !isValidContentHash(options.contentHash)) {
+        throw new RagValidationError("contentHash must be a hex digest of 32..128 characters");
+    }
+    const contentHash = options.contentHash?.toLowerCase();
     const totalBytes = options.chunks.reduce((total, chunk) => total + byteLength(redactor?.redact(chunk.text) ?? chunk.text), 0);
     const setStatus = async (state, error) => {
         if (!options.statusStore)
@@ -20,29 +29,82 @@ export async function replaceSource(options) {
         await options.statusStore.set(ingestionStatus(scope, sourceId, state, state === "indexed" ? totalBytes : 0, state === "indexed" ? options.chunks.length : 0, message ? (redactor?.redact(message) ?? message) : undefined));
     };
     await setStatus("pending");
+    const telemetry = options.telemetry;
+    const root = telemetry?.startSpan("rag_index", {
+        "rag.scope.tenant_id": scope.tenantId,
+        "rag.source_id": sourceId,
+        "rag.embedder_id": options.embedder.id,
+        "rag.chunk_count": options.chunks.length,
+    });
     try {
+        // One read decides the skip; unchanged sources cost zero embeds and zero writes.
+        const previous = await sourceRecords(options.store, sourceId, scope, options.signal);
+        if (contentHash &&
+            options.skipIfUnchanged !== false &&
+            previous.length > 0 &&
+            previous.every((record) => storedDocHash(record) === contentHash)) {
+            // Incoming stats describe the now-live content even though nothing was rewritten.
+            await setStatus("indexed", undefined);
+            return Object.freeze({ sourceId, deleted: 0, indexed: 0, skipped: true });
+        }
+        const reuseEmbeddings = new Map();
+        if (options.skipIfUnchanged !== false) {
+            // skipIfUnchanged: false means rebuild everything — no embedding reuse either.
+            for (const record of previous) {
+                if (record.embedderId === options.embedder.id) {
+                    reuseEmbeddings.set(record.id, { text: record.text, embedding: record.embedding });
+                }
+            }
+        }
         const staged = [];
-        const indexed = await indexChunkBatches({ ...options, statusStore: undefined }, async (records) => {
+        const indexed = await indexChunkBatches({ ...options, statusStore: undefined, contentHash, reuseEmbeddings, telemetry, telemetryParent: root }, async (records) => {
             staged.push(...records);
         });
         assertNotAborted(options.signal);
         const result = await options.store.transaction(async (store) => {
+            // Generation visibility: stamp chunks at N+1 and advance the scope pointer in the
+            // same transaction as the swap. Stores without generation tracking keep legacy behavior.
+            const getCurrent = store.getCurrentGeneration?.bind(store);
+            const setCurrent = store.setCurrentGeneration?.bind(store);
+            let nextGeneration;
+            if (getCurrent && setCurrent) {
+                const current = await getCurrent({
+                    tenantId: scope.tenantId,
+                    resourceId: scope.resourceId,
+                    threadId: scope.corpusId,
+                });
+                nextGeneration = (current === undefined ? 0 : Number(current)) + 1;
+                root?.setAttribute("rag.index_generation", nextGeneration);
+            }
             const previous = await sourceRecords(store, sourceId, scope, options.signal);
             assertNotAborted(options.signal);
             if (previous.length) {
                 await store.delete({ tenantId: scope.tenantId, resourceId: scope.resourceId, threadId: scope.corpusId, ids: previous.map((record) => record.id) }, { signal: options.signal });
             }
-            if (staged.length)
-                await store.upsert(staged, { signal: options.signal });
+            if (staged.length) {
+                const stamped = nextGeneration === undefined ? staged : staged.map((record) => ({ ...record, generation: nextGeneration }));
+                await store.upsert(stamped, { signal: options.signal });
+            }
+            if (setCurrent && nextGeneration !== undefined) {
+                await setCurrent({
+                    tenantId: scope.tenantId,
+                    resourceId: scope.resourceId,
+                    threadId: scope.corpusId,
+                }, nextGeneration);
+            }
             return Object.freeze({ sourceId, deleted: previous.length, indexed: indexed.indexed });
         }, { signal: options.signal });
         await setStatus("indexed");
         return result;
     }
     catch (error) {
+        root?.recordError();
         await setStatus("failed", error);
         throw error;
     }
+    finally {
+        root?.end();
+    }
 }
 export async function deleteSource(options) {
     const sourceId = requireSourceId(options.sourceId);

package/dist/tei-reranker.d.ts

@@ -0,0 +1,35 @@
+import { type SsrfPolicy } from "@arnilo/prism";
+import type { Reranker } from "./types.js";
+/**
+ * Hugging Face TEI rerank adapter (plan 034 Task 8 / request P8):
+ * `POST <baseUrl>/rerank` with `{query, texts, raw_scores:false}` →
+ * `{results: [{index, score}]}` mapped to a permutation-only reorder of the
+ * provided `RagHit[]` (same object references — provenance/trust untouched).
+ *
+ * - URL shape validated at construction (absolute, http/https, no embedded
+ *   credentials or fragment); SSRF/enforcement is host-side via `ssrf`,
+ *   `allowLoopback`, or an injected `fetch`. Default transport is the core
+ *   `pinnedFetch` primitive (DNS-pinned, redirect-free, byte-bounded).
+ * - Out-of-range/duplicate/missing indices, non-finite scores, HTTP errors,
+ *   timeouts, and oversized bodies all fail closed in the rerank error
+ *   family. Seam caps (`maxRerankBytes`, `maxRerankMs`, `rerankConcurrency`)
+ *   stay enforced by `rerankHits` around this adapter.
+ * - No credentials, no SaaS default URL.
+ */
+export interface CreateTeiRerankerOptions {
+    /** Base URL of the TEI service, e.g. `http://tei.svc:8080`. `/rerank` is appended. */
+    readonly baseUrl: string;
+    /** Optional model name sent in the rerank body. */
+    readonly model?: string;
+    /** Per-call timeout combined with the caller signal; aborts fail closed. */
+    readonly timeoutMs?: number;
+    /** SSRF policy applied on resolved hosts (default: core default). */
+    readonly ssrf?: SsrfPolicy;
+    /** Allow loopback destinations (local/dev TEI). Default `false`. */
+    readonly allowLoopback?: boolean;
+    /** Maximum response body bytes. Default 65,536 (plan 021 ceiling precedent). */
+    readonly maxResponseBytes?: number;
+    /** Trusted custom transport; host owns DNS/Bonding protection (OPA precedent). */
+    readonly fetch?: typeof globalThis.fetch;
+}
+export declare function createTeiReranker(options: CreateTeiRerankerOptions): Reranker;