zerochat 7.3.0__py3-none-any.whl

zerochat_runtime/assets/js/profile-repository.js

@@ -0,0 +1,213 @@
+/**
+ * Versioned repository for editable connection profiles.
+ * Runtime consumers must use ChatConfig instead of reading this repository.
+ */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = factory(require('./cookies.js'), require('./profile-backup.js'));
+  } else {
+    root.ChatProfileRepository = factory(root.ChatStorage, root.ChatProfileBackup);
+  }
+}(typeof self !== 'undefined' ? self : this, function (Storage, Backup) {
+  'use strict';
+
+  const STORAGE_KEY = 'profiles_v1';
+  const SCHEMA_VERSION = 1;
+  const READONLY_PROFILE_ID = 'profile:mirror';
+  const PROFILE_FIELDS = Object.freeze([
+    'apiUrl', 'apiType', 'model', 'systemPrompt', 'temperature',
+    'reasoningEffort', 'reasoningTransport', 'maxAgentTurns', 'modelReasoningConfig', 'enabledTools',
+    'enableRawLogs', 'enableContextCache', 'contextLimitOverride', 'webllmConfig', 'apiKeyLocked'
+  ]);
+  const STORAGE_PROFILE_FIELDS = Object.freeze([...PROFILE_FIELDS, 'apiKey']);
+
+  function clone(value) {
+    return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+  }
+
+  function createId(name) {
+    return `profile:${encodeURIComponent(String(name || '').trim())}`;
+  }
+
+  const NEW_PROFILE_SETTINGS = Object.freeze({
+    apiUrl: 'http://localhost:1234/v1', apiType: 'openai', model: '', systemPrompt: '',
+    temperature: '0.7', reasoningEffort: 'medium', reasoningTransport: 'auto', maxAgentTurns: 15, modelReasoningConfig: null,
+    enabledTools: { execute_javascript: true, search_web: true, fetch_web_page: true, download_pdf: true, render_chart: true },
+    enableRawLogs: false, enableContextCache: true, contextLimitOverride: null, apiKeyLocked: false,
+    webllmConfig: {
+      context_window_size: 'default',
+      prefill_chunk_size: 'default'
+    }
+  });
+
+  const MIRROR_PROFILE = Object.freeze({
+    id: READONLY_PROFILE_ID,
+    name: 'Espejo',
+    description: 'Muestra la petición OpenAI sin enviarla.',
+    settings: {
+      ...NEW_PROFILE_SETTINGS, apiUrl: 'mirror://local', apiType: 'mirror', model: 'mirror'
+    }
+  });
+
+  function normalizeSettings(source = {}) {
+    if (!source || typeof source !== 'object' || Array.isArray(source)) throw new Error('Los datos del perfil no son válidos.');
+    const settings = {};
+    STORAGE_PROFILE_FIELDS.forEach(key => {
+      if (key === 'apiKey') {
+        if (source[key] === '' || source[key] === null || source[key] === undefined) {
+          settings.apiKey = null;
+          return;
+        }
+        if (!Backup?.validateApiKeySecret) throw new Error('La validación de API keys no está disponible.');
+        Backup.validateApiKeySecret(source[key]);
+      }
+      if (source[key] !== undefined) settings[key] = clone(source[key]);
+    });
+    return settings;
+  }
+
+  function normalizeRecord(record = {}) {
+    const name = String(record.name || '').trim();
+    if (!name) throw new Error('El nombre del perfil no puede estar vacío.');
+    return {
+      id: String(record.id || createId(name)),
+      name,
+      description: String(record.description || '').trim(),
+      schemaVersion: SCHEMA_VERSION,
+      version: Number.isInteger(record.version) && record.version > 0 ? record.version : 1,
+      updatedAt: Number(record.updatedAt) || Date.now(),
+      settings: normalizeSettings(record.settings || record)
+    };
+  }
+
+  function createRepository(storage = Storage) {
+    function readDocument() {
+      const raw = storage?.getStorageItem ? storage.getStorageItem(STORAGE_KEY) : null;
+      if (!raw) return null;
+      let doc;
+      try {
+        doc = JSON.parse(raw);
+      } catch (_) {
+        throw new Error('El almacenamiento de perfiles no es JSON válido.');
+      }
+      if (!doc || doc.schemaVersion !== SCHEMA_VERSION || !Array.isArray(doc.profiles)) {
+        throw new Error('El almacenamiento de perfiles no tiene un formato válido.');
+      }
+      return { schemaVersion: SCHEMA_VERSION, profiles: doc.profiles.map(normalizeRecord) };
+    }
+
+    function writeDocument(document) {
+      if (!storage?.setStorageItem) throw new Error('El almacenamiento de perfiles no está disponible.');
+      storage.setStorageItem(STORAGE_KEY, JSON.stringify(document));
+    }
+
+    function initialize() {
+      const existing = readDocument();
+      if (existing) {
+        if (!existing.profiles.some(profile => profile.id === READONLY_PROFILE_ID)) {
+          existing.profiles.unshift(normalizeRecord(MIRROR_PROFILE));
+          writeDocument(existing);
+        }
+        return clone(existing);
+      }
+
+      const document = { schemaVersion: SCHEMA_VERSION, profiles: [normalizeRecord(MIRROR_PROFILE)] };
+      writeDocument(document);
+      return clone(document);
+    }
+
+    function list() {
+      return initialize().profiles;
+    }
+
+    function get(id) {
+      const cleanId = String(id || '');
+      return list().find(profile => profile.id === cleanId) || null;
+    }
+
+    async function load(id) {
+      const profile = get(id);
+      if (!profile) return null;
+      const secret = profile.settings.apiKey;
+      if (secret) {
+        if (!Backup?.decryptApiKey) throw new Error('El descifrado de API keys no está disponible.');
+        profile.settings.apiKey = await Backup.decryptApiKey(secret);
+      } else {
+        profile.settings.apiKey = '';
+      }
+      return profile;
+    }
+
+    function findByName(name) {
+      const cleanName = String(name || '').trim();
+      return list().find(profile => profile.name === cleanName) || null;
+    }
+
+    function save(record) {
+      const current = initialize();
+      const normalized = normalizeRecord(record);
+      if (normalized.id === READONLY_PROFILE_ID || normalized.name === MIRROR_PROFILE.name) {
+        throw new Error('El perfil Espejo no se puede modificar.');
+      }
+      const index = current.profiles.findIndex(profile => profile.id === normalized.id);
+      if (index >= 0) {
+        if (current.profiles[index].settings.apiKeyLocked === true) throw new Error('Los cambios de este perfil están bloqueados.');
+        normalized.version = current.profiles[index].version + 1;
+      }
+      normalized.updatedAt = Date.now();
+      if (index >= 0) current.profiles[index] = normalized;
+      else current.profiles.push(normalized);
+      writeDocument(current);
+      return clone(normalized);
+    }
+
+    async function saveEditable(record) {
+      if (typeof record?.settings?.apiKey !== 'string') throw new Error('La API key del perfil no es válida.');
+      if (!Backup?.encryptApiKey) throw new Error('El cifrado de API keys no está disponible.');
+      const apiKey = await Backup.encryptApiKey(record.settings.apiKey);
+      return save({ ...record, settings: { ...record.settings, apiKey } });
+    }
+
+    function remove(id) {
+      if (String(id || '') === READONLY_PROFILE_ID) return false;
+      const current = initialize();
+      const index = current.profiles.findIndex(profile => profile.id === String(id || ''));
+      if (index < 0) return false;
+      current.profiles.splice(index, 1);
+      writeDocument(current);
+      return true;
+    }
+
+    function mergeImported(records) {
+      if (!Array.isArray(records) || records.length > 100) throw new Error('La lista de perfiles importados no es válida.');
+      const current = initialize();
+      const imported = records.map(normalizeRecord).filter(profile => profile.id !== READONLY_PROFILE_ID && profile.name !== MIRROR_PROFILE.name);
+      if (imported.length !== records.length) throw new Error('La copia no puede modificar el perfil Espejo.');
+      const ids = new Set();
+      const names = new Set();
+      imported.forEach(profile => {
+        if (ids.has(profile.id) || names.has(profile.name)) throw new Error('La copia contiene perfiles duplicados.');
+        ids.add(profile.id); names.add(profile.name);
+      });
+      const editable = current.profiles.filter(profile => profile.id !== READONLY_PROFILE_ID);
+      const byId = new Map(editable.map(profile => [profile.id, profile]));
+      const existingNames = new Map(editable.map(profile => [profile.name, profile.id]));
+      let added = 0;
+      let replaced = 0;
+      imported.forEach(profile => {
+        const nameOwner = existingNames.get(profile.name);
+        if (nameOwner && nameOwner !== profile.id) throw new Error(`Ya existe un perfil llamado "${profile.name}" con otro identificador.`);
+        if (byId.has(profile.id)) replaced += 1;
+        else added += 1;
+        byId.set(profile.id, profile);
+      });
+      writeDocument({ schemaVersion: SCHEMA_VERSION, profiles: [normalizeRecord(MIRROR_PROFILE), ...byId.values()] });
+      return { added, replaced, total: imported.length };
+    }
+
+    return { initialize, list, get, load, findByName, save, saveEditable, remove, mergeImported };
+  }
+
+  const defaultRepository = createRepository();
+  return { STORAGE_KEY, SCHEMA_VERSION, PROFILE_FIELDS, STORAGE_PROFILE_FIELDS, READONLY_PROFILE_ID, MIRROR_PROFILE: clone(MIRROR_PROFILE), NEW_PROFILE_SETTINGS: clone(NEW_PROFILE_SETTINGS), createRepository, ...defaultRepository };
+}));

zerochat_runtime/assets/js/providers-webllm.js

@@ -0,0 +1,486 @@
+/**
+ * Adaptador WebLLM: carga diferida y transporte local en el navegador.
+ * WebLLM conserva por defecto los artefactos de los modelos mediante Cache Storage.
+ */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = factory(require('./providers.js'));
+  } else {
+    root.ChatWebLLM = factory(root.ChatProviders);
+  }
+})(typeof self !== 'undefined' ? self : this, function (Providers) {
+  'use strict';
+
+  const WEBLLM_URL = 'https://cdn.jsdelivr.net/npm/@mlc-ai/web-llm@0.2.85/+esm';
+  const COMPLETED_MODELS_STORAGE_KEY = 'webllm_completed_models_v1';
+  let modulePromise = null;
+
+  function supported() {
+    return typeof navigator !== 'undefined' && !!navigator.gpu && typeof caches !== 'undefined' && typeof ReadableStream !== 'undefined' && typeof AbortController !== 'undefined';
+  }
+
+  function supportError() {
+    if (typeof navigator === 'undefined' || !navigator.gpu) return 'WebGPU no está disponible en este navegador.';
+    if (typeof caches === 'undefined') return 'Cache Storage no está disponible en este navegador.';
+    return 'El navegador no admite los requisitos de WebLLM.';
+  }
+
+  function getAppConfig(webllm) {
+    const base = webllm.prebuiltAppConfig;
+    if (!base || !Array.isArray(base.model_list)) throw new Error('WebLLM did not provide a valid model catalog.');
+    return { ...base, model_list: base.model_list };
+  }
+
+  function getStorage() {
+    if (typeof globalThis !== 'undefined' && globalThis.ChatStorage) return globalThis.ChatStorage;
+    return typeof require !== 'undefined' ? require('./cookies.js') : null;
+  }
+
+  function completedModels() {
+    const Storage = getStorage();
+    if (!Storage?.getStorageItem) return null;
+    try {
+      const models = JSON.parse(Storage.getStorageItem(COMPLETED_MODELS_STORAGE_KEY) || '[]');
+      return new Set(Array.isArray(models) ? models.filter(model => typeof model === 'string') : []);
+    } catch (_) {
+      return new Set();
+    }
+  }
+
+  function getCompletedModelIds() {
+    const models = completedModels();
+    return models ? Array.from(models) : [];
+  }
+
+  function isModelCompleted(modelId) {
+    const models = completedModels();
+    return models ? models.has(modelId) : false;
+  }
+
+  function setModelCompleted(modelId, completed) {
+    const Storage = getStorage();
+    if (!Storage?.setStorageItem) return false;
+    const models = completedModels() || new Set();
+    if (completed) models.add(modelId);
+    else models.delete(modelId);
+    try {
+      Storage.setStorageItem(COMPLETED_MODELS_STORAGE_KEY, JSON.stringify([...models]));
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  async function getModelAvailability(webllm, modelId, appConfig) {
+    if (typeof webllm.hasModelInCache !== 'function') return 'unknown';
+    const cached = await webllm.hasModelInCache(modelId, appConfig);
+    const recorded = completedModels();
+    if (cached !== true) return recorded?.has(modelId) ? 'incomplete' : 'missing';
+    if (recorded === null) return 'unknown';
+    return recorded.has(modelId) ? 'cached' : 'incomplete';
+  }
+
+  async function isModelAvailable(webllm, modelId, appConfig) {
+    return await getModelAvailability(webllm, modelId, appConfig) === 'cached';
+  }
+
+  function loadWebLLM(loader) {
+    if (!supported()) return Promise.reject(new Error(supportError()));
+    if (!modulePromise) {
+      const importModule = loader || (async (url) => {
+        if (typeof globalThis !== 'undefined' && globalThis.webllm?.CreateWebWorkerMLCEngine) {
+          return globalThis.webllm;
+        }
+        return await import(/* webpackIgnore: true */ url);
+      });
+      modulePromise = Promise.resolve().then(() => importModule(WEBLLM_URL)).catch(error => {
+        modulePromise = null;
+        throw new Error(`No se pudo preparar WebLLM: ${error.message || error}`);
+      });
+    }
+    return modulePromise;
+  }
+
+  function normalizeProgress(progress) {
+    const detail = String(progress?.text || '').trim();
+    const explicit = progress?.progress === null || progress?.progress === undefined ? NaN : Number(progress.progress);
+    const match = detail.match(/(\d+(?:\.\d+)?)%\s+completed/i);
+    const percent = Number.isFinite(explicit)
+      ? Math.max(0, Math.min(100, explicit <= 1 ? explicit * 100 : explicit))
+      : (match ? Math.max(0, Math.min(100, Number(match[1]))) : null);
+    let phase = 'preparing';
+    if (/shader modules/i.test(detail)) phase = 'compiling';
+    else if (/fetch params|loading model/i.test(detail)) phase = 'loading';
+    else if (/finish loading/i.test(detail)) phase = 'ready';
+    return { phase, percent, detail };
+  }
+
+  function emitProgress(onProgress, progress) {
+    onProgress?.(typeof progress === 'string' ? { phase: progress, percent: null, detail: '' } : normalizeProgress(progress));
+  }
+
+  function abortError() {
+    return typeof DOMException === 'function' ? new DOMException('Aborted', 'AbortError') : Object.assign(new Error('Aborted'), { name: 'AbortError' });
+  }
+
+  function workerError(detail) {
+    const suffix = detail ? ` (${detail})` : '';
+    const error = new Error(`WebLLM could not start its dedicated worker${suffix}. Local inference was not started to keep the browser responsive.`);
+    error.code = 'WEBLLM_WORKER_UNAVAILABLE';
+    return error;
+  }
+
+  function extractOverrides(config) {
+    if (!config || typeof config !== 'object') return null;
+    const overrides = {};
+    const parseParam = val => {
+      if (val === undefined || val === null || val === '' || val === 'default') return null;
+      const num = Number(val);
+      return Number.isFinite(num) && num > 0 ? Math.floor(num) : null;
+    };
+    const cw = parseParam(config.context_window_size);
+    if (cw !== null) overrides.context_window_size = cw;
+    const pc = parseParam(config.prefill_chunk_size);
+    if (pc !== null) overrides.prefill_chunk_size = pc;
+    return Object.keys(overrides).length > 0 ? overrides : null;
+  }
+
+  function applyModelOverrides(appConfig, modelId, overrides) {
+    if (!overrides || Object.keys(overrides).length === 0) return appConfig;
+    const cloned = JSON.parse(JSON.stringify(appConfig || {}));
+    if (Array.isArray(cloned.model_list)) {
+      const entry = cloned.model_list.find(m => m.model_id === modelId);
+      if (entry) {
+        entry.overrides = Object.assign({}, entry.overrides, overrides);
+      }
+    }
+    return cloned;
+  }
+
+  function getActiveWebllmConfig() {
+    try {
+      const State = typeof ChatState !== 'undefined' ? ChatState : (typeof globalThis !== 'undefined' ? globalThis.ChatState : null);
+      const cfg = State?.get?.('config') || (typeof ChatConfig !== 'undefined' ? ChatConfig.get?.() : null);
+      return cfg?.webllmConfig || null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function createWorkerEngine(webllm, modelId, appConfig, onProgress, signal, chatOpts = {}) {
+    if (typeof Worker === 'undefined' || typeof Blob === 'undefined' || typeof URL === 'undefined' || typeof URL.createObjectURL !== 'function' || typeof webllm.CreateWebWorkerMLCEngine !== 'function') {
+      return Promise.reject(workerError('Dedicated Web Worker support is unavailable'));
+    }
+
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let worker = null;
+      let workerUrl = null;
+
+      const workerFailure = event => fail(event);
+      const abort = () => fail(abortError(), false);
+      const cleanup = () => {
+        if (worker) {
+          worker.removeEventListener('error', workerFailure);
+          worker.removeEventListener('messageerror', workerFailure);
+        }
+        signal?.removeEventListener('abort', abort);
+      };
+      const discard = () => {
+        if (worker) {
+          worker.terminate();
+        }
+        if (workerUrl) {
+          URL.revokeObjectURL(workerUrl);
+        }
+      };
+      const fail = (event, isWorkerFailure = true) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        discard();
+        let detail = typeof event === 'string' ? event : (event?.message || event?.error?.message || event?.messageText || '');
+        if (typeof detail === 'string') detail = detail.trim();
+        if (detail === '[object Object]' || !detail) {
+          if (event && typeof event === 'object') {
+            detail = event.error?.message || event.cause?.message || (typeof event.error === 'string' ? event.error : '') || '';
+          }
+        }
+        if (detail === '[object Object]' || !detail) {
+          detail = 'WebLLM model preparation failed.';
+        }
+        const error = event?.name === 'AbortError' || (!isWorkerFailure && event instanceof Error)
+          ? (event.message === '[object Object]' ? new Error(detail, { cause: event }) : event)
+          : (isWorkerFailure
+            ? workerError(detail)
+            : new Error(detail, { cause: event }));
+        if (typeof console !== 'undefined' && console.error) {
+          console.error('[WebLLM] Preparation error:', error);
+        }
+        reject(error);
+      };
+      const notifyProgress = progress => {
+        emitProgress(onProgress, progress);
+      };
+
+      signal?.addEventListener('abort', abort, { once: true });
+      if (signal?.aborted) return abort();
+
+      const source = `import * as webllm from ${JSON.stringify(WEBLLM_URL)};\nconst handler = new webllm.WebWorkerMLCEngineHandler();\nself.onmessage = event => handler.onmessage(event);`;
+      workerUrl = URL.createObjectURL(new Blob([source], { type: 'text/javascript' }));
+      try {
+        worker = new Worker(workerUrl, { type: 'module' });
+      } catch (error) {
+        URL.revokeObjectURL(workerUrl);
+        workerUrl = null;
+        fail(error);
+        return;
+      }
+
+      worker.addEventListener('error', workerFailure, { once: true });
+      worker.addEventListener('messageerror', workerFailure, { once: true });
+
+      const opts = chatOpts || {};
+      webllm.CreateWebWorkerMLCEngine(worker, modelId, { appConfig, initProgressCallback: notifyProgress }, opts)
+        .then(engine => {
+          if (settled) {
+            engine.unload?.();
+            return;
+          }
+          settled = true;
+          cleanup();
+          resolve({
+            engine,
+            release: async () => {
+              try { await engine.unload?.(); } finally { discard(); }
+            }
+          });
+        })
+        .catch(error => fail(error, false));
+    });
+  }
+
+  class WebLLMEngineManager {
+    constructor(createEngine = createWorkerEngine) {
+      this.createEngine = createEngine;
+      this.active = null;
+      this.pending = null;
+    }
+
+    async acquire(webllm, modelId, appConfig, onProgress, signal, chatOpts = {}) {
+      if (this.active?.modelId === modelId) return { handle: this.active.handle, reused: true };
+      if (this.pending) {
+        if (this.pending.modelId !== modelId) throw new Error('Another WebLLM model is still being prepared.');
+        return { handle: await this.pending.promise, reused: false };
+      }
+      if (this.active) await this.dispose();
+
+      onProgress?.({ phase: 'starting', percent: null, detail: '' });
+      const controller = new AbortController();
+      const abort = () => controller.abort(signal?.reason);
+      signal?.addEventListener('abort', abort, { once: true });
+      if (signal?.aborted) abort();
+      const pending = { modelId, promise: null, controller };
+      pending.promise = this.createEngine(webllm, modelId, appConfig, onProgress, controller.signal, chatOpts)
+        .then(handle => {
+          this.active = { modelId, handle };
+          return handle;
+        })
+        .finally(() => {
+          signal?.removeEventListener('abort', abort);
+          if (this.pending === pending) this.pending = null;
+        });
+      this.pending = pending;
+      return { handle: await pending.promise, reused: false };
+    }
+
+    async dispose(modelId) {
+      if (modelId && this.active?.modelId !== modelId && this.pending?.modelId !== modelId) return;
+      if (this.pending) {
+        this.pending.controller.abort();
+        try { await this.pending.promise; } catch (_) { /* The caller receives the preparation error. */ }
+      }
+      const active = this.active;
+      this.active = null;
+      await active?.handle.release();
+    }
+  }
+
+  async function listModels(options = {}) {
+    const webllm = await loadWebLLM(options.loader);
+    const appConfig = getAppConfig(webllm);
+    const entries = Array.isArray(appConfig?.model_list) ? appConfig.model_list : [];
+    const models = await Promise.all(entries.map(async entry => {
+      let cached = null;
+      try {
+        cached = await getModelAvailability(webllm, entry.model_id, appConfig);
+      } catch (_) { cached = 'unknown'; }
+      const defaultContext = Number(entry.overrides?.context_window_size);
+      const contextLength = Number.isFinite(defaultContext) && defaultContext > 0 ? Math.floor(defaultContext) : 4096;
+      return {
+        id: entry.model_id,
+        name: entry.model_id,
+        details: {
+          webllmCache: cached,
+          webllmVramMB: Number.isFinite(Number(entry.vram_required_MB)) ? Number(entry.vram_required_MB) : null,
+          loaded_context_length: contextLength,
+          max_context_length: contextLength
+        }
+      };
+    }));
+    models.sort((a, b) => {
+      const aCached = a?.details?.webllmCache === 'cached' ? 1 : 0;
+      const bCached = b?.details?.webllmCache === 'cached' ? 1 : 0;
+      return bCached - aCached;
+    });
+    return { success: true, models, count: models.length, endpoint: 'webllm://local' };
+  }
+
+  function toSseStream(iterable, release) {
+    const encoder = new TextEncoder();
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+      async pull(controller) {
+        try {
+          const next = await iterator.next();
+          if (next.done) {
+            controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+            controller.close();
+            await release();
+            return;
+          }
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(next.value)}\n\n`));
+        } catch (error) {
+          await release();
+          controller.error(error);
+        }
+      },
+      async cancel() {
+        try { await iterator.return?.(); } finally { await release(); }
+      }
+    });
+  }
+
+  const BaseProviderAdapter = Providers?.BaseProviderAdapter || class {};
+  class WebLLMProviderAdapter extends BaseProviderAdapter {
+    constructor(options = {}) {
+      super({
+        id: 'webllm', label: 'WebLLM (local)', reasoningLevels: ['none'],
+        connection: { endpoint: 'webllm://local', endpointReadOnly: true, credentials: false, localModelManagement: true },
+        capabilities: { vision: false, tools: false, reasoning: false, jsonMode: false, promptCaching: false, embeddings: false, modelListing: true },
+        ...options
+      });
+      this.engines = options.engineManager || new WebLLMEngineManager();
+    }
+
+    normalizeEndpoint() { return 'webllm://local'; }
+    buildHeaders() { return {}; }
+    supportsUsageStatistics() { return false; }
+    async listModels(options) { return listModels(options); }
+
+    async disposeActiveEngine() {
+      await this.engines.dispose();
+    }
+
+    async deactivate() {
+      await this.disposeActiveEngine();
+    }
+
+    async createStreamResponse({ payload, signal, onProgress }) {
+      if (!payload.model) throw new Error('Selecciona un modelo WebLLM descargado en el perfil.');
+      const webllm = await loadWebLLM();
+      let appConfig = getAppConfig(webllm);
+      const available = await isModelAvailable(webllm, payload.model, appConfig);
+      if (!available) throw new Error('El modelo WebLLM no está disponible por completo en el almacenamiento local. Descárgalo desde el perfil antes de iniciar el chat.');
+
+      const activeWebllmConfig = payload.webllmConfig || getActiveWebllmConfig();
+      const overrides = extractOverrides(activeWebllmConfig);
+      if (overrides) {
+        appConfig = applyModelOverrides(appConfig, payload.model, overrides);
+      }
+
+      if (signal?.aborted) throw abortError();
+      const acquired = await this.engines.acquire(webllm, payload.model, appConfig, onProgress, signal, overrides || {});
+      const engineHandle = acquired.handle;
+      if (signal?.aborted) {
+        throw abortError();
+      }
+      const interrupt = () => engineHandle.engine?.interruptGenerate?.();
+      signal?.addEventListener('abort', interrupt, { once: true });
+      const finishStream = () => signal?.removeEventListener('abort', interrupt);
+      try {
+        const stream = await engineHandle.engine.chat.completions.create({ ...payload, stream: true });
+        return { ok: true, body: toSseStream(stream, finishStream) };
+      } catch (error) {
+        finishStream();
+        throw error;
+      }
+    }
+
+    async downloadModel(modelId, onProgress) {
+      const webllm = await loadWebLLM();
+      const appConfig = getAppConfig(webllm);
+      try {
+        await this.engines.acquire(webllm, modelId, appConfig, onProgress);
+        const cached = await webllm.hasModelInCache?.(modelId, appConfig);
+        if (cached !== true) {
+          throw new Error('WebLLM terminó la preparación, pero el navegador no pudo guardar el modelo en Cache Storage.');
+        }
+        if (!setModelCompleted(modelId, true)) {
+          throw new Error('WebLLM could not persist the completed model verification.');
+        }
+      } catch (error) {
+        setModelCompleted(modelId, false);
+        await this.engines.dispose(modelId);
+        throw error;
+      }
+      return true;
+    }
+
+    async deleteModel(modelId) {
+      await this.engines.dispose(modelId);
+      const webllm = await loadWebLLM();
+      const appConfig = getAppConfig(webllm);
+      if (typeof webllm.deleteModelAllInfoInCache !== 'function') {
+        throw new Error('Esta versión de WebLLM no permite borrar modelos individualmente.');
+      }
+      await webllm.deleteModelAllInfoInCache(modelId, appConfig);
+      const removed = await webllm.hasModelInCache?.(modelId, appConfig) !== true;
+      if (removed) setModelCompleted(modelId, false);
+      return removed;
+    }
+
+    async cancelModelOperation(modelId) {
+      await this.engines.dispose(modelId);
+    }
+
+    getCompletedModelIds() {
+      return getCompletedModelIds();
+    }
+
+    isModelCompleted(modelId) {
+      return isModelCompleted(modelId);
+    }
+  }
+
+  const adapter = new WebLLMProviderAdapter();
+  Providers?.registry?.register(adapter);
+  return {
+    WEBLLM_URL,
+    COMPLETED_MODELS_STORAGE_KEY,
+    WebLLMEngineManager,
+    WebLLMProviderAdapter,
+    adapter,
+    loadWebLLM,
+    getAppConfig,
+    listModels,
+    getModelAvailability,
+    getCompletedModelIds,
+    isModelCompleted,
+    normalizeProgress,
+    createWorkerEngine,
+    extractOverrides,
+    applyModelOverrides,
+    getActiveWebllmConfig
+  };
+});