@browser-ai/web-llm 2.1.0 → 2.1.1

package/dist/index.mjs

@@ -957,7 +957,7 @@ ${existingContent}` : "")
   ];
 }
 
-// src/web-llm-language-model.ts
+// src/utils/browser.ts
 function isMobile() {
   if (typeof navigator === "undefined") return false;
   return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
@@ -974,6 +974,8 @@ function checkWebGPU() {
 function doesBrowserSupportWebLLM() {
   return checkWebGPU();
 }
+
+// src/web-llm-language-model.ts
 function extractToolName(content) {
   const jsonMatch = content.match(/\{\s*"name"\s*:\s*"([^"]+)"/);
   if (jsonMatch) {
@@ -1688,16 +1690,213 @@ var WebLLMLanguageModel = class {
   }
 };
 
+// src/web-llm-embedding-model.ts
+import {
+  CreateWebWorkerMLCEngine as CreateWebWorkerMLCEngine2,
+  MLCEngine as MLCEngine2
+} from "@mlc-ai/web-llm";
+var WebLLMEmbeddingModel = class {
+  constructor(modelId, options = {}) {
+    this.specificationVersion = "v3";
+    this.provider = "web-llm";
+    this.supportsParallelCalls = false;
+    this.isInitialized = false;
+    this.modelId = modelId;
+    this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall ?? 100;
+    this.config = {
+      provider: this.provider,
+      modelId,
+      options
+    };
+  }
+  /**
+   * Check if the model is initialized and ready to use
+   */
+  get isModelInitialized() {
+    return this.isInitialized;
+  }
+  async getEngine(options, onInitProgress) {
+    const availability = await this.availability();
+    if (availability === "unavailable") {
+      throw new LoadSettingError({
+        message: "WebLLM is not available. This library requires a browser with WebGPU support."
+      });
+    }
+    if (this.engine && this.isInitialized) return this.engine;
+    if (this.initializationPromise) {
+      await this.initializationPromise;
+      if (this.engine) return this.engine;
+    }
+    this.initializationPromise = this._initializeEngine(
+      options,
+      onInitProgress
+    );
+    await this.initializationPromise;
+    if (!this.engine) {
+      throw new LoadSettingError({
+        message: "Engine initialization failed"
+      });
+    }
+    return this.engine;
+  }
+  async _initializeEngine(options, onInitProgress) {
+    try {
+      const engineConfig = {
+        ...this.config.options.engineConfig,
+        ...options,
+        initProgressCallback: onInitProgress || this.config.options.initProgressCallback
+      };
+      if (this.config.options.worker) {
+        this.engine = await CreateWebWorkerMLCEngine2(
+          this.config.options.worker,
+          this.modelId,
+          engineConfig
+        );
+      } else {
+        this.engine = new MLCEngine2(engineConfig);
+        await this.engine.reload(this.modelId);
+      }
+      this.isInitialized = true;
+    } catch (error) {
+      this.engine = void 0;
+      this.isInitialized = false;
+      this.initializationPromise = void 0;
+      throw new LoadSettingError({
+        message: `Failed to initialize WebLLM embedding engine: ${error instanceof Error ? error.message : "Unknown error"}`
+      });
+    }
+  }
+  /**
+   * Check the availability of the WebLLM embedding model
+   * @returns Promise resolving to "unavailable", "available", or "downloadable"
+   */
+  async availability() {
+    if (this.isInitialized) {
+      return "available";
+    }
+    if (this.config.options.worker && isMobile()) {
+      return "downloadable";
+    }
+    const supported = checkWebGPU();
+    return supported ? "downloadable" : "unavailable";
+  }
+  /**
+   * Creates an engine session with download progress monitoring.
+   *
+   * @example
+   * ```typescript
+   * const engine = await model.createSessionWithProgress(
+   *   (progress) => {
+   *     console.log(`Download progress: ${Math.round(progress.progress * 100)}%`);
+   *   }
+   * );
+   * ```
+   *
+   * @param onInitProgress Optional callback receiving progress reports during model download
+   * @returns Promise resolving to a configured WebLLM engine
+   * @throws {LoadSettingError} When WebLLM isn't available or model is unavailable
+   */
+  async createSessionWithProgress(onInitProgress) {
+    return this.getEngine(void 0, onInitProgress);
+  }
+  /**
+   * Embed texts using the WebLLM embedding model
+   */
+  async doEmbed(options) {
+    const { values, abortSignal } = options;
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    if (abortSignal?.aborted) {
+      throw new Error("Operation was aborted");
+    }
+    const engine = await this.getEngine();
+    const abortHandler = () => {
+      engine.interruptGenerate();
+    };
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", abortHandler);
+    }
+    try {
+      const response = await engine.embeddings.create({
+        input: values,
+        model: this.modelId,
+        ...abortSignal && !this.config.options.worker && { signal: abortSignal }
+      });
+      const sortedEmbeddings = response.data.sort((a, b) => a.index - b.index).map((e) => e.embedding);
+      return {
+        embeddings: sortedEmbeddings,
+        usage: {
+          tokens: response.usage.total_tokens
+        },
+        providerMetadata: {
+          webllm: {
+            model: response.model,
+            promptTokens: response.usage.prompt_tokens,
+            totalTokens: response.usage.total_tokens,
+            prefillTokensPerSecond: response.usage.extra?.prefill_tokens_per_s
+          }
+        },
+        warnings: []
+      };
+    } catch (error) {
+      throw new Error(
+        `WebLLM embedding failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    } finally {
+      if (abortSignal) {
+        abortSignal.removeEventListener("abort", abortHandler);
+      }
+    }
+  }
+};
+
 // src/index.ts
 import { WebWorkerMLCEngineHandler } from "@mlc-ai/web-llm";
 
 // src/web-llm-provider.ts
-function webLLM(modelId, settings) {
-  return new WebLLMLanguageModel(modelId, settings);
+function createWebLLM() {
+  const createLanguageModel = (modelId, settings) => {
+    return new WebLLMLanguageModel(modelId, settings);
+  };
+  const createEmbeddingModel = (modelId, settings) => {
+    return new WebLLMEmbeddingModel(modelId, settings);
+  };
+  const provider = function(modelId, settings) {
+    if (new.target) {
+      throw new Error(
+        "The WebLLM model function cannot be called with the new keyword."
+      );
+    }
+    return createLanguageModel(modelId, settings);
+  };
+  provider.specificationVersion = "v3";
+  provider.languageModel = createLanguageModel;
+  provider.chat = createLanguageModel;
+  provider.embedding = createEmbeddingModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
+  provider.speechModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "speechModel" });
+  };
+  provider.transcriptionModel = (modelId) => {
+    throw new NoSuchModelError({ modelId, modelType: "transcriptionModel" });
+  };
+  return provider;
 }
+var webLLM = createWebLLM();
 export {
+  WebLLMEmbeddingModel,
   WebLLMLanguageModel,
   WebWorkerMLCEngineHandler,
+  createWebLLM,
   doesBrowserSupportWebLLM,
   webLLM
 };