@lov3kaizen/agentsea-embeddings 1.0.1 → 1.1.1

package/dist/index.mjs

@@ -1,3 +1,18 @@
+import {
+  BaseProvider,
+  CohereProvider,
+  HuggingFaceProvider,
+  LocalProvider,
+  OpenAIProvider,
+  VoyageProvider,
+  createCohereProvider,
+  createHuggingFaceProvider,
+  createLocalProvider,
+  createMockProvider,
+  createOpenAIProvider,
+  createRandomProvider,
+  createVoyageProvider
+} from "./chunk-5GTQFVEI.mjs";
 import {
   BaseCache,
   MemoryCache,
@@ -10,7 +25,7 @@ import {
   createSQLiteCache,
   createStandardTieredCache,
   createTieredCache
-} from "./chunk-VPSMDBHH.mjs";
+} from "./chunk-MNJPAUDC.mjs";
 import {
   BaseChunker,
   CodeChunker,
@@ -27,8 +42,9 @@ import {
   createSemanticChunker,
   defaultTokenCounter,
   mergeSmallChunks,
+  nanoid,
   splitLargeChunks
-} from "./chunk-DJAURHAS.mjs";
+} from "./chunk-U6EYWYUD.mjs";
 import {
   BaseStore,
   ChromaStore,
@@ -40,22 +56,8 @@ import {
   createPineconeStore,
   createQdrantStore,
   createStore
-} from "./chunk-TER262ST.mjs";
-import {
-  BaseProvider,
-  CohereProvider,
-  HuggingFaceProvider,
-  LocalProvider,
-  OpenAIProvider,
-  VoyageProvider,
-  createCohereProvider,
-  createHuggingFaceProvider,
-  createLocalProvider,
-  createMockProvider,
-  createOpenAIProvider,
-  createRandomProvider,
-  createVoyageProvider
-} from "./chunk-NBHIRTJT.mjs";
+} from "./chunk-JHWMXQ56.mjs";
+import "./chunk-2TCNSTX3.mjs";
 import {
   batch,
   cacheKey,
@@ -432,7 +434,6 @@ function createEmbeddingManager(config) {
 }
 
 // src/versioning/VersionRegistry.ts
-import { nanoid } from "nanoid";
 import EventEmitter2 from "eventemitter3";
 var VersionRegistry = class extends EventEmitter2 {
   versions = /* @__PURE__ */ new Map();
@@ -684,7 +685,6 @@ function createVersionRegistry(options) {
 
 // src/quality/DriftDetector.ts
 import EventEmitter3 from "eventemitter3";
-import { nanoid as nanoid2 } from "nanoid";
 var DriftDetector = class extends EventEmitter3 {
   reference = null;
   config;
@@ -719,7 +719,7 @@ var DriftDetector = class extends EventEmitter3 {
       varianceVector.push(variance(values));
     }
     this.reference = {
-      id: nanoid2(),
+      id: nanoid(),
       model,
       version,
       sampleCount: embeddings.length,
@@ -894,7 +894,7 @@ var DriftDetector = class extends EventEmitter3 {
    */
   emitAlert(result) {
     const alert = {
-      id: nanoid2(),
+      id: nanoid(),
       type: "drift_detected",
       severity: result.severity,
       message: `Embedding drift detected with score ${result.driftScore.toFixed(3)}`,

package/dist/providers/index.d.mts

@@ -1,2 +1,2 @@
-export { B as BaseProvider, C as CohereProvider, c as CohereProviderConfig, E as EmbeddingProviderType, H as HuggingFaceProvider, f as HuggingFaceProviderConfig, L as LocalEmbeddingFn, g as LocalProvider, h as LocalProviderConfig, i as LocalProviderOptions, O as OpenAIProvider, k as OpenAIProviderConfig, P as ProviderCapabilities, l as ProviderConfig, o as ProviderHealth, p as ProviderMetrics, V as VoyageProvider, r as VoyageProviderConfig, s as createCohereProvider, t as createHuggingFaceProvider, u as createLocalProvider, v as createMockProvider, w as createOpenAIProvider, x as createRandomProvider, y as createVoyageProvider } from '../index-DmEEUzJg.mjs';
+export { B as BaseProvider, C as CohereProvider, c as CohereProviderConfig, E as EmbeddingProviderType, H as HuggingFaceProvider, f as HuggingFaceProviderConfig, L as LocalEmbeddingFn, g as LocalProvider, h as LocalProviderConfig, i as LocalProviderOptions, O as OpenAIProvider, k as OpenAIProviderConfig, P as ProviderCapabilities, l as ProviderConfig, o as ProviderHealth, p as ProviderMetrics, V as VoyageProvider, r as VoyageProviderConfig, s as createCohereProvider, t as createHuggingFaceProvider, u as createLocalProvider, v as createMockProvider, w as createOpenAIProvider, x as createRandomProvider, y as createVoyageProvider } from '../index-DGzfvyHY.mjs';
 import '../embedding.types-6Qr8Mgij.mjs';

package/dist/providers/index.d.ts

@@ -1,2 +1,2 @@
-export { B as BaseProvider, C as CohereProvider, c as CohereProviderConfig, E as EmbeddingProviderType, H as HuggingFaceProvider, f as HuggingFaceProviderConfig, L as LocalEmbeddingFn, g as LocalProvider, h as LocalProviderConfig, i as LocalProviderOptions, O as OpenAIProvider, k as OpenAIProviderConfig, P as ProviderCapabilities, l as ProviderConfig, o as ProviderHealth, p as ProviderMetrics, V as VoyageProvider, r as VoyageProviderConfig, s as createCohereProvider, t as createHuggingFaceProvider, u as createLocalProvider, v as createMockProvider, w as createOpenAIProvider, x as createRandomProvider, y as createVoyageProvider } from '../index-G-KgyvZT.js';
+export { B as BaseProvider, C as CohereProvider, c as CohereProviderConfig, E as EmbeddingProviderType, H as HuggingFaceProvider, f as HuggingFaceProviderConfig, L as LocalEmbeddingFn, g as LocalProvider, h as LocalProviderConfig, i as LocalProviderOptions, O as OpenAIProvider, k as OpenAIProviderConfig, P as ProviderCapabilities, l as ProviderConfig, o as ProviderHealth, p as ProviderMetrics, V as VoyageProvider, r as VoyageProviderConfig, s as createCohereProvider, t as createHuggingFaceProvider, u as createLocalProvider, v as createMockProvider, w as createOpenAIProvider, x as createRandomProvider, y as createVoyageProvider } from '../index-_uJcyK8e.js';
 import '../embedding.types-6Qr8Mgij.js';

package/dist/providers/index.js

@@ -950,20 +950,33 @@ function createVoyageProvider(config) {
   return new VoyageProvider(config);
 }
 
+// src/core/optional-import.ts
+function importOptional(name) {
+  return import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    name
+  );
+}
+
 // src/providers/LocalProvider.ts
 var LocalProvider = class extends BaseProvider {
   modelInfo;
   embedFn = null;
   normalize;
   batchSize;
+  modelPath;
+  /** Lazily-built ONNX extractor (only when loading from `modelPath`). */
+  extractorPromise;
   constructor(config) {
     super({ ...config, type: "local" });
     if (!config.embedFn && !config.modelPath) {
       throw new Error(
-        "Either embedFn or modelPath is required for local provider"
+        "`embedFn` or `modelPath` (ONNX) is required for the local provider"
       );
     }
     this.embedFn = config.embedFn ?? null;
+    this.modelPath = config.modelPath;
     this.normalize = config.normalize ?? true;
     this.batchSize = config.batchSize ?? 32;
     this.modelInfo = {
@@ -977,10 +990,43 @@ var LocalProvider = class extends BaseProvider {
       description: "Local embedding model"
     };
   }
+  /**
+   * Lazily load the ONNX feature-extraction pipeline from `modelPath` via
+   * Transformers.js and adapt it into a {@link LocalEmbeddingFn}.
+   */
+  getOnnxEmbedFn() {
+    if (!this.extractorPromise) {
+      this.extractorPromise = (async () => {
+        let mod;
+        try {
+          mod = await importOptional("@xenova/transformers");
+        } catch {
+          throw new Error(
+            'Loading local ONNX models from `modelPath` requires the "@xenova/transformers" package. Install it, or pass an `embedFn`.'
+          );
+        }
+        const transformers = mod;
+        return transformers.pipeline("feature-extraction", this.modelPath);
+      })();
+    }
+    return this.extractorPromise;
+  }
   get info() {
     return this.modelInfo;
   }
   async doEmbed(texts, options) {
+    if (!this.embedFn && this.modelPath) {
+      const extractor = await this.getOnnxEmbedFn();
+      this.embedFn = async (input) => {
+        const output = await extractor(input, {
+          pooling: "mean",
+          normalize: false
+          // we normalize below if configured
+        });
+        const list = output.tolist();
+        return Array.isArray(list[0]) ? list : [list];
+      };
+    }
     if (!this.embedFn) {
       throw new Error("No embedding function configured");
     }

package/dist/providers/index.mjs

@@ -12,7 +12,8 @@ import {
   createOpenAIProvider,
   createRandomProvider,
   createVoyageProvider
-} from "../chunk-NBHIRTJT.mjs";
+} from "../chunk-5GTQFVEI.mjs";
+import "../chunk-2TCNSTX3.mjs";
 import "../chunk-3KM32UQK.mjs";
 import "../chunk-QAITLJ2E.mjs";
 export {

package/dist/stores/index.d.mts

@@ -138,6 +138,8 @@ interface DeleteOptions {
 }
 interface DeleteResult {
     deletedCount: number;
+    countExact: boolean;
+    requestedCount?: number;
     durationMs: number;
 }
 interface StoreQueryOptions extends SearchOptions {
@@ -293,6 +295,258 @@ declare class QdrantStore extends BaseStore {
 }
 declare function createQdrantStore(config: QdrantStoreConfig): QdrantStore;
 
+interface PgPoolLike {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: Array<Record<string, unknown>>;
+        rowCount: number | null;
+    }>;
+    end(): Promise<void>;
+}
+interface PgVectorStoreOptions extends PgVectorStoreConfig {
+    pool?: PgPoolLike;
+}
+declare class PgVectorStore extends BaseStore {
+    readonly storeType: VectorStoreType;
+    private pool?;
+    private readonly injectedPool?;
+    private readonly table;
+    private readonly vectorColumn;
+    private readonly contentColumn;
+    private readonly metadataColumn;
+    private readonly pgConfig;
+    private initialized;
+    constructor(config: PgVectorStoreOptions);
+    private get distanceOperator();
+    init(): Promise<void>;
+    private ensureInitialized;
+    private ident;
+    private toVectorLiteral;
+    upsert(records: VectorRecord[], options?: UpsertOptions): Promise<UpsertResult>;
+    query(vector: EmbeddingVector, options?: StoreQueryOptions): Promise<StoreQueryResult>;
+    delete(ids: string[], _options?: DeleteOptions): Promise<DeleteResult>;
+    deleteAll(_options?: DeleteOptions): Promise<DeleteResult>;
+    getStats(): Promise<StoreStats>;
+    checkHealth(): Promise<StoreHealth>;
+    close(): Promise<void>;
+}
+declare function createPgVectorStore(config: PgVectorStoreOptions): PgVectorStore;
+
+interface WeaviateBackend {
+    ensureClass(className: string, dimensions?: number): Promise<void>;
+    upsert(className: string, objects: Array<{
+        id: string;
+        vector: number[];
+        properties: Record<string, unknown>;
+    }>): Promise<void>;
+    nearVector(className: string, vector: number[], limit: number, filter?: Record<string, unknown>): Promise<Array<{
+        id: string;
+        score: number;
+        properties: Record<string, unknown>;
+    }>>;
+    deleteByIds(className: string, ids: string[]): Promise<number>;
+    deleteAll(className: string): Promise<number>;
+    count(className: string): Promise<number>;
+    ping(): Promise<void>;
+}
+interface WeaviateStoreOptions extends WeaviateStoreConfig {
+    backend?: WeaviateBackend;
+}
+declare class WeaviateStore extends BaseStore {
+    readonly storeType: VectorStoreType;
+    private backend?;
+    private readonly injectedBackend?;
+    private readonly className;
+    private readonly url;
+    private readonly apiKey?;
+    private initialized;
+    constructor(config: WeaviateStoreOptions);
+    init(): Promise<void>;
+    private ensureInitialized;
+    private buildSdkBackend;
+    upsert(records: VectorRecord[], options?: UpsertOptions): Promise<UpsertResult>;
+    query(vector: EmbeddingVector, options?: StoreQueryOptions): Promise<StoreQueryResult>;
+    delete(ids: string[], _options?: DeleteOptions): Promise<DeleteResult>;
+    deleteAll(_options?: DeleteOptions): Promise<DeleteResult>;
+    getStats(): Promise<StoreStats>;
+    checkHealth(): Promise<StoreHealth>;
+    close(): Promise<void>;
+}
+interface WeaviateSdkClient {
+    schema: {
+        getter: () => {
+            do: () => Promise<{
+                classes?: Array<{
+                    class: string;
+                }>;
+            }>;
+        };
+        classCreator: () => {
+            withClass: (c: unknown) => {
+                do: () => Promise<unknown>;
+            };
+        };
+    };
+    batch: {
+        objectsBatcher: () => WeaviateBatcher;
+    };
+    data: {
+        deleter: () => {
+            withClassName: (c: string) => {
+                withId: (id: string) => {
+                    do: () => Promise<unknown>;
+                };
+            };
+        };
+    };
+    graphql: {
+        get: () => WeaviateGraphQLGet;
+        aggregate: () => WeaviateAggregate;
+    };
+    misc: {
+        liveChecker: () => {
+            do: () => Promise<unknown>;
+        };
+    };
+}
+interface WeaviateBatcher {
+    withObject: (o: unknown) => WeaviateBatcher;
+    do: () => Promise<unknown>;
+}
+interface WeaviateGraphQLGet {
+    withClassName: (c: string) => WeaviateGraphQLGet;
+    withFields: (f: string) => WeaviateGraphQLGet;
+    withNearVector: (v: unknown) => WeaviateGraphQLGet;
+    withWhere: (w: unknown) => WeaviateGraphQLGet;
+    withLimit: (n: number) => WeaviateGraphQLGet;
+    do: () => Promise<{
+        data?: Record<string, unknown>;
+    }>;
+}
+interface WeaviateAggregate {
+    withClassName: (c: string) => WeaviateAggregate;
+    withFields: (f: string) => WeaviateAggregate;
+    do: () => Promise<{
+        data?: Record<string, unknown>;
+    }>;
+}
+declare class WeaviateSdkBackend implements WeaviateBackend {
+    private readonly client;
+    constructor(client: WeaviateSdkClient);
+    ensureClass(className: string, _dimensions?: number): Promise<void>;
+    upsert(className: string, objects: Array<{
+        id: string;
+        vector: number[];
+        properties: Record<string, unknown>;
+    }>): Promise<void>;
+    nearVector(className: string, vector: number[], limit: number, filter?: Record<string, unknown>): Promise<Array<{
+        id: string;
+        score: number;
+        properties: Record<string, unknown>;
+    }>>;
+    deleteByIds(className: string, ids: string[]): Promise<number>;
+    deleteAll(className: string): Promise<number>;
+    count(className: string): Promise<number>;
+    ping(): Promise<void>;
+    private toWhere;
+}
+declare function createWeaviateStore(config: WeaviateStoreOptions): WeaviateStore;
+
+interface MilvusBackend {
+    ensureCollection(collection: string, dimensions: number, metric: string): Promise<void>;
+    upsert(collection: string, rows: Array<{
+        id: string;
+        vector: number[];
+        text: string;
+        metadata: Record<string, unknown>;
+    }>): Promise<void>;
+    search(collection: string, vector: number[], limit: number, filter?: string): Promise<Array<{
+        id: string;
+        score: number;
+        text: string;
+        metadata: Record<string, unknown>;
+    }>>;
+    deleteByIds(collection: string, ids: string[]): Promise<number>;
+    deleteAll(collection: string): Promise<number>;
+    count(collection: string): Promise<number>;
+    ping(): Promise<void>;
+}
+interface MilvusStoreOptions extends MilvusStoreConfig {
+    backend?: MilvusBackend;
+}
+declare class MilvusStore extends BaseStore {
+    readonly storeType: VectorStoreType;
+    private backend?;
+    private readonly injectedBackend?;
+    private readonly collection;
+    private readonly milvusConfig;
+    private initialized;
+    constructor(config: MilvusStoreOptions);
+    private get metricType();
+    init(): Promise<void>;
+    private ensureInitialized;
+    private buildSdkBackend;
+    upsert(records: VectorRecord[], options?: UpsertOptions): Promise<UpsertResult>;
+    query(vector: EmbeddingVector, options?: StoreQueryOptions): Promise<StoreQueryResult>;
+    delete(ids: string[], _options?: DeleteOptions): Promise<DeleteResult>;
+    deleteAll(_options?: DeleteOptions): Promise<DeleteResult>;
+    getStats(): Promise<StoreStats>;
+    checkHealth(): Promise<StoreHealth>;
+    close(): Promise<void>;
+    private toExpr;
+}
+interface MilvusSdkClient {
+    hasCollection(p: {
+        collection_name: string;
+    }): Promise<{
+        value: boolean;
+    }>;
+    createCollection(p: unknown): Promise<unknown>;
+    createIndex(p: unknown): Promise<unknown>;
+    loadCollectionSync(p: {
+        collection_name: string;
+    }): Promise<unknown>;
+    insert(p: {
+        collection_name: string;
+        data: unknown[];
+    }): Promise<unknown>;
+    search(p: unknown): Promise<{
+        results: Array<Record<string, unknown>>;
+    }>;
+    deleteEntities(p: {
+        collection_name: string;
+        expr: string;
+    }): Promise<unknown>;
+    getCollectionStatistics(p: {
+        collection_name: string;
+    }): Promise<{
+        data?: {
+            row_count?: string | number;
+        };
+    }>;
+}
+declare class MilvusSdkBackend implements MilvusBackend {
+    private readonly client;
+    constructor(client: MilvusSdkClient);
+    ensureCollection(collection: string, dimensions: number, metric: string): Promise<void>;
+    upsert(collection: string, rows: Array<{
+        id: string;
+        vector: number[];
+        text: string;
+        metadata: Record<string, unknown>;
+    }>): Promise<void>;
+    search(collection: string, vector: number[], limit: number, filter?: string): Promise<Array<{
+        id: string;
+        score: number;
+        text: string;
+        metadata: Record<string, unknown>;
+    }>>;
+    deleteByIds(collection: string, ids: string[]): Promise<number>;
+    deleteAll(collection: string): Promise<number>;
+    count(collection: string): Promise<number>;
+    ping(): Promise<void>;
+}
+declare function createMilvusStore(config: MilvusStoreOptions): MilvusStore;
+
 declare function createStore(type: VectorStoreType, config: StoreConfig): BaseStore;
 
-export { BaseStore, ChromaStore, type ChromaStoreConfig, type CollectionInfo, type DeleteOptions, type DeleteResult, type DistanceMetric, type IndexInfo, MemoryStore, type MemoryStoreConfig, type MilvusStoreConfig, type PgVectorStoreConfig, PineconeStore, type PineconeStoreConfig, QdrantStore, type QdrantStoreConfig, type StoreConfig, type StoreFactoryOptions, type StoreHealth, type StoreQueryOptions, type StoreQueryResult, type StoreStats, type StoredVector, type UpsertOptions, type UpsertResult, type VectorRecord, type VectorStoreType, type WeaviateStoreConfig, createChromaStore, createMemoryStore, createPineconeStore, createQdrantStore, createStore };
+export { BaseStore, ChromaStore, type ChromaStoreConfig, type CollectionInfo, type DeleteOptions, type DeleteResult, type DistanceMetric, type IndexInfo, MemoryStore, type MemoryStoreConfig, type MilvusBackend, MilvusSdkBackend, MilvusStore, type MilvusStoreConfig, type MilvusStoreOptions, type PgPoolLike, PgVectorStore, type PgVectorStoreConfig, type PgVectorStoreOptions, PineconeStore, type PineconeStoreConfig, QdrantStore, type QdrantStoreConfig, type StoreConfig, type StoreFactoryOptions, type StoreHealth, type StoreQueryOptions, type StoreQueryResult, type StoreStats, type StoredVector, type UpsertOptions, type UpsertResult, type VectorRecord, type VectorStoreType, type WeaviateBackend, WeaviateSdkBackend, WeaviateStore, type WeaviateStoreConfig, type WeaviateStoreOptions, createChromaStore, createMemoryStore, createMilvusStore, createPgVectorStore, createPineconeStore, createQdrantStore, createStore, createWeaviateStore };