Lighter model.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "localm",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "",
   "main": "chat-full.js",
   "scripts": {

src/app/worker-connection.js

@@ -33,7 +33,7 @@ export function workerConnection() {
           const msg = ev.data || {};
           if (msg && msg.type === 'ready') {
             ready = true;
-            resolve({ worker: worker, pending, send });
+            resolve({ worker, pending, send });
             return;
           }
 
@@ -41,10 +41,14 @@ export function workerConnection() {
             const id = msg.id;
             const entry = pending.get(id);
             if (!entry) return;
-            pending.delete(id);
-            if (msg.type === 'response') entry.resolve(msg.result);
-            else if (msg.type === 'error') entry.reject(new Error(msg.error));
-            else entry.resolve(msg);
+            if (msg.type === 'response') {
+              pending.delete(id);
+              entry.resolve(msg.result);
+            } else if (msg.type === 'error') {
+              pending.delete(id);
+              entry.reject(new Error(msg.error));
+            }
+            //else entry.resolve(msg);
           }
         });
 
@@ -80,11 +84,12 @@ export function workerConnection() {
 
   /**
    * @param {string} promptText
-   * @param {string} modelName
+   * @param {string} [modelName]
    */
   async function runPrompt(promptText, modelName) {
     await workerLoaded;
     const { send } = await workerLoaded;
-    return send({ type: 'runPrompt', prompt: promptText, modelName });
+    const sendPromise = send({ type: 'runPrompt', prompt: promptText, modelName });
+    return sendPromise;
   }
 }

src/worker/load-model-core.js

@@ -19,12 +19,13 @@ export async function loadModelCore({
   // via its own callbacks if available.
   const pipe = await pipeline(
     'text-generation',
-    modelName,{
-    device,
-    progress_callback: (progress) => {
-      if (onProgress) onProgress(progress);
-    }
-  });
+    modelName,
+    {
+      device,
+      progress_callback: (progress) => {
+        if (onProgress) onProgress(progress);
+      }
+    });
 
   return pipe;
 }

src/worker/model-cache.js

@@ -9,9 +9,14 @@ export class ModelCache {
   backend = undefined;
 
   knownModels = [
-    'Xenova/phi-1.5',
+    'Xenova/llama2.c-stories15M', // nonsense
     'Xenova/phi-3-mini-4k-instruct',
-    'Xenova/all-MiniLM-L6-v2'
+    'Xenova/all-MiniLM-L6-v2', // unsupported model type: bert
+    'Xenova/phi-1.5', // gated
+    'Qwen/Qwen2.5-3B', // cannot be loaded
+    'microsoft/phi-1_5', // cannot be loaded
+    'FlofloB/100k_fineweb_continued_pretraining_Qwen2.5-0.5B-Instruct_Unsloth_merged_16bit', // cannot be loaded 
+    'ehristoforu/coolqwen-3b-it' // cannot be loaded
   ];
 
   /**
@@ -30,20 +35,52 @@ export class ModelCache {
    */
   _loadModelAndStore({ modelName }) {
     if (!this.backend) this.backend = detectTransformersBackend();
-    const modelPromise = loadModelCore({
-      modelName,
-      device: this.backend
-    });
-    this.cache.set(modelName, modelPromise);
-    modelPromise.then(
-      model => {
+    // Create a loader promise that will try multiple backends in order.
+    const loader = (async () => {
+      const tried = [];
+      // candidate order: detected backend first, then common fallbacks
+      let candidates = ['webgpu', 'gpu', 'wasm'];
+      candidates = ['gpu', 'wasm'];
+      candidates = candidates.slice(candidates.indexOf(this.backend || 'wasm'));
+
+      let lastErr = null;
+      console.log('Trying candidates ', candidates);
+      for (const device of candidates) {
+        try {
+          const model = await loadModelCore({
+            modelName,
+            device: /** @type {import('@huggingface/transformers').DeviceType} */ (device)
+          });
+          // on success, update backend to the working device and store model
+          this.backend = /** @type {import('@huggingface/transformers').DeviceType} */ (device);
+          this.cache.set(modelName, model);
+          return model;
+        } catch (err) {
+          console.log('Failed ', device, ' ', err);
+          tried.push({ device, error: err.stack || String(err) });
+          lastErr = err;
+          // continue to next candidate
+        }
+      }
+
+      // none succeeded
+      const err = new Error(`no available backend found. attempts=${JSON.stringify(tried)}; last=${String(lastErr)}`);
+      throw err;
+    })();
+
+    // store the in-progress promise so concurrent requests reuse it
+    this.cache.set(modelName, loader);
+    loader.then(
+      (model) => {
+        // on success, loader already stored the model
         this.cache.set(modelName, model);
       },
       () => {
         this.cache.delete(modelName);
-      });
-    
-    return modelPromise;
+      }
+    );
+
+    return loader;
   }
 
 }