@adonis-agora/agent/dist/src/testing/fake-embedding-provider.d.ts

Governed, durable-backed AI agent (chat + tool-calling + governance) for AdonisJS — part of the Agora ecosystem.

import { EmbeddingRetriever } from '../rag/embedding-retriever.js';
import { type IngestDocument } from '../rag/ingest.js';
import type { EmbeddingProvider, EmbeddingResult } from '../spi/embedding-provider.js';
import type { Reranker, RerankOptions } from '../spi/reranker.js';
import type { Passage } from '../spi/retriever.js';
/**
 * A deterministic, offline {@link EmbeddingProvider} — no API key, no network. Each text is embedded as
 * a fixed-length bag-of-words vector: every whitespace/punctuation-delimited token is lower-cased and
 * hashed into a dimension whose count it increments. Texts that share words land close under cosine
 * similarity, so retrieval ranks the relevant chunk first, while the mapping stays a pure function of
 * the input (replay-safe, reproducible across runs). Mirrors the reference deterministic fake.
 */
export declare class FakeEmbeddingProvider implements EmbeddingProvider {
    private readonly dimensions;
    private readonly reportUsage;
    /**
     * @param dimensions tamanho do vetor.
     * @param reportUsage se deve reportar consumo. Default `true`, para que o caminho contabilizado
     *   seja o que os testes exercitam por padrão. Passe `false` para dublar um provider ANTIGO, sem
     *   `embedWithUsage` — é assim que se prova que o fallback continua de pé.
     */
    constructor(dimensions?: number, reportUsage?: boolean);
    embed(texts: string[]): Promise<number[][]>;
    embedWithUsage(texts: string[]): Promise<EmbeddingResult>;
    private embedOne;
}
/**
 * A deterministic hashed bag-of-words {@link EmbeddingProvider}: Unicode tokens (runs of any letter or
 * digit, so "coração" and "東京" stay whole), FNV-1a buckets, L2-normalized. No model and no network —
 * similar *wording* ranks close, meaning does not. For tests, and for a "no embedding model configured"
 * dev mode that still exercises ingest → embed → retrieve end to end. Reports one token per word as
 * usage (model `hashed-<dimensions>`), so the accounted path runs too.
 *
 * ```ts
 * retriever: retrievers.pgvector({ embedder: hashedEmbeddings(256), dimension: 256 })
 * ```
 */
export declare function hashedEmbeddings(dimensions?: number): EmbeddingProvider;
/**
 * A deterministic, offline {@link Reranker} for tests: re-scores each passage by how many distinct
 * query terms it contains (lexical overlap), then sorts descending and truncates to `topK`. No model,
 * no randomness — enough to prove {@link import('../rag/reranking-retriever.js').RerankingRetriever}
 * genuinely RE-ORDERS candidates (not just truncates) against a known-relevant passage. Stands in for a
 * real cross-encoder rerank endpoint (provider impls deferred this round). Mirrors the reference fake.
 */
export declare class FakeReranker implements Reranker {
    rerank(query: string, passages: Passage[], options?: RerankOptions): Promise<Passage[]>;
}
/**
 * Build a ready-to-use in-memory {@link EmbeddingRetriever} for tests: a {@link MemoryVectorStore} fed
 * by the given (or a fresh {@link FakeEmbeddingProvider}) embedder, with `documents` ingested. Wire the
 * result as the config's `retriever` to exercise inject-mode retrieval offline.
 */
export declare function inMemoryRetriever(options: {
    documents?: IngestDocument[];
    embedder?: EmbeddingProvider;
    chunkSize?: number;
    overlap?: number;
}): Promise<EmbeddingRetriever>;
//# sourceMappingURL=fake-embedding-provider.d.ts.map