zerochat 7.3.0__py3-none-any.whl

zerochat_runtime/assets/js/tools/builtin/search-web.tool.js

@@ -0,0 +1,125 @@
+/** Tool autocontenida: search_web. */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatBuiltinSearchWebTool = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  const definition = {
+    name: 'search_web',
+    description: 'Searches the internet in real time for up-to-date information, news, articles, and web links using DuckDuckGo.',
+    parameters: {
+      type: 'object',
+      properties: { query: { type: 'string', description: 'Search terms or query (e.g. "INE population Ceuta census", "DeepSeek R1").' } },
+      required: ['query']
+    }
+  };
+
+  function getQuery(args) {
+    return args?.query || args?.q || args?.search || args?.keyword || args?.term || args?.input || (typeof args === 'string' ? args : '');
+  }
+
+  function createCardWrapper(ui) {
+    if (ui?.createCardWrapper) return ui.createCardWrapper();
+    const doc = ui?.document || (typeof document !== 'undefined' ? document : null);
+    if (!doc) return null;
+    const cardDiv = doc.createElement('div');
+    cardDiv.className = 'tool-card-wrapper';
+    return cardDiv;
+  }
+
+  const SEARCH_ICON_SVG = '<svg class="ui-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg>';
+  const LINK_ICON_SVG = '<svg class="ui-icon" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><polyline points="15 3 21 3 21 9"></polyline><line x1="10" y1="14" x2="21" y2="3"></line></svg>';
+
+  function getHtmlSafety() {
+    const Utils = (typeof window !== 'undefined' && window.ChatUtils)
+      || (typeof require !== 'undefined' ? (() => { try { return require('../../utils.js'); } catch (_) { return null; } })() : null);
+    if (Utils) return { ...Utils, renderMarkdown: value => Utils.escapeHtml(value) };
+    return { escapeHtml: () => '', sanitizeUrl: () => '#', renderMarkdown: () => '' };
+  }
+
+  function createLiveCard(args, ui) {
+    const cardDiv = createCardWrapper(ui);
+    if (!cardDiv) return null;
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || getHtmlSafety();
+    const t = ui?.t || ((key) => key);
+    const spinner = ui?.SPINNER_SVG || '';
+    const chevron = ui?.CHEVRON_SVG || '';
+    cardDiv.innerHTML = `<div class="web-search-card"><div class="search-card-header"><div class="search-card-title"><span>${SEARCH_ICON_SVG}</span><span>${t('tool_search_title') || 'Búsqueda en Internet'}</span></div><div class="tool-card-header-actions"><span class="search-card-badge status-loading">${spinner} <span>${t('tool_badge_searching') || 'Buscando...'}</span></span><button type="button" class="btn-tool-collapse" title="${t('tool_btn_collapse') || 'Minimizar'}">${chevron}</button></div></div><div class="tool-card-collapsible-body"><div class="search-query-section"><div class="section-label">${t('tool_search_query')}</div><div class="query-badge">${SEARCH_ICON_SVG} <strong>${Markdown.escapeHtml(getQuery(args))}</strong></div></div><div class="search-results-section"><div class="section-label search-sources-label">${t('tool_search_searching') || 'Buscando fuentes...'}</div><div class="search-results-list tool-loading-placeholder">${spinner} <span>${t('tool_loading_search') || 'Consultando motores de búsqueda...'}</span></div></div></div></div>`;
+    return cardDiv;
+  }
+
+  function updateLiveCard(cardDiv, _args, result = {}, elapsedMs = 0, ui) {
+    if (!cardDiv) return;
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || getHtmlSafety();
+    const t = ui?.t || ((key) => key);
+    const checkSvg = ui?.CHECK_SVG || '';
+    const errorSvg = ui?.ERROR_SVG || '';
+    const isSuccess = result?.success !== false && !result?.error;
+    const count = result?.count || (Array.isArray(result?.results) ? result.results.length : 0);
+    const badge = cardDiv.querySelector('.search-card-badge');
+    if (badge) {
+      badge.className = `search-card-badge ${isSuccess ? 'status-success' : 'status-error'}`;
+      badge.innerHTML = isSuccess
+        ? `${checkSvg} <span>${count} fuentes (${elapsedMs || 0}ms)</span>`
+        : `${errorSvg} <span>Error búsqueda (${elapsedMs || 0}ms)</span>`;
+    }
+    const label = cardDiv.querySelector('.search-sources-label');
+    if (label) label.textContent = t('tool_search_sources_label') || 'Fuentes y resultados encontrados:';
+    const list = cardDiv.querySelector('.search-results-list');
+    if (!list) return;
+    if (result?.results?.length) {
+      list.innerHTML = result.results.map(item => `<div class="search-result-item"><div><a href="${Markdown.sanitizeUrl(item.url)}" target="_blank" rel="noopener noreferrer">${LINK_ICON_SVG} ${Markdown.escapeHtml(item.title)}</a> <small style="opacity:0.75;">(${Markdown.escapeHtml(item.source || 'web')})</small></div>${item.snippet ? `<div class="search-result-snippet">${Markdown.escapeHtml(item.snippet)}</div>` : ''}</div>`).join('');
+    } else if (result?.markdown) list.innerHTML = `<div class="search-result-snippet">${Markdown.renderMarkdown(result.markdown)}</div>`;
+    else list.innerHTML = `<div class="search-result-snippet"><em>${t('tool_search_empty') || 'No se encontraron resultados relevantes.'}</em></div>`;
+  }
+
+  function renderHistoricalCard(args, toolMessage, ui) {
+    const cardDiv = createLiveCard(args, ui);
+    if (!cardDiv) return null;
+    let result = {};
+    if (toolMessage?.content) {
+      try { result = JSON.parse(toolMessage.content); } catch (e) { result = { markdown: toolMessage.content }; }
+    }
+    updateLiveCard(cardDiv, args, result, 0, ui);
+    return cardDiv;
+  }
+
+  function createTool(Tool) {
+    if (typeof Tool !== 'function') throw new Error('La clase Tool es necesaria para crear search_web.');
+    return new Tool({
+      id: definition.name,
+      definition,
+      aliases: ['searchweb', 'web_search', 'duckduckgo_search', 'duckduckgo', 'search_internet', 'internet_search', 'search'],
+      category: 'web',
+      metadata: { icon: 'search', label: definition.name },
+      settings: {
+        titleKey: 'agent_search_title', titleFallback: 'Búsqueda en DuckDuckGo en Tiempo Real',
+        descKey: 'agent_search_desc', descFallback: 'Permite al modelo invocar search_web para buscar información actualizada, definiciones, noticias y enlaces web mediante la API de DuckDuckGo.',
+        icon: 'search', defaultEnabled: true, showInSettings: true
+      },
+      promptGuide: () => '- `search_web(query="...")`: Searches up-to-date information, news, articles, and links on the internet using DuckDuckGo.',
+      execute: async (args, context = {}) => {
+        const WebSearch = context.services?.webSearch;
+        if (!WebSearch || !WebSearch.search) return { success: false, error: 'Módulo WebSearch no disponible.' };
+        return WebSearch.search(getQuery(args), context.language || context.lang || 'es');
+      },
+      result: {
+        toModel: (_args, result) => result?.markdown || JSON.stringify(result || {}),
+        toMarkdown: (args, result) => {
+          const resultText = result?.markdown || JSON.stringify(result || {});
+          return `> 🔍 **search_web** (${result?.count || 0} fuentes)\n> Query: "${args.query || ''}"\n> \`\`\`markdown\n> ${resultText.split('\n').join('\n> ')}\n> \`\`\``;
+        }
+      },
+      displayMode: 'collapsed',
+      view: { id: definition.name, displayMode: 'collapsed', createLiveCard, updateLiveCard, renderHistoricalCard }
+    });
+  }
+
+  const toolModule = { id: definition.name, definition, displayMode: 'collapsed', createTool, getQuery, view: { id: definition.name, displayMode: 'collapsed', createLiveCard, updateLiveCard, renderHistoricalCard } };
+  let manifestApi = null;
+  if (typeof window !== 'undefined' && window.ChatToolManifest) manifestApi = window.ChatToolManifest;
+  else if (typeof require !== 'undefined') { try { manifestApi = require('../tool-manifest.js'); } catch (e) {} }
+  if (manifestApi?.builtin && !manifestApi.builtin.has(toolModule.id)) manifestApi.builtin.register(toolModule);
+  return toolModule;
+});

zerochat_runtime/assets/js/tools/tool-manifest.js

@@ -0,0 +1,53 @@
+/**
+ * Registro de módulos de tools autocontenidas.
+ *
+ * Los módulos futuros se registrarán aquí al cargarse; durante la transición
+ * las tools existentes continúan registrándose mediante BuiltinToolProvider.
+ */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = factory();
+  } else {
+    root.ChatToolManifest = factory();
+  }
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  class ToolModuleManifest {
+    constructor(options = {}) {
+      this.id = options.id || 'builtin';
+      this.modules = new Map();
+    }
+
+    register(toolModule, options = {}) {
+      if (!toolModule || typeof toolModule.id !== 'string' || !toolModule.id.trim()) {
+        throw new Error('Un módulo de tool debe declarar un id válido.');
+      }
+      const id = toolModule.id.trim();
+      if (this.modules.has(id) && !options.overwrite) {
+        throw new Error(`El módulo de tool '${id}' ya está registrado.`);
+      }
+      this.modules.set(id, toolModule);
+      return toolModule;
+    }
+
+    has(id) {
+      return this.modules.has(id);
+    }
+
+    get(id) {
+      return this.modules.get(id) || null;
+    }
+
+    list() {
+      return Array.from(this.modules.values());
+    }
+  }
+
+  const builtin = new ToolModuleManifest({ id: 'builtin' });
+
+  return {
+    ToolModuleManifest,
+    builtin
+  };
+});

zerochat_runtime/assets/js/tools/tool-runtime.js

@@ -0,0 +1,77 @@
+/**
+ * Infraestructura de ejecución para módulos de tools de ZeroChat.
+ *
+ * Expone un contexto explícito y servicios resueltos de forma perezosa para
+ * que cada tool autocontenida declare sólo las dependencias que consume.
+ */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = factory();
+  } else {
+    root.ChatToolRuntime = factory();
+  }
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  const SERVICE_DEFINITIONS = {
+    sandbox: { globalName: 'ChatSandbox', modulePath: '../sandbox.js' },
+    webSearch: { globalName: 'ChatWebSearch', modulePath: '../web-search.js' },
+    webBrowser: { globalName: 'ChatWebBrowser', modulePath: '../web-browser.js' },
+    charts: { globalName: 'ChatCharts', modulePath: '../charts.js' },
+    ragStorage: { globalName: 'ChatRagStorage', modulePath: '../ragStorage.js' },
+    ragService: { globalName: 'ChatRagService', modulePath: '../rag-service.js' },
+    mcp: { globalName: 'ChatMCP', modulePath: '../mcp.js' }
+  };
+
+  function resolveService(name) {
+    const definition = SERVICE_DEFINITIONS[name];
+    if (!definition) return null;
+
+    if (typeof window !== 'undefined') {
+      if (window[definition.globalName]) return window[definition.globalName];
+      if (definition.fallbackGlobalName && window[definition.fallbackGlobalName]) {
+        return window[definition.fallbackGlobalName];
+      }
+    }
+
+    if (typeof require !== 'undefined') {
+      try { return require(definition.modulePath); } catch (e) {}
+    }
+    return null;
+  }
+
+  /**
+   * Contenedor de servicios con resolución perezosa y sustituciones para test.
+   */
+  function createToolServices(overrides = {}) {
+    const services = {};
+    Object.keys(SERVICE_DEFINITIONS).forEach(name => {
+      Object.defineProperty(services, name, {
+        enumerable: true,
+        get: () => Object.prototype.hasOwnProperty.call(overrides, name)
+          ? overrides[name]
+          : resolveService(name)
+      });
+    });
+    return services;
+  }
+
+  /**
+   * Crea el contexto estándar recibido por execute(args, context).
+   */
+  function createToolExecutionContext(options = {}, serviceOverrides = {}) {
+    return {
+      ...options,
+      language: options.language || options.lang || 'es',
+      services: options.services || createToolServices(serviceOverrides),
+      config: options.config || {}
+    };
+  }
+
+  return {
+    SERVICE_DEFINITIONS,
+    resolveService,
+    createToolServices,
+    createToolExecutionContext
+  };
+});

zerochat_runtime/assets/js/ui-composer.js

@@ -0,0 +1,319 @@
+/**
+ * Módulo de Interfaz de Usuario para el Compositor de Mensajes (ZeroChat).
+ * Gestiona el formulario del chat, textarea con auto-ajuste de altura,
+ * eventos de teclado (Enter / Shift+Enter), portapapeles (imágenes), arrastrar y soltar (drag & drop),
+ * renderizado de adjuntos, y sincronización de controles de generación (Enviar / Parar).
+ */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') {
+    module.exports = factory();
+  } else {
+    root.ChatUIComposer = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  function resolveDep(globalName, relPath) {
+    if (typeof window !== 'undefined' && window[globalName]) return window[globalName];
+    if (typeof globalThis !== 'undefined' && globalThis[globalName]) return globalThis[globalName];
+    if (typeof require !== 'undefined') {
+      try { return require(relPath); } catch (_) {}
+    }
+    return null;
+  }
+
+  function getI18n() { return resolveDep('ChatI18n', './i18n.js'); }
+  function getAttachments() { return resolveDep('ChatAttachments', './attachments.js'); }
+  function getFileParser() { return resolveDep('ChatFileParser', './file-parser.js'); }
+  function getDialogs() { return resolveDep('ChatDialogs', './ui-dialogs.js'); }
+  function getState() { return resolveDep('ChatState', './state.js'); }
+
+  function t(key, params) {
+    const I18n = getI18n();
+    return I18n?.t?.(key, params) || key;
+  }
+
+  let activeCleanupFns = [];
+  let cachedElements = null;
+
+  // field-sizing:content gestiona el auto-resize en CSS (Baseline 2024).
+  // Esta función actúa como fallback para navegadores sin soporte.
+  function autoResizeTextarea(elements) {
+    const els = elements || cachedElements || {};
+    if (typeof CSS !== 'undefined' && CSS.supports && CSS.supports('field-sizing', 'content')) return;
+    if (!els.userInput || !els.userInput.style) return;
+    if (!els.userInput.value) {
+      els.userInput.style.height = '';
+      return;
+    }
+    els.userInput.style.height = 'auto';
+    const newHeight = Math.min(els.userInput.scrollHeight, 160);
+    els.userInput.style.height = `${newHeight}px`;
+  }
+
+  function focusInput(elements) {
+    const els = elements || cachedElements || {};
+    if (els.userInput && typeof els.userInput.focus === 'function') {
+      els.userInput.focus();
+    }
+  }
+
+  function clearInput(elements) {
+    const els = elements || cachedElements || {};
+    if (els.userInput) {
+      els.userInput.value = '';
+    }
+    autoResizeTextarea(els);
+  }
+
+  function getPromptValue(elements) {
+    const els = elements || cachedElements || {};
+    return (els.userInput?.value || '').trim();
+  }
+
+  function setPromptValue(elements, text) {
+    const els = elements || cachedElements || {};
+    if (els.userInput) {
+      els.userInput.value = text || '';
+    }
+    autoResizeTextarea(els);
+    focusInput(els);
+  }
+
+  function renderAttachedFiles(elements) {
+    const els = elements || cachedElements || {};
+    const Attachments = getAttachments();
+    if (Attachments?.renderChips) {
+      Attachments.renderChips(els.attachmentsContainer, () => autoResizeTextarea(els));
+    }
+  }
+
+  function clearAttachedFiles(elements) {
+    const els = elements || cachedElements || {};
+    const Attachments = getAttachments();
+    if (Attachments?.clearFiles) {
+      Attachments.clearFiles();
+      renderAttachedFiles(els);
+    }
+    if (els.fileInput) els.fileInput.value = '';
+  }
+
+  function readFileAsText(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = () => reject(reader.error);
+      reader.readAsText(file);
+    });
+  }
+
+  async function processFiles(elements, files) {
+    const els = elements || cachedElements || {};
+    const Attachments = getAttachments();
+    const FileParser = getFileParser();
+    const Dialogs = getDialogs();
+    const maxBytes = Attachments?.MAX_FILE_SIZE || (50 * 1024 * 1024);
+
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (file && typeof file.size === 'number' && file.size > maxBytes) {
+        if (Dialogs?.alert) {
+          await Dialogs.alert(t('err_file_too_large', { name: file.name, max: '50 MB' }), { type: 'error' });
+        }
+        continue;
+      }
+      try {
+        let parsed;
+        if (FileParser?.parseFile) {
+          parsed = await FileParser.parseFile(file);
+        } else {
+          const text = await readFileAsText(file);
+          parsed = {
+            name: file.name,
+            size: file.size,
+            type: 'text',
+            content: text
+          };
+        }
+        if (Attachments?.addFile) Attachments.addFile(parsed);
+      } catch (err) {
+        console.error(`Error processing file ${file.name}:`, err);
+        if (Dialogs?.alert) {
+          Dialogs.alert(t('err_file_process', { name: file.name, err: err.message || err }), { type: 'error' });
+        }
+      }
+    }
+    renderAttachedFiles(els);
+    focusInput(els);
+  }
+
+  function handlePasteEvent(e, elements) {
+    const els = elements || cachedElements || {};
+    if (!e.clipboardData || !e.clipboardData.items) return;
+    const items = e.clipboardData.items;
+    const FileParser = getFileParser();
+    const Attachments = getAttachments();
+
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].type && items[i].type.startsWith('image/')) {
+        const file = items[i].getAsFile();
+        if (file) {
+          e.preventDefault();
+          if (FileParser?.parseFile) {
+            FileParser.parseFile(file).then(parsed => {
+              if (Attachments?.addFile) Attachments.addFile(parsed);
+              renderAttachedFiles(els);
+            }).catch(err => {
+              console.error('Error pasting image:', err);
+            });
+          }
+        }
+      }
+    }
+  }
+
+
+  function syncGenerationControls(elements, isGenerating, options = {}) {
+    const els = elements || cachedElements || {};
+    const generating = Boolean(isGenerating);
+    if (els.btnSend) els.btnSend.disabled = generating;
+    if (els.btnStopStream) els.btnStopStream.style.display = generating ? 'inline-flex' : 'none';
+    if (!generating && typeof options.clearGenerationStatus === 'function') {
+      options.clearGenerationStatus();
+    }
+  }
+
+  function mount(elements, { onSendMessage, onStopGeneration } = {}) {
+    dispose();
+    cachedElements = elements || {};
+    const els = cachedElements;
+
+    if (els.chatForm) {
+      const onSubmit = function (e) {
+        e.preventDefault();
+        if (typeof onSendMessage === 'function') onSendMessage();
+      };
+      els.chatForm.addEventListener('submit', onSubmit);
+      activeCleanupFns.push(() => els.chatForm.removeEventListener('submit', onSubmit));
+
+      const onDragOver = function (e) {
+        e.preventDefault();
+        els.chatForm.classList.add('drag-over');
+      };
+      els.chatForm.addEventListener('dragover', onDragOver);
+      activeCleanupFns.push(() => els.chatForm.removeEventListener('dragover', onDragOver));
+
+      const onDragLeave = function () {
+        els.chatForm.classList.remove('drag-over');
+      };
+      els.chatForm.addEventListener('dragleave', onDragLeave);
+      activeCleanupFns.push(() => els.chatForm.removeEventListener('dragleave', onDragLeave));
+
+      const onDrop = function (e) {
+        e.preventDefault();
+        els.chatForm.classList.remove('drag-over');
+        if (e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+          processFiles(els, Array.from(e.dataTransfer.files));
+        }
+      };
+      els.chatForm.addEventListener('drop', onDrop);
+      activeCleanupFns.push(() => els.chatForm.removeEventListener('drop', onDrop));
+    }
+
+    if (els.userInput) {
+      const onKeyDown = function (e) {
+        if (e.key === 'Enter' && !e.shiftKey) {
+          e.preventDefault();
+          if (typeof onSendMessage === 'function') onSendMessage();
+        }
+      };
+      els.userInput.addEventListener('keydown', onKeyDown);
+      activeCleanupFns.push(() => els.userInput.removeEventListener('keydown', onKeyDown));
+
+      const onInput = function () {
+        autoResizeTextarea(els);
+      };
+      els.userInput.addEventListener('input', onInput);
+      activeCleanupFns.push(() => els.userInput.removeEventListener('input', onInput));
+
+      const onPaste = function (e) {
+        handlePasteEvent(e, els);
+      };
+      els.userInput.addEventListener('paste', onPaste);
+      activeCleanupFns.push(() => els.userInput.removeEventListener('paste', onPaste));
+
+      const onFocus = function () {
+        if (typeof window !== 'undefined' && window.visualViewport) {
+          setTimeout(() => {
+            if (els.userInput) {
+              els.userInput.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
+            }
+          }, 300);
+        }
+      };
+      els.userInput.addEventListener('focus', onFocus);
+      activeCleanupFns.push(() => els.userInput.removeEventListener('focus', onFocus));
+    }
+
+    if (els.btnStopStream) {
+      const onStop = function () {
+        if (typeof onStopGeneration === 'function') onStopGeneration();
+      };
+      els.btnStopStream.addEventListener('click', onStop);
+      activeCleanupFns.push(() => els.btnStopStream.removeEventListener('click', onStop));
+    }
+
+    if (els.btnAttachFile) {
+      const onAttach = function () {
+        if (els.fileInput && typeof els.fileInput.click === 'function') {
+          els.fileInput.click();
+        }
+      };
+      els.btnAttachFile.addEventListener('click', onAttach);
+      activeCleanupFns.push(() => els.btnAttachFile.removeEventListener('click', onAttach));
+    }
+
+    if (els.fileInput) {
+      const onChange = function (e) {
+        if (e.target.files && e.target.files.length > 0) {
+          processFiles(els, Array.from(e.target.files));
+        }
+      };
+      els.fileInput.addEventListener('change', onChange);
+      activeCleanupFns.push(() => els.fileInput.removeEventListener('change', onChange));
+    }
+
+    return {
+      autoResizeTextarea: () => autoResizeTextarea(els),
+      focusInput: () => focusInput(els),
+      clearInput: () => clearInput(els),
+      getPromptValue: () => getPromptValue(els),
+      setPromptValue: (text) => setPromptValue(els, text),
+      renderAttachedFiles: () => renderAttachedFiles(els),
+      clearAttachedFiles: () => clearAttachedFiles(els),
+      syncGenerationControls: (isGenerating, opts) => syncGenerationControls(els, isGenerating, opts)
+    };
+  }
+
+  function dispose() {
+    activeCleanupFns.forEach(fn => { try { fn(); } catch (_) {} });
+    activeCleanupFns = [];
+    cachedElements = null;
+  }
+
+  return {
+    autoResizeTextarea,
+    focusInput,
+    clearInput,
+    getPromptValue,
+    setPromptValue,
+    renderAttachedFiles,
+    clearAttachedFiles,
+    readFileAsText,
+    processFiles,
+    handlePasteEvent,
+    syncGenerationControls,
+    mount,
+    dispose
+  };
+}));