@anvia/transformers 1.0.0-rc.1 → 1.0.0-rc.2

package/README.md

@@ -1,8 +1,6 @@
 # @anvia/transformers
 
-Transformers.js embedding model adapter for Anvia.
-
-Use this package when you want local embedding generation through `@huggingface/transformers`, especially for development or lightweight RAG workflows.
+Local Transformers.js embedding model adapter for Anvia.
 
 ## Installation
 
@@ -10,78 +8,67 @@ Use this package when you want local embedding generation through `@huggingface/
 pnpm add @anvia/transformers @anvia/core @huggingface/transformers
 ```
 
-In this monorepo, the package is available through the workspace:
-
-```sh
-pnpm --filter @anvia/transformers build
-```
-
 ## Usage
 
 ```ts
 import { embedDocuments } from "@anvia/core/embeddings";
-import { InMemoryVectorStore } from "@anvia/core/vector-store";
-import { createTransformersEmbeddingModel } from "@anvia/transformers";
-
-const embeddingModel = await createTransformersEmbeddingModel();
-
-const documents = await embedDocuments(
-  embeddingModel,
-  [
-    {
-      id: "password-reset",
-      title: "Password reset policy",
-      body: "Password reset links expire after 30 minutes.",
-    },
-    {
-      id: "priority-support",
-      title: "Priority support",
-      body: "Enterprise customers receive priority support.",
-    },
-  ],
-  {
-    id: (document) => document.id,
-    content: (document) => `${document.title}\n${document.body}`,
-  },
-);
-
-const store = InMemoryVectorStore.fromDocuments(documents);
-const index = store.index(embeddingModel);
-
-const results = await index.search({
-  query: "How long does a password reset link last?",
-  topK: 3,
+import { InMemoryVectorStore, retrieveDocuments } from "@anvia/core/vector-store";
+import { loadTransformersEmbeddingModel } from "@anvia/transformers";
+
+const model = await loadTransformersEmbeddingModel({ modelId: "Xenova/all-MiniLM-L6-v2" });
+const { documents } = await embedDocuments({
+  model,
+  documents: [{ id: "password-reset", text: "Reset links expire after 30 minutes." }],
+  id: (document) => document.id,
+  content: (document) => document.text,
 });
 
-console.log(results);
+const store = InMemoryVectorStore.fromDocuments({ documents });
+const results = await retrieveDocuments({
+  store,
+  model,
+  query: "How long does a reset link last?",
+  topK: 3,
+});
 ```
 
-## Default Model
+Loading is eager and may download model files. Reuse the returned handle and close it at application
+shutdown. The handle supports `await using` and waits for active inference before disposing its
+owned Transformers pipeline.
 
-The default embedding model is:
+```ts
+const model = await loadTransformersEmbeddingModel({
+  modelId: "Xenova/all-MiniLM-L6-v2",
+  pooling: "mean",
+  normalize: true,
+  maxBatchSize: 16,
+});
+```
 
 ```ts
-Xenova/all-MiniLM-L6-v2
+await using model = await loadTransformersEmbeddingModel({
+  modelId: "Xenova/all-MiniLM-L6-v2",
+  device: "cpu",
+  dtype: "q8",
+  cacheDir: "./models",
+});
 ```
 
-You can pass another feature-extraction model:
+Adapt an existing pipeline when the application owns its lifecycle:
 
 ```ts
-const embeddingModel = await createTransformersEmbeddingModel({
-  model: "Xenova/all-MiniLM-L6-v2",
+import { adaptTransformersEmbeddingModel } from "@anvia/transformers";
+
+const model = adaptTransformersEmbeddingModel({
+  runtime: existingPipeline,
+  modelId: "custom-model",
   pooling: "mean",
   normalize: true,
-  maxBatchSize: 16,
 });
 ```
 
-## Exports
-
-- `TransformersEmbeddingModel`
-- `createTransformersEmbeddingModel`
-- `DEFAULT_TRANSFORMERS_EMBEDDING_MODEL`
-- `TransformersEmbeddingModelOptions`
-- `TransformersPooling`
+Adapted handles never dispose the caller-owned runtime. Embedding helpers use object arguments,
+return named results, and accept `retries` and `abortSignal`.
 
 ## Development
 

package/dist/index.d.ts

@@ -1,30 +1,40 @@
-import { EmbeddingModel, Embedding } from '@anvia/core/embeddings';
+import { EmbeddingModel } from '@anvia/core/embeddings';
 
 type TransformersPooling = "mean" | "cls";
-type TransformersFeatureExtractionPipeline = (texts: string[], options: {
-    pooling: TransformersPooling;
-    normalize: boolean;
-}) => Promise<{
+type TransformersTensor = {
     tolist(): unknown;
-}>;
-type TransformersEmbeddingModelOptions = {
-    model?: string | undefined;
+    dispose(): void;
+};
+type TransformersFeatureExtractionPipeline = {
+    (texts: string[], options: {
+        pooling: TransformersPooling;
+        normalize: boolean;
+    }): Promise<TransformersTensor>;
+    dispose(): Promise<void>;
+};
+type TransformersEmbeddingRuntimeOptions = {
+    modelId: string;
     pooling?: TransformersPooling | undefined;
     normalize?: boolean | undefined;
     maxBatchSize?: number | undefined;
 };
+type LoadTransformersEmbeddingModelOptions = TransformersEmbeddingRuntimeOptions & {
+    device?: string | Record<string, string> | undefined;
+    dtype?: string | Record<string, string> | undefined;
+    cacheDir?: string | undefined;
+    localFilesOnly?: boolean | undefined;
+    revision?: string | undefined;
+};
+type AdaptTransformersEmbeddingModelOptions = TransformersEmbeddingRuntimeOptions & {
+    runtime: TransformersFeatureExtractionPipeline;
+};
+interface LoadedTransformersEmbeddingModel extends EmbeddingModel, AsyncDisposable {
+    close(): Promise<void>;
+}
+type TransformersEmbeddingModelHandle = EmbeddingModel;
 
 declare const DEFAULT_TRANSFORMERS_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
-declare class TransformersEmbeddingModel implements EmbeddingModel {
-    private readonly extractor;
-    readonly model: string;
-    readonly maxBatchSize: number;
-    private readonly pooling;
-    private readonly normalize;
-    constructor(extractor: TransformersFeatureExtractionPipeline, options?: TransformersEmbeddingModelOptions);
-    static create(options?: TransformersEmbeddingModelOptions): Promise<TransformersEmbeddingModel>;
-    embedTexts(texts: string[]): Promise<Embedding[]>;
-}
-declare function createTransformersEmbeddingModel(options?: TransformersEmbeddingModelOptions): Promise<TransformersEmbeddingModel>;
+declare function loadTransformersEmbeddingModel(options: LoadTransformersEmbeddingModelOptions): Promise<LoadedTransformersEmbeddingModel>;
+declare function adaptTransformersEmbeddingModel(options: AdaptTransformersEmbeddingModelOptions): TransformersEmbeddingModelHandle;
 
-export { DEFAULT_TRANSFORMERS_EMBEDDING_MODEL, TransformersEmbeddingModel, type TransformersEmbeddingModelOptions, type TransformersFeatureExtractionPipeline, type TransformersPooling, createTransformersEmbeddingModel };
+export { type AdaptTransformersEmbeddingModelOptions, DEFAULT_TRANSFORMERS_EMBEDDING_MODEL, type LoadTransformersEmbeddingModelOptions, type LoadedTransformersEmbeddingModel, type TransformersEmbeddingModelHandle, type TransformersFeatureExtractionPipeline, type TransformersPooling, type TransformersTensor, adaptTransformersEmbeddingModel, loadTransformersEmbeddingModel };

package/dist/index.js

@@ -18,48 +18,136 @@ function parseVectors(value, expectedLength) {
 
 // src/model.ts
 var DEFAULT_TRANSFORMERS_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
-var TransformersEmbeddingModel = class _TransformersEmbeddingModel {
-  constructor(extractor, options = {}) {
-    this.extractor = extractor;
-    this.model = options.model ?? DEFAULT_TRANSFORMERS_EMBEDDING_MODEL;
+var TransformersEmbeddingModel = class {
+  constructor(runtime, options) {
+    this.runtime = runtime;
+    this.modelId = requireModelId(options.modelId);
     this.pooling = options.pooling ?? "mean";
     this.normalize = options.normalize ?? true;
-    this.maxBatchSize = Math.max(1, Math.trunc(options.maxBatchSize ?? 16));
+    this.maxBatchSize = positiveSafeInteger(options.maxBatchSize ?? 16, "maxBatchSize");
   }
-  extractor;
-  model;
+  runtime;
+  provider = "transformers";
+  modelId;
   maxBatchSize;
   pooling;
   normalize;
-  static async create(options = {}) {
-    const model = options.model ?? DEFAULT_TRANSFORMERS_EMBEDDING_MODEL;
-    const extractor = await transformersPipeline(
-      "feature-extraction",
-      model
-    );
-    return new _TransformersEmbeddingModel(extractor, { ...options, model });
+  beginCall() {
+  }
+  endCall() {
   }
-  async embedTexts(texts) {
-    if (texts.length === 0) {
-      return [];
+  async embedTexts(texts, options) {
+    this.beginCall();
+    let output;
+    try {
+      throwIfAborted(options?.abortSignal);
+      if (texts.length === 0) {
+        return [];
+      }
+      output = await this.runtime(texts, {
+        pooling: this.pooling,
+        normalize: this.normalize
+      });
+      throwIfAborted(options?.abortSignal);
+      const vectors = parseVectors(output.tolist(), texts.length);
+      return texts.map((document, index) => ({
+        document,
+        vector: vectors[index]
+      }));
+    } finally {
+      try {
+        output?.dispose();
+      } finally {
+        this.endCall();
+      }
     }
-    const output = await this.extractor(texts, {
-      pooling: this.pooling,
-      normalize: this.normalize
-    });
-    const vectors = parseVectors(output.tolist(), texts.length);
-    return texts.map((document, index) => ({
-      document,
-      vector: vectors[index]
-    }));
   }
 };
-function createTransformersEmbeddingModel(options = {}) {
-  return TransformersEmbeddingModel.create(options);
+var OwnedTransformersEmbeddingModel = class extends TransformersEmbeddingModel {
+  closed = false;
+  activeCalls = 0;
+  idleWaiters = /* @__PURE__ */ new Set();
+  closePromise;
+  beginCall() {
+    if (this.closed) {
+      throw new Error("Transformers embedding model is closed.");
+    }
+    this.activeCalls += 1;
+  }
+  endCall() {
+    this.activeCalls -= 1;
+    if (this.activeCalls === 0) {
+      for (const resolve of this.idleWaiters) resolve();
+      this.idleWaiters.clear();
+    }
+  }
+  close() {
+    if (this.closePromise !== void 0) {
+      return this.closePromise;
+    }
+    this.closed = true;
+    this.closePromise = (async () => {
+      if (this.activeCalls > 0) {
+        await new Promise((resolve) => this.idleWaiters.add(resolve));
+      }
+      await this.runtime.dispose();
+    })();
+    return this.closePromise;
+  }
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+};
+async function loadTransformersEmbeddingModel(options) {
+  const normalized = normalizeRuntimeOptions(options);
+  let runtime;
+  try {
+    runtime = await transformersPipeline("feature-extraction", normalized.modelId, {
+      ...options.device === void 0 ? {} : { device: options.device },
+      ...options.dtype === void 0 ? {} : { dtype: options.dtype },
+      ...options.cacheDir === void 0 ? {} : { cache_dir: options.cacheDir },
+      ...options.localFilesOnly === void 0 ? {} : { local_files_only: options.localFilesOnly },
+      ...options.revision === void 0 ? {} : { revision: options.revision }
+    });
+    return new OwnedTransformersEmbeddingModel(runtime, normalized);
+  } catch (error) {
+    await runtime?.dispose();
+    throw error;
+  }
+}
+function adaptTransformersEmbeddingModel(options) {
+  return new TransformersEmbeddingModel(options.runtime, normalizeRuntimeOptions(options));
+}
+function normalizeRuntimeOptions(options) {
+  return {
+    modelId: requireModelId(options.modelId),
+    pooling: options.pooling,
+    normalize: options.normalize,
+    maxBatchSize: positiveSafeInteger(options.maxBatchSize ?? 16, "maxBatchSize")
+  };
+}
+function requireModelId(modelId) {
+  if (modelId.trim().length === 0) {
+    throw new TypeError("modelId must be a non-empty string");
+  }
+  return modelId;
+}
+function positiveSafeInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
+  return value;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    const error = new Error("The operation was aborted.");
+    error.name = "AbortError";
+    throw error;
+  }
 }
 export {
   DEFAULT_TRANSFORMERS_EMBEDDING_MODEL,
-  TransformersEmbeddingModel,
-  createTransformersEmbeddingModel
+  adaptTransformersEmbeddingModel,
+  loadTransformersEmbeddingModel
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/model.ts","../src/helpers.ts"],"sourcesContent":["import type { Embedding, EmbeddingModel } from \"@anvia/core/embeddings\";\nimport { pipeline as transformersPipeline } from \"@huggingface/transformers\";\nimport { parseVectors } from \"./helpers.js\";\nimport type {\n  TransformersEmbeddingModelOptions,\n  TransformersFeatureExtractionPipeline,\n  TransformersPooling,\n} from \"./types.js\";\n\nexport const DEFAULT_TRANSFORMERS_EMBEDDING_MODEL = \"Xenova/all-MiniLM-L6-v2\";\n\nexport class TransformersEmbeddingModel implements EmbeddingModel {\n  readonly model: string;\n  readonly maxBatchSize: number;\n\n  private readonly pooling: TransformersPooling;\n  private readonly normalize: boolean;\n\n  constructor(\n    private readonly extractor: TransformersFeatureExtractionPipeline,\n    options: TransformersEmbeddingModelOptions = {},\n  ) {\n    this.model = options.model ?? DEFAULT_TRANSFORMERS_EMBEDDING_MODEL;\n    this.pooling = options.pooling ?? \"mean\";\n    this.normalize = options.normalize ?? true;\n    this.maxBatchSize = Math.max(1, Math.trunc(options.maxBatchSize ?? 16));\n  }\n\n  static async create(\n    options: TransformersEmbeddingModelOptions = {},\n  ): Promise<TransformersEmbeddingModel> {\n    const model = options.model ?? DEFAULT_TRANSFORMERS_EMBEDDING_MODEL;\n    const extractor = (await transformersPipeline(\n      \"feature-extraction\",\n      model,\n    )) as TransformersFeatureExtractionPipeline;\n\n    return new TransformersEmbeddingModel(extractor, { ...options, model });\n  }\n\n  async embedTexts(texts: string[]): Promise<Embedding[]> {\n    if (texts.length === 0) {\n      return [];\n    }\n\n    const output = await this.extractor(texts, {\n      pooling: this.pooling,\n      normalize: this.normalize,\n    });\n    const vectors = parseVectors(output.tolist(), texts.length);\n\n    return texts.map((document, index) => ({\n      document,\n      vector: vectors[index] as number[],\n    }));\n  }\n}\n\nexport function createTransformersEmbeddingModel(\n  options: TransformersEmbeddingModelOptions = {},\n): Promise<TransformersEmbeddingModel> {\n  return TransformersEmbeddingModel.create(options);\n}\n","export function parseVectors(value: unknown, expectedLength: number): number[][] {\n  if (!Array.isArray(value) || value.length !== expectedLength) {\n    throw new Error(\n      `Transformers embedding model returned ${Array.isArray(value) ? value.length : 0} embeddings for ${expectedLength} texts`,\n    );\n  }\n\n  return value.map((vector, index) => {\n    if (!Array.isArray(vector) || !vector.every((item) => typeof item === \"number\")) {\n      throw new Error(`Transformers embedding model returned an invalid vector at index ${index}`);\n    }\n    return vector;\n  });\n}\n"],"mappings":";AACA,SAAS,YAAY,4BAA4B;;;ACD1C,SAAS,aAAa,OAAgB,gBAAoC;AAC/E,MAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,gBAAgB;AAC5D,UAAM,IAAI;AAAA,MACR,yCAAyC,MAAM,QAAQ,KAAK,IAAI,MAAM,SAAS,CAAC,mBAAmB,cAAc;AAAA,IACnH;AAAA,EACF;AAEA,SAAO,MAAM,IAAI,CAAC,QAAQ,UAAU;AAClC,QAAI,CAAC,MAAM,QAAQ,MAAM,KAAK,CAAC,OAAO,MAAM,CAAC,SAAS,OAAO,SAAS,QAAQ,GAAG;AAC/E,YAAM,IAAI,MAAM,oEAAoE,KAAK,EAAE;AAAA,IAC7F;AACA,WAAO;AAAA,EACT,CAAC;AACH;;;ADJO,IAAM,uCAAuC;AAE7C,IAAM,6BAAN,MAAM,4BAAqD;AAAA,EAOhE,YACmB,WACjB,UAA6C,CAAC,GAC9C;AAFiB;AAGjB,SAAK,QAAQ,QAAQ,SAAS;AAC9B,SAAK,UAAU,QAAQ,WAAW;AAClC,SAAK,YAAY,QAAQ,aAAa;AACtC,SAAK,eAAe,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,gBAAgB,EAAE,CAAC;AAAA,EACxE;AAAA,EAPmB;AAAA,EAPV;AAAA,EACA;AAAA,EAEQ;AAAA,EACA;AAAA,EAYjB,aAAa,OACX,UAA6C,CAAC,GACT;AACrC,UAAM,QAAQ,QAAQ,SAAS;AAC/B,UAAM,YAAa,MAAM;AAAA,MACvB;AAAA,MACA;AAAA,IACF;AAEA,WAAO,IAAI,4BAA2B,WAAW,EAAE,GAAG,SAAS,MAAM,CAAC;AAAA,EACxE;AAAA,EAEA,MAAM,WAAW,OAAuC;AACtD,QAAI,MAAM,WAAW,GAAG;AACtB,aAAO,CAAC;AAAA,IACV;AAEA,UAAM,SAAS,MAAM,KAAK,UAAU,OAAO;AAAA,MACzC,SAAS,KAAK;AAAA,MACd,WAAW,KAAK;AAAA,IAClB,CAAC;AACD,UAAM,UAAU,aAAa,OAAO,OAAO,GAAG,MAAM,MAAM;AAE1D,WAAO,MAAM,IAAI,CAAC,UAAU,WAAW;AAAA,MACrC;AAAA,MACA,QAAQ,QAAQ,KAAK;AAAA,IACvB,EAAE;AAAA,EACJ;AACF;AAEO,SAAS,iCACd,UAA6C,CAAC,GACT;AACrC,SAAO,2BAA2B,OAAO,OAAO;AAClD;","names":[]}
+{"version":3,"sources":["../src/model.ts","../src/helpers.ts"],"sourcesContent":["import type { Embedding, EmbeddingModel, ModelCallOptions } from \"@anvia/core/embeddings\";\nimport { pipeline as transformersPipeline } from \"@huggingface/transformers\";\nimport { parseVectors } from \"./helpers.js\";\nimport type {\n  AdaptTransformersEmbeddingModelOptions,\n  LoadedTransformersEmbeddingModel,\n  LoadTransformersEmbeddingModelOptions,\n  TransformersEmbeddingModelHandle,\n  TransformersFeatureExtractionPipeline,\n  TransformersPooling,\n  TransformersTensor,\n} from \"./types.js\";\n\nexport const DEFAULT_TRANSFORMERS_EMBEDDING_MODEL = \"Xenova/all-MiniLM-L6-v2\";\n\nclass TransformersEmbeddingModel implements EmbeddingModel {\n  readonly provider = \"transformers\";\n  readonly modelId: string;\n  readonly maxBatchSize: number;\n\n  private readonly pooling: TransformersPooling;\n  private readonly normalize: boolean;\n\n  constructor(\n    protected readonly runtime: TransformersFeatureExtractionPipeline,\n    options: {\n      modelId: string;\n      pooling?: TransformersPooling | undefined;\n      normalize?: boolean | undefined;\n      maxBatchSize?: number | undefined;\n    },\n  ) {\n    this.modelId = requireModelId(options.modelId);\n    this.pooling = options.pooling ?? \"mean\";\n    this.normalize = options.normalize ?? true;\n    this.maxBatchSize = positiveSafeInteger(options.maxBatchSize ?? 16, \"maxBatchSize\");\n  }\n\n  protected beginCall(): void {}\n  protected endCall(): void {}\n\n  async embedTexts(texts: string[], options?: ModelCallOptions): Promise<Embedding[]> {\n    this.beginCall();\n    let output: TransformersTensor | undefined;\n    try {\n      throwIfAborted(options?.abortSignal);\n      if (texts.length === 0) {\n        return [];\n      }\n\n      output = await this.runtime(texts, {\n        pooling: this.pooling,\n        normalize: this.normalize,\n      });\n      throwIfAborted(options?.abortSignal);\n      const vectors = parseVectors(output.tolist(), texts.length);\n\n      return texts.map((document, index) => ({\n        document,\n        vector: vectors[index] as number[],\n      }));\n    } finally {\n      try {\n        output?.dispose();\n      } finally {\n        this.endCall();\n      }\n    }\n  }\n}\n\nclass OwnedTransformersEmbeddingModel\n  extends TransformersEmbeddingModel\n  implements LoadedTransformersEmbeddingModel\n{\n  private closed = false;\n  private activeCalls = 0;\n  private readonly idleWaiters = new Set<() => void>();\n  private closePromise: Promise<void> | undefined;\n\n  protected override beginCall(): void {\n    if (this.closed) {\n      throw new Error(\"Transformers embedding model is closed.\");\n    }\n    this.activeCalls += 1;\n  }\n\n  protected override endCall(): void {\n    this.activeCalls -= 1;\n    if (this.activeCalls === 0) {\n      for (const resolve of this.idleWaiters) resolve();\n      this.idleWaiters.clear();\n    }\n  }\n\n  close(): Promise<void> {\n    if (this.closePromise !== undefined) {\n      return this.closePromise;\n    }\n    this.closed = true;\n    this.closePromise = (async () => {\n      if (this.activeCalls > 0) {\n        await new Promise<void>((resolve) => this.idleWaiters.add(resolve));\n      }\n      await this.runtime.dispose();\n    })();\n    return this.closePromise;\n  }\n\n  async [Symbol.asyncDispose](): Promise<void> {\n    await this.close();\n  }\n}\n\nexport async function loadTransformersEmbeddingModel(\n  options: LoadTransformersEmbeddingModelOptions,\n): Promise<LoadedTransformersEmbeddingModel> {\n  const normalized = normalizeRuntimeOptions(options);\n  let runtime: TransformersFeatureExtractionPipeline | undefined;\n  try {\n    runtime = (await transformersPipeline(\"feature-extraction\", normalized.modelId, {\n      ...(options.device === undefined ? {} : { device: options.device }),\n      ...(options.dtype === undefined ? {} : { dtype: options.dtype }),\n      ...(options.cacheDir === undefined ? {} : { cache_dir: options.cacheDir }),\n      ...(options.localFilesOnly === undefined ? {} : { local_files_only: options.localFilesOnly }),\n      ...(options.revision === undefined ? {} : { revision: options.revision }),\n    } as never)) as TransformersFeatureExtractionPipeline;\n    return new OwnedTransformersEmbeddingModel(runtime, normalized);\n  } catch (error) {\n    await runtime?.dispose();\n    throw error;\n  }\n}\n\nexport function adaptTransformersEmbeddingModel(\n  options: AdaptTransformersEmbeddingModelOptions,\n): TransformersEmbeddingModelHandle {\n  return new TransformersEmbeddingModel(options.runtime, normalizeRuntimeOptions(options));\n}\n\nfunction normalizeRuntimeOptions(options: {\n  modelId: string;\n  pooling?: TransformersPooling | undefined;\n  normalize?: boolean | undefined;\n  maxBatchSize?: number | undefined;\n}) {\n  return {\n    modelId: requireModelId(options.modelId),\n    pooling: options.pooling,\n    normalize: options.normalize,\n    maxBatchSize: positiveSafeInteger(options.maxBatchSize ?? 16, \"maxBatchSize\"),\n  };\n}\n\nfunction requireModelId(modelId: string): string {\n  if (modelId.trim().length === 0) {\n    throw new TypeError(\"modelId must be a non-empty string\");\n  }\n  return modelId;\n}\n\nfunction positiveSafeInteger(value: number, name: string): number {\n  if (!Number.isSafeInteger(value) || value <= 0) {\n    throw new TypeError(`${name} must be a positive safe integer`);\n  }\n  return value;\n}\n\nfunction throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) {\n    const error = new Error(\"The operation was aborted.\");\n    error.name = \"AbortError\";\n    throw error;\n  }\n}\n","export function parseVectors(value: unknown, expectedLength: number): number[][] {\n  if (!Array.isArray(value) || value.length !== expectedLength) {\n    throw new Error(\n      `Transformers embedding model returned ${Array.isArray(value) ? value.length : 0} embeddings for ${expectedLength} texts`,\n    );\n  }\n\n  return value.map((vector, index) => {\n    if (!Array.isArray(vector) || !vector.every((item) => typeof item === \"number\")) {\n      throw new Error(`Transformers embedding model returned an invalid vector at index ${index}`);\n    }\n    return vector;\n  });\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anvia/transformers",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.2",
   "description": "Transformers.js embedding model adapter for Anvia.",
   "author": "anvia",
   "maintainer": "Indra Zulfi",
@@ -33,10 +33,10 @@
     "tsup": "^8.5.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.8",
-    "@anvia/core": "1.0.0-rc.1"
+    "@anvia/core": "1.0.0-rc.2"
   },
   "peerDependencies": {
-    "@anvia/core": "1.0.0-rc.1"
+    "@anvia/core": "1.0.0-rc.2"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",