@lov3kaizen/agentsea-embeddings 0.5.1

package/dist/index-DMaQRn2w.d.mts

@@ -0,0 +1,172 @@
+type ChunkingStrategyType = 'fixed' | 'semantic' | 'recursive' | 'markdown' | 'code' | 'sentence' | 'paragraph' | 'custom';
+interface Chunk {
+    id: string;
+    text: string;
+    index: number;
+    startPosition: number;
+    endPosition: number;
+    tokenCount: number;
+    charCount: number;
+    overlapPrev: number;
+    overlapNext: number;
+    metadata: ChunkingMetadata;
+}
+interface ChunkingMetadata {
+    documentId?: string;
+    source?: string;
+    type?: string;
+    page?: number;
+    section?: string;
+    language?: string;
+    boundaryType?: string;
+    [key: string]: unknown;
+}
+interface ChunkingOptions {
+    chunkSize?: number;
+    chunkOverlap?: number;
+    minChunkSize?: number;
+    maxChunkSize?: number;
+    tokenCounter?: (text: string) => number;
+    documentId?: string;
+    source?: string;
+    type?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FixedChunkingOptions extends ChunkingOptions {
+    splitByChars?: boolean;
+    separator?: string;
+    keepSeparator?: boolean;
+}
+interface SemanticChunkingOptions extends ChunkingOptions {
+    similarityThreshold?: number;
+    embeddingFn?: (texts: string[]) => Promise<number[][]>;
+    breakpointPercentileThreshold?: number;
+    bufferSize?: number;
+}
+interface RecursiveChunkingOptions extends ChunkingOptions {
+    separators?: string[];
+    keepSeparator?: boolean;
+    mergeSmallChunks?: boolean;
+}
+interface MarkdownChunkingOptions extends ChunkingOptions {
+    preserveHeaders?: boolean;
+    includeHeaderHierarchy?: boolean;
+    headingLevels?: number[];
+    splitCodeBlocks?: boolean;
+    preserveLinks?: boolean;
+}
+interface CodeChunkingOptions extends ChunkingOptions {
+    language?: string;
+    autoDetectLanguage?: boolean;
+    splitBy?: 'function' | 'class' | 'module' | 'auto';
+    includeComments?: boolean;
+    includeImports?: boolean;
+    includeTypeDefinitions?: boolean;
+}
+interface SentenceChunkingOptions extends ChunkingOptions {
+    combineSentences?: boolean;
+    sentenceBoundary?: RegExp;
+    minSentences?: number;
+}
+interface ParagraphChunkingOptions extends ChunkingOptions {
+    combineParagraphs?: boolean;
+    paragraphBoundary?: RegExp;
+    minParagraphs?: number;
+}
+interface ChunkingResult {
+    chunks: Chunk[];
+    totalChunks: number;
+    totalTokens: number;
+    avgChunkSize: number;
+    processingTimeMs: number;
+    strategy: ChunkingStrategyType;
+    originalLength: number;
+}
+interface ChunkingStats {
+    documentsProcessed: number;
+    chunksCreated: number;
+    tokensProcessed: number;
+    avgChunksPerDocument: number;
+    avgTokensPerChunk: number;
+    strategyDistribution: Record<ChunkingStrategyType, number>;
+}
+interface ChunkingStrategyConfig {
+    type: ChunkingStrategyType;
+    options: ChunkingOptions;
+    description?: string;
+}
+type CustomChunkingFn = (text: string, options: ChunkingOptions) => Promise<Chunk[]> | Chunk[];
+type TokenCounterFn = (text: string) => number;
+type TextSplitterFn = (text: string, separator: string) => string[];
+
+declare const defaultTokenCounter: TokenCounterFn;
+declare abstract class BaseChunker {
+    abstract readonly strategyType: ChunkingStrategyType;
+    protected defaultOptions: ChunkingOptions;
+    abstract chunk(text: string, options?: ChunkingOptions): Promise<Chunk[]>;
+    protected getOptions(options?: ChunkingOptions): ChunkingOptions & {
+        chunkSize: number;
+        chunkOverlap: number;
+        minChunkSize: number;
+        maxChunkSize: number;
+        tokenCounter: (text: string) => number;
+        metadata: Record<string, unknown>;
+    };
+    protected createChunk(text: string, index: number, startPosition: number, options: ChunkingOptions, additionalMetadata?: Record<string, unknown>): Chunk;
+    protected setOverlapInfo(chunks: Chunk[], overlapChars: number): void;
+    protected splitWithOverlap(text: string, chunkSize: number, overlap: number, tokenCounter: TokenCounterFn): string[];
+    chunkWithResult(text: string, options?: ChunkingOptions): Promise<ChunkingResult>;
+}
+declare function mergeSmallChunks(chunks: Chunk[], minTokens: number, tokenCounter: TokenCounterFn): Chunk[];
+declare function splitLargeChunks(chunks: Chunk[], maxTokens: number, tokenCounter: TokenCounterFn): Chunk[];
+
+declare class FixedChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: FixedChunkingOptions): Promise<Chunk[]>;
+    private getOverlapText;
+}
+declare function createFixedChunker(): FixedChunker;
+
+declare class RecursiveChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: RecursiveChunkingOptions): Promise<Chunk[]>;
+    private splitRecursively;
+    private splitBySeparator;
+    private splitByChars;
+    private addOverlap;
+    private getEndOverlap;
+}
+declare function createRecursiveChunker(): RecursiveChunker;
+
+declare class MarkdownChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: MarkdownChunkingOptions): Promise<Chunk[]>;
+    private parseMarkdown;
+    private chunkSection;
+}
+declare function createMarkdownChunker(): MarkdownChunker;
+
+declare class CodeChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: CodeChunkingOptions): Promise<Chunk[]>;
+    private detectLanguage;
+    private parseCode;
+    private splitLargeBlock;
+}
+declare function createCodeChunker(): CodeChunker;
+
+declare class SemanticChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: SemanticChunkingOptions): Promise<Chunk[]>;
+    private splitSentences;
+    private calculateDistances;
+    private findBreakpoints;
+    private fallbackChunk;
+    private splitLargeChunks;
+}
+declare function createSemanticChunker(): SemanticChunker;
+
+declare function createChunker(strategy: ChunkingStrategyType): BaseChunker;
+declare function chunk(text: string, strategy?: ChunkingStrategyType, options?: ChunkingOptions): Promise<Chunk[]>;
+
+export { BaseChunker as B, type ChunkingStrategyType as C, FixedChunker as F, MarkdownChunker as M, type ParagraphChunkingOptions as P, RecursiveChunker as R, SemanticChunker as S, type TokenCounterFn as T, type ChunkingOptions as a, type Chunk as b, createFixedChunker as c, defaultTokenCounter as d, createRecursiveChunker as e, createMarkdownChunker as f, CodeChunker as g, createCodeChunker as h, createSemanticChunker as i, createChunker as j, chunk as k, type ChunkingMetadata as l, mergeSmallChunks as m, type FixedChunkingOptions as n, type SemanticChunkingOptions as o, type RecursiveChunkingOptions as p, type MarkdownChunkingOptions as q, type CodeChunkingOptions as r, splitLargeChunks as s, type SentenceChunkingOptions as t, type ChunkingResult as u, type ChunkingStats as v, type ChunkingStrategyConfig as w, type CustomChunkingFn as x, type TextSplitterFn as y };

package/dist/index-DMaQRn2w.d.ts

@@ -0,0 +1,172 @@
+type ChunkingStrategyType = 'fixed' | 'semantic' | 'recursive' | 'markdown' | 'code' | 'sentence' | 'paragraph' | 'custom';
+interface Chunk {
+    id: string;
+    text: string;
+    index: number;
+    startPosition: number;
+    endPosition: number;
+    tokenCount: number;
+    charCount: number;
+    overlapPrev: number;
+    overlapNext: number;
+    metadata: ChunkingMetadata;
+}
+interface ChunkingMetadata {
+    documentId?: string;
+    source?: string;
+    type?: string;
+    page?: number;
+    section?: string;
+    language?: string;
+    boundaryType?: string;
+    [key: string]: unknown;
+}
+interface ChunkingOptions {
+    chunkSize?: number;
+    chunkOverlap?: number;
+    minChunkSize?: number;
+    maxChunkSize?: number;
+    tokenCounter?: (text: string) => number;
+    documentId?: string;
+    source?: string;
+    type?: string;
+    metadata?: Record<string, unknown>;
+}
+interface FixedChunkingOptions extends ChunkingOptions {
+    splitByChars?: boolean;
+    separator?: string;
+    keepSeparator?: boolean;
+}
+interface SemanticChunkingOptions extends ChunkingOptions {
+    similarityThreshold?: number;
+    embeddingFn?: (texts: string[]) => Promise<number[][]>;
+    breakpointPercentileThreshold?: number;
+    bufferSize?: number;
+}
+interface RecursiveChunkingOptions extends ChunkingOptions {
+    separators?: string[];
+    keepSeparator?: boolean;
+    mergeSmallChunks?: boolean;
+}
+interface MarkdownChunkingOptions extends ChunkingOptions {
+    preserveHeaders?: boolean;
+    includeHeaderHierarchy?: boolean;
+    headingLevels?: number[];
+    splitCodeBlocks?: boolean;
+    preserveLinks?: boolean;
+}
+interface CodeChunkingOptions extends ChunkingOptions {
+    language?: string;
+    autoDetectLanguage?: boolean;
+    splitBy?: 'function' | 'class' | 'module' | 'auto';
+    includeComments?: boolean;
+    includeImports?: boolean;
+    includeTypeDefinitions?: boolean;
+}
+interface SentenceChunkingOptions extends ChunkingOptions {
+    combineSentences?: boolean;
+    sentenceBoundary?: RegExp;
+    minSentences?: number;
+}
+interface ParagraphChunkingOptions extends ChunkingOptions {
+    combineParagraphs?: boolean;
+    paragraphBoundary?: RegExp;
+    minParagraphs?: number;
+}
+interface ChunkingResult {
+    chunks: Chunk[];
+    totalChunks: number;
+    totalTokens: number;
+    avgChunkSize: number;
+    processingTimeMs: number;
+    strategy: ChunkingStrategyType;
+    originalLength: number;
+}
+interface ChunkingStats {
+    documentsProcessed: number;
+    chunksCreated: number;
+    tokensProcessed: number;
+    avgChunksPerDocument: number;
+    avgTokensPerChunk: number;
+    strategyDistribution: Record<ChunkingStrategyType, number>;
+}
+interface ChunkingStrategyConfig {
+    type: ChunkingStrategyType;
+    options: ChunkingOptions;
+    description?: string;
+}
+type CustomChunkingFn = (text: string, options: ChunkingOptions) => Promise<Chunk[]> | Chunk[];
+type TokenCounterFn = (text: string) => number;
+type TextSplitterFn = (text: string, separator: string) => string[];
+
+declare const defaultTokenCounter: TokenCounterFn;
+declare abstract class BaseChunker {
+    abstract readonly strategyType: ChunkingStrategyType;
+    protected defaultOptions: ChunkingOptions;
+    abstract chunk(text: string, options?: ChunkingOptions): Promise<Chunk[]>;
+    protected getOptions(options?: ChunkingOptions): ChunkingOptions & {
+        chunkSize: number;
+        chunkOverlap: number;
+        minChunkSize: number;
+        maxChunkSize: number;
+        tokenCounter: (text: string) => number;
+        metadata: Record<string, unknown>;
+    };
+    protected createChunk(text: string, index: number, startPosition: number, options: ChunkingOptions, additionalMetadata?: Record<string, unknown>): Chunk;
+    protected setOverlapInfo(chunks: Chunk[], overlapChars: number): void;
+    protected splitWithOverlap(text: string, chunkSize: number, overlap: number, tokenCounter: TokenCounterFn): string[];
+    chunkWithResult(text: string, options?: ChunkingOptions): Promise<ChunkingResult>;
+}
+declare function mergeSmallChunks(chunks: Chunk[], minTokens: number, tokenCounter: TokenCounterFn): Chunk[];
+declare function splitLargeChunks(chunks: Chunk[], maxTokens: number, tokenCounter: TokenCounterFn): Chunk[];
+
+declare class FixedChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: FixedChunkingOptions): Promise<Chunk[]>;
+    private getOverlapText;
+}
+declare function createFixedChunker(): FixedChunker;
+
+declare class RecursiveChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: RecursiveChunkingOptions): Promise<Chunk[]>;
+    private splitRecursively;
+    private splitBySeparator;
+    private splitByChars;
+    private addOverlap;
+    private getEndOverlap;
+}
+declare function createRecursiveChunker(): RecursiveChunker;
+
+declare class MarkdownChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: MarkdownChunkingOptions): Promise<Chunk[]>;
+    private parseMarkdown;
+    private chunkSection;
+}
+declare function createMarkdownChunker(): MarkdownChunker;
+
+declare class CodeChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: CodeChunkingOptions): Promise<Chunk[]>;
+    private detectLanguage;
+    private parseCode;
+    private splitLargeBlock;
+}
+declare function createCodeChunker(): CodeChunker;
+
+declare class SemanticChunker extends BaseChunker {
+    readonly strategyType: ChunkingStrategyType;
+    chunk(text: string, options?: SemanticChunkingOptions): Promise<Chunk[]>;
+    private splitSentences;
+    private calculateDistances;
+    private findBreakpoints;
+    private fallbackChunk;
+    private splitLargeChunks;
+}
+declare function createSemanticChunker(): SemanticChunker;
+
+declare function createChunker(strategy: ChunkingStrategyType): BaseChunker;
+declare function chunk(text: string, strategy?: ChunkingStrategyType, options?: ChunkingOptions): Promise<Chunk[]>;
+
+export { BaseChunker as B, type ChunkingStrategyType as C, FixedChunker as F, MarkdownChunker as M, type ParagraphChunkingOptions as P, RecursiveChunker as R, SemanticChunker as S, type TokenCounterFn as T, type ChunkingOptions as a, type Chunk as b, createFixedChunker as c, defaultTokenCounter as d, createRecursiveChunker as e, createMarkdownChunker as f, CodeChunker as g, createCodeChunker as h, createSemanticChunker as i, createChunker as j, chunk as k, type ChunkingMetadata as l, mergeSmallChunks as m, type FixedChunkingOptions as n, type SemanticChunkingOptions as o, type RecursiveChunkingOptions as p, type MarkdownChunkingOptions as q, type CodeChunkingOptions as r, splitLargeChunks as s, type SentenceChunkingOptions as t, type ChunkingResult as u, type ChunkingStats as v, type ChunkingStrategyConfig as w, type CustomChunkingFn as x, type TextSplitterFn as y };

package/dist/index-DWddsKRi.d.ts

@@ -0,0 +1,297 @@
+import { E as EmbeddingVector, a as EmbeddingResult, c as BatchEmbeddingResult, g as EmbeddingModelInfo, b as EmbeddingOptions, B as BatchEmbeddingOptions } from './embedding.types-CCgPVxt1.js';
+
+type EmbeddingProviderType = 'openai' | 'cohere' | 'voyage' | 'local' | 'huggingface' | 'anthropic' | 'google' | 'custom';
+interface ProviderConfig {
+    type: EmbeddingProviderType;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    headers?: Record<string, string>;
+    options?: Record<string, unknown>;
+}
+interface OpenAIProviderConfig extends ProviderConfig {
+    type: 'openai';
+    organization?: string;
+    apiVersion?: string;
+    model?: string;
+    encodingFormat?: 'float' | 'base64';
+    dimensions?: number;
+}
+interface CohereProviderConfig extends ProviderConfig {
+    type: 'cohere';
+    model?: string;
+    inputType?: 'search_document' | 'search_query' | 'classification' | 'clustering';
+    truncate?: 'NONE' | 'START' | 'END';
+}
+interface VoyageProviderConfig extends ProviderConfig {
+    type: 'voyage';
+    model?: string;
+    inputType?: 'document' | 'query';
+    truncation?: boolean;
+}
+interface LocalProviderConfig extends ProviderConfig {
+    type: 'local';
+    modelPath?: string;
+    modelType?: 'onnx' | 'transformers' | 'sentence-transformers';
+    device?: 'cpu' | 'cuda' | 'mps';
+    batchSize?: number;
+    normalize?: boolean;
+    pooling?: 'mean' | 'cls' | 'max';
+}
+interface HuggingFaceProviderConfig extends ProviderConfig {
+    type: 'huggingface';
+    model?: string;
+    useInferenceApi?: boolean;
+    waitForModel?: boolean;
+}
+interface EmbeddingRequest {
+    text: string;
+    model?: string;
+    user?: string;
+    options?: Record<string, unknown>;
+}
+interface BatchEmbeddingRequest {
+    texts: string[];
+    model?: string;
+    user?: string;
+    options?: Record<string, unknown>;
+}
+interface ProviderResponse {
+    embeddings: EmbeddingVector[];
+    model: string;
+    usage: TokenUsage;
+    metadata?: Record<string, unknown>;
+}
+interface TokenUsage {
+    promptTokens: number;
+    totalTokens: number;
+}
+interface ProviderError {
+    code: string;
+    message: string;
+    status?: number;
+    retryable: boolean;
+    retryAfter?: number;
+    details?: Record<string, unknown>;
+}
+interface ProviderHealth {
+    healthy: boolean;
+    latencyMs: number;
+    lastCheck: number;
+    error?: string;
+    rateLimit?: RateLimitInfo;
+}
+interface RateLimitInfo {
+    remaining: number;
+    limit: number;
+    reset: number;
+    retryAfter?: number;
+}
+interface ProviderMetrics {
+    provider: EmbeddingProviderType;
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    totalTokens: number;
+    avgLatencyMs: number;
+    p50LatencyMs: number;
+    p95LatencyMs: number;
+    p99LatencyMs: number;
+    errorRate: number;
+    rateLimitHits: number;
+    estimatedCostUSD: number;
+}
+interface ModelInfo {
+    id: string;
+    name: string;
+    provider: EmbeddingProviderType;
+    dimensions: number;
+    maxTokens: number;
+    maxBatchSize: number;
+    costPer1K?: number;
+    description?: string;
+    releaseDate?: string;
+    deprecated?: boolean;
+    replacement?: string;
+}
+interface ProviderCapabilities {
+    batch: boolean;
+    maxBatchSize: number;
+    streaming: boolean;
+    customDimensions: boolean;
+    inputTypes: string[];
+    models: string[];
+}
+interface ProviderFactoryOptions {
+    defaultProvider?: EmbeddingProviderType;
+    providers?: Record<EmbeddingProviderType, ProviderConfig>;
+    enableMetrics?: boolean;
+    enableHealthChecks?: boolean;
+    healthCheckInterval?: number;
+}
+interface CustomProviderConfig extends ProviderConfig {
+    type: 'custom';
+    embedFn: (text: string, options?: Record<string, unknown>) => Promise<EmbeddingResult>;
+    batchEmbedFn?: (texts: string[], options?: Record<string, unknown>) => Promise<BatchEmbeddingResult>;
+    modelInfo: ModelInfo;
+}
+
+declare abstract class EmbeddingModel {
+    abstract readonly info: EmbeddingModelInfo;
+    abstract embed(text: string, options?: EmbeddingOptions): Promise<EmbeddingResult>;
+    abstract embedBatch(texts: string[], options?: BatchEmbeddingOptions): Promise<BatchEmbeddingResult>;
+    get dimensions(): number;
+    get maxTokens(): number;
+    get maxBatchSize(): number;
+    get name(): string;
+    get provider(): string;
+    countTokens(text: string): number;
+    exceedsMaxTokens(text: string): boolean;
+    truncateToMaxTokens(text: string): string;
+    static cosineSimilarity(a: EmbeddingVector, b: EmbeddingVector): number;
+    static euclideanDistance(a: EmbeddingVector, b: EmbeddingVector): number;
+    static dotProduct(a: EmbeddingVector, b: EmbeddingVector): number;
+    static normalize(vector: EmbeddingVector): EmbeddingVector;
+    static average(vectors: EmbeddingVector[]): EmbeddingVector;
+    static weightedAverage(vectors: EmbeddingVector[], weights: number[]): EmbeddingVector;
+}
+declare class ModelRegistry {
+    private models;
+    private defaultModel;
+    register(model: EmbeddingModel, isDefault?: boolean): void;
+    get(provider: string, name: string): EmbeddingModel | undefined;
+    getByKey(key: string): EmbeddingModel | undefined;
+    getDefault(): EmbeddingModel | undefined;
+    setDefault(provider: string, name: string): void;
+    list(): EmbeddingModelInfo[];
+    has(provider: string, name: string): boolean;
+    remove(provider: string, name: string): boolean;
+    clear(): void;
+}
+declare const modelRegistry: ModelRegistry;
+
+declare abstract class BaseProvider extends EmbeddingModel {
+    protected config: ProviderConfig;
+    protected metrics: ProviderMetrics;
+    protected health: ProviderHealth;
+    protected latencies: number[];
+    private readonly maxLatencySamples;
+    constructor(config: ProviderConfig);
+    private createInitialMetrics;
+    protected abstract doEmbed(texts: string[], options?: EmbeddingOptions): Promise<{
+        vectors: number[][];
+        tokenCount: number;
+    }>;
+    embed(text: string, options?: EmbeddingOptions): Promise<EmbeddingResult>;
+    embedBatch(texts: string[], options?: BatchEmbeddingOptions): Promise<BatchEmbeddingResult>;
+    protected isRetryable(error: Error): boolean;
+    protected recordLatency(latencyMs: number): void;
+    protected calculatePercentile(p: number): number;
+    protected updateMetrics(): void;
+    getMetrics(): ProviderMetrics;
+    getHealth(): ProviderHealth;
+    checkHealth(): Promise<ProviderHealth>;
+    resetMetrics(): void;
+}
+
+declare class OpenAIProvider extends BaseProvider {
+    private modelInfo;
+    private apiKey;
+    private baseUrl;
+    private organization?;
+    constructor(config: OpenAIProviderConfig);
+    get info(): EmbeddingModelInfo;
+    protected doEmbed(texts: string[], options?: EmbeddingOptions): Promise<{
+        vectors: number[][];
+        tokenCount: number;
+    }>;
+    countTokens(text: string): number;
+}
+declare function createOpenAIProvider(config: OpenAIProviderConfig): OpenAIProvider;
+
+declare class CohereProvider extends BaseProvider {
+    private modelInfo;
+    private apiKey;
+    private baseUrl;
+    private inputType;
+    private truncate;
+    constructor(config: CohereProviderConfig);
+    get info(): EmbeddingModelInfo;
+    protected doEmbed(texts: string[], options?: EmbeddingOptions): Promise<{
+        vectors: number[][];
+        tokenCount: number;
+    }>;
+    setInputType(inputType: CohereProviderConfig['inputType']): this;
+    countTokens(text: string): number;
+}
+declare function createCohereProvider(config: CohereProviderConfig): CohereProvider;
+
+declare class VoyageProvider extends BaseProvider {
+    private modelInfo;
+    private apiKey;
+    private baseUrl;
+    private inputType;
+    private truncation;
+    constructor(config: VoyageProviderConfig);
+    get info(): EmbeddingModelInfo;
+    protected doEmbed(texts: string[], options?: EmbeddingOptions): Promise<{
+        vectors: number[][];
+        tokenCount: number;
+    }>;
+    setInputType(inputType: VoyageProviderConfig['inputType']): this;
+    countTokens(text: string): number;
+}
+declare function createVoyageProvider(config: VoyageProviderConfig): VoyageProvider;
+
+type LocalEmbeddingFn = (texts: string[], options?: Record<string, unknown>) => Promise<number[][]>;
+interface LocalProviderOptions extends LocalProviderConfig {
+    embedFn?: LocalEmbeddingFn;
+    dimensions: number;
+    name?: string;
+    maxTokens?: number;
+    maxBatchSize?: number;
+}
+declare class LocalProvider extends BaseProvider {
+    private modelInfo;
+    private embedFn;
+    private normalize;
+    private batchSize;
+    constructor(config: LocalProviderOptions);
+    get info(): EmbeddingModelInfo;
+    protected doEmbed(texts: string[], options?: EmbeddingOptions): Promise<{
+        vectors: number[][];
+        tokenCount: number;
+    }>;
+    setEmbedFunction(fn: LocalEmbeddingFn): this;
+    countTokens(text: string): number;
+}
+declare function createLocalProvider(config: LocalProviderOptions): LocalProvider;
+declare function createMockProvider(config: {
+    dimensions: number;
+    name?: string;
+    delay?: number;
+}): LocalProvider;
+declare function createRandomProvider(config: {
+    dimensions: number;
+    name?: string;
+}): LocalProvider;
+
+declare class HuggingFaceProvider extends BaseProvider {
+    private modelInfo;
+    private apiKey;
+    private baseUrl;
+    private waitForModel;
+    constructor(config: HuggingFaceProviderConfig);
+    get info(): EmbeddingModelInfo;
+    protected doEmbed(texts: string[], _options?: EmbeddingOptions): Promise<{
+        vectors: number[][];
+        tokenCount: number;
+    }>;
+    countTokens(text: string): number;
+}
+declare function createHuggingFaceProvider(config: HuggingFaceProviderConfig): HuggingFaceProvider;
+
+export { BaseProvider as B, CohereProvider as C, type EmbeddingProviderType as E, HuggingFaceProvider as H, LocalProvider as L, type ModelInfo as M, OpenAIProvider as O, type ProviderConfig as P, type RateLimitInfo as R, type TokenUsage as T, VoyageProvider as V, EmbeddingModel as a, ModelRegistry as b, createOpenAIProvider as c, createCohereProvider as d, createVoyageProvider as e, createLocalProvider as f, createMockProvider as g, createRandomProvider as h, createHuggingFaceProvider as i, type LocalEmbeddingFn as j, type LocalProviderOptions as k, type OpenAIProviderConfig as l, modelRegistry as m, type CohereProviderConfig as n, type VoyageProviderConfig as o, type LocalProviderConfig as p, type HuggingFaceProviderConfig as q, type EmbeddingRequest as r, type BatchEmbeddingRequest as s, type ProviderResponse as t, type ProviderError as u, type ProviderHealth as v, type ProviderMetrics as w, type ProviderCapabilities as x, type ProviderFactoryOptions as y, type CustomProviderConfig as z };