Updating to handle prompt queries better.

package.json

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

src/app/worker-connection.js

@@ -75,7 +75,7 @@ export function workerConnection() {
   async function loadModel(modelName) {
     await workerLoaded;
   const { send } = await workerLoaded;
-  return send({ type: 'loadModel', model: modelName });
+  return send({ type: 'loadModel', modelName });
   }
 
   /**
@@ -85,6 +85,6 @@ export function workerConnection() {
   async function runPrompt(promptText, modelName) {
     await workerLoaded;
   const { send } = await workerLoaded;
-  return send({ type: 'runPrompt', prompt: promptText, model: modelName });
+  return send({ type: 'runPrompt', prompt: promptText, modelName });
   }
 }

src/worker/boot-worker.js

@@ -1,8 +1,9 @@
 // @ts-check
 
-import { pipeline } from '@huggingface/transformers';
+import { ModelCache } from './model-cache';
 
 export function bootWorker() {
+  const modelCache = new ModelCache();
   // Report starting
   try {
     self.postMessage({ type: 'status', status: 'initializing' });
@@ -10,160 +11,70 @@ export function bootWorker() {
     // ignore if postMessage not available for some reason
   }
 
-  (async () => {
-  // named import `pipeline` is available from the bundled runtime
+  self.postMessage({ type: 'status', status: 'backend-detected', backend: modelCache.backend });
 
-    // Detect available acceleration backends
-    let backend = 'wasm';
-    try {
-      const hasWebGPU = typeof navigator !== 'undefined' && !!navigator.gpu;
-      let hasWebGL2 = false;
-      try {
-        // In a worker environment prefer OffscreenCanvas to test webgl2
-        if (typeof OffscreenCanvas !== 'undefined') {
-          const c = new OffscreenCanvas(1, 1);
-          const gl = c.getContext('webgl2') || c.getContext('webgl');
-          hasWebGL2 = !!gl;
-        } else if (typeof document !== 'undefined') {
-          const canvas = document.createElement('canvas');
-          const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
-          hasWebGL2 = !!gl;
-        }
-      } catch (e) {
-        hasWebGL2 = false;
-      }
 
-      if (hasWebGPU) backend = 'webgpu';
-      else if (hasWebGL2) backend = 'webgl';
-    } catch (e) {
-      backend = 'wasm';
-    }
+  // signal ready to main thread (worker script loaded; model runtime may still be pending)
+  self.postMessage({ type: 'ready' });
 
-    self.postMessage({ type: 'status', status: 'backend-detected', backend });
+  // handle incoming requests from the UI thread
+  self.addEventListener('message', handleMessage);
 
-    // verify the named import is present
+  async function handleMessage({ data }) {
+    const { id } = data;
     try {
-      if (!pipeline) throw new Error('transformers pipeline import not available');
-      self.postMessage({ type: 'status', status: 'transformers-loaded', source: '@huggingface/transformers' });
+      if (data.type === 'listModels') {
+        self.postMessage({ id, type: 'response', result: modelCache.knownModels });
+      } else if (data.type === 'loadModel') {
+        const { modelName = modelCache.knownModels[0] } = data;
+        try {
+          const pipe = await modelCache.getModel({ modelName });
+          self.postMessage({ id, type: 'response', result: { model: modelName, status: 'loaded' } });
+        } catch (err) {
+          self.postMessage({ id, type: 'error', error: String(err) });
+        }
+      } else if (data.type === 'runPrompt') {
+        handleRunPrompt(data);
+      } else {
+        if (id) self.postMessage({ id, type: 'error', error: 'unknown-message-type' });
+      }
     } catch (err) {
-      self.postMessage({ type: 'status', status: 'transformers-load-failed', error: String(err) });
+      if (id) self.postMessage({ id, type: 'error', error: String(err) });
     }
+  }
 
-    // Model cache to avoid loading the same model multiple times.
-    // value = { promise, pipeline }
-    const modelCache = new Map();
-
-    const availableModels = [
-      'Xenova/phi-3-mini-4k-instruct',
-      'Xenova/phi-1.5',
-      'Xenova/all-MiniLM-L6-v2'
-    ];
-
-    // signal ready to main thread (worker script loaded; model runtime may still be pending)
-    self.postMessage({ type: 'ready' });
-
-    // helper: create or return existing pipeline promise
-    async function ensureModel(modelName, id) {
-      if (modelCache.has(modelName)) {
-        const entry = modelCache.get(modelName);
-        // If pipeline already resolved, return it, otherwise await the promise
-        if (entry.pipeline) return entry.pipeline;
-        return entry.promise;
-      }
-
-      // create loader promise
-      const loader = (async () => {
-        if (!pipeline) {
-          throw new Error('transformers runtime not available');
-        }
-
-        // Post progress and status
-        if (id) self.postMessage({ id, type: 'status', status: 'model-loading', model: modelName });
-
-        // Choose device hint as a literal union. Cast only at the call site if TypeScript
-        // needs help narrowing.
-        const deviceOption = backend === 'webgpu' ? 'webgpu' : (backend === 'webgl' ? 'gpu' : 'wasm');
-
-        // Create a text-generation pipeline. Depending on the model this may
-        // perform downloads of model weights; the library should report progress
-        // via its own callbacks if available.
-        const pipe = await pipeline('text-generation', modelName, /** @type {any} */ ({
-          device: deviceOption,
-          progress_callback: (progress) => {
-            if (id) self.postMessage({ id, type: 'model-progress', progress, model: modelName });
-          }
-        }));
-
-        // store pipeline for reuse
-        const entry = modelCache.get(modelName) || {};
-        entry.pipeline = pipe;
-        modelCache.set(modelName, entry);
-
-        if (id) self.postMessage({ id, type: 'status', status: 'model-loaded', model: modelName });
-        return pipe;
-      })();
-
-      // temporarly store the in-progress promise so concurrent requests reuse it
-      modelCache.set(modelName, { promise: loader });
-      return loader;
+  async function handleRunPrompt({ prompt, modelName = modelCache.knownModels[0], id, options }) {
+    try {
+      const pipe = await modelCache.getModel({ modelName });
+      // run the pipeline
+      if (!pipe) throw new Error('pipeline not available');
+      self.postMessage({ id, type: 'status', status: 'inference-start', model: modelName });
+      const out = await pipe(prompt, options || {});
+      const text = extractText(out);
+      self.postMessage({ id, type: 'status', status: 'inference-done', model: modelName });
+      self.postMessage({ id, type: 'response', result: text });
+    } catch (err) {
+      self.postMessage({ id, type: 'error', error: String(err) });
     }
+  }
+}
 
-    // helper to extract generated text from various runtime outputs
-    function extractText(output) {
-      // typical shapes: [{ generated_text: '...' }] or [{ text: '...' }] or string
-      try {
-        if (!output) return '';
-        if (typeof output === 'string') return output;
-        if (Array.isArray(output) && output.length > 0) {
-          const el = output[0];
-          if (el.generated_text) return el.generated_text;
-          if (el.text) return el.text;
-          // Some runtimes return an array of strings
-          if (typeof el === 'string') return el;
-        }
-        // Fallback: try JSON stringify
-        return String(output);
-      } catch (e) {
-        return '';
-      }
+// helper to extract generated text from various runtime outputs
+function extractText(output) {
+  // typical shapes: [{ generated_text: '...' }] or [{ text: '...' }] or string
+  try {
+    if (!output) return '';
+    if (typeof output === 'string') return output;
+    if (Array.isArray(output) && output.length > 0) {
+      const el = output[0];
+      if (el.generated_text) return el.generated_text;
+      if (el.text) return el.text;
+      // Some runtimes return an array of strings
+      if (typeof el === 'string') return el;
     }
-
-    // handle incoming requests from the UI thread
-    self.addEventListener('message', async (ev) => {
-      const msg = ev.data || {};
-      const id = msg.id;
-      try {
-        if (msg.type === 'listModels') {
-          self.postMessage({ id, type: 'response', result: availableModels });
-        } else if (msg.type === 'loadModel') {
-          const modelName = msg.model;
-          try {
-            await ensureModel(modelName, id);
-            self.postMessage({ id, type: 'response', result: { model: modelName, status: 'loaded' } });
-          } catch (err) {
-            self.postMessage({ id, type: 'error', error: String(err) });
-          }
-        } else if (msg.type === 'runPrompt') {
-          const prompt = msg.prompt || '';
-          const modelName = msg.model;
-          try {
-            const pipe = await ensureModel(modelName, id);
-            // run the pipeline
-            if (!pipe) throw new Error('pipeline not available');
-            self.postMessage({ id, type: 'status', status: 'inference-start', model: modelName });
-            const out = await pipe(prompt, msg.options || {});
-            const text = extractText(out);
-            self.postMessage({ id, type: 'status', status: 'inference-done', model: modelName });
-            self.postMessage({ id, type: 'response', result: text });
-          } catch (err) {
-            self.postMessage({ id, type: 'error', error: String(err) });
-          }
-        } else {
-          if (id) self.postMessage({ id, type: 'error', error: 'unknown-message-type' });
-        }
-      } catch (err) {
-        if (id) self.postMessage({ id, type: 'error', error: String(err) });
-      }
-    });
-  })();
+    // Fallback: try JSON stringify
+    return String(output);
+  } catch (e) {
+    return '';
+  }
 }

src/worker/load-model-core.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+import { pipeline } from '@huggingface/transformers';
+
+/**
+ * @param {{
+ *  modelName: string,
+ *  device: import('@huggingface/transformers').DeviceType,
+ *  onProgress?: import('@huggingface/transformers').ProgressCallback
+ * }} _
+ */
+export async function loadModelCore({
+  modelName,
+  device,
+  onProgress
+}) {
+  // Create a text-generation pipeline. Depending on the model this may
+  // perform downloads of model weights; the library should report progress
+  // via its own callbacks if available.
+  const pipe = await pipeline(
+    'text-generation',
+    modelName,{
+    device,
+    progress_callback: (progress) => {
+      if (onProgress) onProgress(progress);
+    }
+  });
+
+  return pipe;
+}

src/worker/model-cache.js

@@ -0,0 +1,82 @@
+// @ts-check
+
+import { pipeline } from '@huggingface/transformers';
+import { loadModelCore } from './load-model-core';
+
+export class ModelCache {
+  cache = new Map();
+  /** @type {import('@huggingface/transformers').DeviceType | undefined} */
+  backend = undefined;
+
+  knownModels = [
+    'Xenova/phi-3-mini-4k-instruct',
+    'Xenova/phi-1.5',
+    'Xenova/all-MiniLM-L6-v2'
+  ];
+
+  /**
+   * @param {{
+   *  modelName: string
+   * }} _
+   */
+  getModel({ modelName }) {
+    return this.cache.get(modelName) || this._loadModelAndStore({ modelName });
+  }
+
+  /**
+   * @param {{
+   *  modelName: string
+   * }} _
+   */
+  _loadModelAndStore({ modelName }) {
+    if (!this.backend) this.backend = detectTransformersBackend();
+    const modelPromise = loadModelCore({
+      modelName,
+      device: this.backend
+    });
+    this.cache.set(modelName, modelPromise);
+    modelPromise.then(
+      model => {
+        this.cache.set(modelName, model);
+      },
+      () => {
+        this.cache.delete(modelName);
+      });
+    
+    return modelPromise;
+  }
+
+}
+
+export function detectTransformersBackend() {
+  /**
+   * Detect available acceleration backends
+   * @type {import('@huggingface/transformers').DeviceType}
+   */
+  let backend = 'wasm';
+  try {
+    const hasWebGPU = typeof navigator !== 'undefined' && !!/** @type {*} */(navigator).gpu;
+    let hasWebGL2 = false;
+    try {
+      // In a worker environment prefer OffscreenCanvas to test webgl2
+      if (typeof OffscreenCanvas !== 'undefined') {
+        const c = new OffscreenCanvas(1, 1);
+        const gl = c.getContext('webgl2') || c.getContext('webgl');
+        hasWebGL2 = !!gl;
+      } else if (typeof document !== 'undefined') {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
+        hasWebGL2 = !!gl;
+      }
+    } catch (e) {
+      hasWebGL2 = false;
+    }
+
+    if (hasWebGPU) backend = 'webgpu';
+    else if (hasWebGL2) backend = 'gpu';
+  } catch (e) {
+    backend = 'wasm';
+  }
+
+  return backend;
+}