zerochat 7.3.0__py3-none-any.whl

zerochat_runtime/assets/js/tools/builtin/list-documents.tool.js

@@ -0,0 +1,117 @@
+/** Tool autocontenida: list_documents. */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatBuiltinListDocumentsTool = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  const definition = {
+    name: 'list_documents',
+    description: 'Returns the catalog of available documents (title, chunks, and images). Accepts an optional filter to narrow documents by title keywords (e.g. "Walmart", "2020", "10K"). Use it when you do not know the available sources or when a previous search did not find the expected document.',
+    parameters: {
+      type: 'object',
+      properties: {
+        filter: {
+          type: 'string',
+          description: 'Optional keyword, company name, year, or topic to filter document titles (e.g. "Walmart", "2020", "10-K"). If omitted, returns all documents.'
+        }
+      },
+      required: []
+    }
+  };
+
+  function getBranchIds(context = {}) {
+    return context.activeRagBranchIds || context.activeRagBranchId || context.branchId || context.config?.activeRagBranchIds || context.config?.activeRagBranchId || '';
+  }
+  const getBranchId = getBranchIds;
+
+  function getRagService(context = {}) {
+    if (context.services?.ragService) return context.services.ragService;
+    if (typeof window !== 'undefined' && window.ChatRagService) return window.ChatRagService;
+    if (typeof require !== 'undefined') {
+      try { return require('../../rag-service.js'); } catch (e) {}
+    }
+    return null;
+  }
+
+  const LAYERS_ICON_SVG = '<svg class="ui-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polygon points="12 2 2 7 12 12 22 7 12 2"></polygon><polyline points="2 17 12 22 22 17"></polyline><polyline points="2 12 12 17 22 12"></polyline></svg>';
+
+  function createCardWrapper(ui) {
+    if (ui?.createCardWrapper) return ui.createCardWrapper();
+    const doc = ui?.document || (typeof document !== 'undefined' ? document : null);
+    if (!doc) return null;
+    const card = doc.createElement('div');
+    card.className = 'tool-card-wrapper';
+    return card;
+  }
+
+  function createLiveCard(_args, ui) {
+    const card = createCardWrapper(ui);
+    if (!card) return null;
+    const t = ui?.t || ((key) => key);
+    const spinner = ui?.SPINNER_SVG || '';
+    const chevron = ui?.CHEVRON_SVG || '';
+    const title = t('tool_rag_list_title') || 'Base de Conocimiento (Índice de Documentos)';
+    const loading = t('tool_rag_list_loading') || 'Consultando documentos indexados...';
+    const retrieving = t('tool_rag_list_retrieving') || 'Recuperando documentos desde IndexedDB...';
+    card.innerHTML = `<div class="tool-execution-card rag-execution-card"><div class="tool-card-header"><div class="tool-card-title"><span>${LAYERS_ICON_SVG}</span><span>${title}</span></div><div class="tool-card-header-actions"><span class="tool-card-badge status-loading">${spinner} <span>${loading}</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="tool-card-result"><div class="tool-loading-placeholder">${spinner} <span>${retrieving}</span></div></div></div></div>`;
+    return card;
+  }
+
+  const safeEscapeHtml = (value) => String(value || '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  function updateLiveCard(card, _args, result = {}, elapsedMs = 0, ui) {
+    if (!card) return;
+    const t = ui?.t || ((key, params) => key);
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || (typeof window !== 'undefined' && window.ChatUtils) || { escapeHtml: safeEscapeHtml };
+    const checkSvg = ui?.CHECK_SVG || '';
+    const errorSvg = ui?.ERROR_SVG || '';
+    const success = result?.success !== false && !result?.error;
+    const count = result?.count ?? 0;
+    const text = result?.text || (typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result || ''));
+    const indexedLabel = t('tool_rag_list_indexed', { count, plural: count === 1 ? '' : 's' }) || `${count} doc${count === 1 ? '' : 's'} indexado${count === 1 ? '' : 's'}`;
+    const errorLabel = result?.error || t('tool_err_query') || 'Error al consultar';
+    const badge = card.querySelector('.tool-card-badge');
+    if (badge) {
+      badge.className = `tool-card-badge ${success ? 'status-success' : 'status-error'}`;
+      badge.innerHTML = success ? `${checkSvg} <span>${indexedLabel} (${elapsedMs || 0}ms)</span>` : `${errorSvg} <span>${Markdown.escapeHtml(errorLabel)}</span>`;
+    }
+    const body = card.querySelector('.tool-card-result');
+    if (body) body.innerHTML = `<pre class="tool-result-pre"><code>${Markdown.escapeHtml(text.slice(0, 3000))}${text.length > 3000 ? '\n... (texto completo truncado en tarjeta)' : ''}</code></pre>`;
+  }
+  function renderHistoricalCard(args, message, ui) { const card = createLiveCard(args, ui); if (!card) return null; let result = {}; if (message?.content) { try { result = JSON.parse(message.content); } catch (e) { result = { text: message.content }; } } updateLiveCard(card, args, result, 0, ui); return card; }
+
+  function createTool(Tool) {
+    if (typeof Tool !== 'function') throw new Error('La clase Tool es necesaria para crear list_documents.');
+    return new Tool({
+      id: definition.name,
+      definition,
+      aliases: ['listdocuments', 'list_knowledge_base', 'list_docs', 'get_documents', 'listar_documentos'],
+      category: 'rag',
+      metadata: { icon: 'book-open', label: definition.name },
+      settings: { showInSettings: false },
+      isAvailable: (config = {}) => Boolean(config.activeRagBranchId || (config.activeRagBranchIds && config.activeRagBranchIds.length > 0)),
+      execute: async (args = {}, context = {}) => {
+        const RagService = getRagService(context);
+        if (!RagService?.listDocuments) return { success: false, error: 'Servicio de RAG no disponible.' };
+        return RagService.listDocuments(getBranchIds(context), args);
+      },
+      result: {
+        toModel: (_args, result) => result?.text || JSON.stringify(result || {}),
+        toMarkdown: (args, result) => {
+          const filterSuffix = args?.filter ? ` filtrado por "${args.filter}"` : '';
+          return `> **list_documents** (${result?.count || 0} documentos indexados${filterSuffix})\n\n`;
+        }
+      },
+      displayMode: 'collapsed',
+      view: { id: definition.name, displayMode: 'collapsed', createLiveCard, updateLiveCard, renderHistoricalCard }
+    });
+  }
+
+  const toolModule = { id: definition.name, definition, displayMode: 'collapsed', createTool, getBranchId, getRagService, 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/builtin/read-knowledge-chunk.tool.js

@@ -0,0 +1,129 @@
+/** Tool module: read_knowledge_chunk. */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatBuiltinReadKnowledgeChunkTool = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  const definition = {
+    name: 'read_knowledge_chunk',
+    description: 'Reads the full content of one or several previously located chunks. Accepts chunkId for a single chunk or chunkIds (list of identifiers) to retrieve up to 5 at once in a single turn (prefer 1-2 chunks for dense financial tables). Use as internal evidence; then synthesize and respond.',
+    parameters: {
+      type: 'object',
+      properties: {
+        chunkIds: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'List of chunk identifiers to read simultaneously in a single turn (max 5; prefer 1-2 for dense tables).'
+        },
+        chunkId: {
+          type: 'string',
+          description: 'Unique chunk identifier (chunkId). Accepted as an alternative or complement to chunkIds.'
+        }
+      }
+    }
+  };
+
+  function getRagService(context = {}) {
+    if (context.services?.ragService) return context.services.ragService;
+    if (typeof window !== 'undefined' && window.ChatRagService) return window.ChatRagService;
+    if (typeof require !== 'undefined') { try { return require('../../rag-service.js'); } catch (_) {} }
+    return null;
+  }
+
+  function getBranchIds(context = {}) {
+    return context.activeRagBranchIds || context.activeRagBranchId || context.branchId || context.config?.activeRagBranchIds || context.config?.activeRagBranchId || '';
+  }
+  const getBranchId = getBranchIds;
+
+  function createCardWrapper(ui) {
+    if (ui?.createCardWrapper) return ui.createCardWrapper();
+    const doc = ui?.document || (typeof document !== 'undefined' ? document : null);
+    if (!doc) return null;
+    const card = doc.createElement('div');
+    card.className = 'tool-card-wrapper';
+    return card;
+  }
+
+  const DOC_ICON_SVG = '<svg class="ui-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline><line x1="16" y1="13" x2="8" y2="13"></line><line x1="16" y1="17" x2="8" y2="17"></line><polyline points="10 9 9 9 8 9"></polyline></svg>';
+
+  const safeEscapeHtml = (value) => String(value || '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  function createLiveCard(args, ui) {
+    const card = createCardWrapper(ui);
+    if (!card) return null;
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || (typeof window !== 'undefined' && window.ChatUtils) || { escapeHtml: safeEscapeHtml };
+    const t = ui?.t || ((key, params) => key);
+    const spinner = ui?.SPINNER_SVG || '';
+    const chevron = ui?.CHEVRON_SVG || '';
+    const title = t('tool_rag_read_title') || 'Fragmento de conocimiento';
+    const ids = Array.isArray(args?.chunkIds) && args.chunkIds.length > 0
+      ? args.chunkIds
+      : (args?.chunkId ? [args.chunkId] : []);
+    const targetLabel = ids.length > 1
+      ? `${ids.length} fragmentos`
+      : (ids[0] || '');
+    const loading = t('tool_rag_read_loading', { chunkId: Markdown.escapeHtml(targetLabel) }) || `Leyendo ${Markdown.escapeHtml(targetLabel)}...`;
+    const retrieving = t('tool_rag_read_retrieving') || 'Recuperando texto desde IndexedDB...';
+    card.innerHTML = `<div class="tool-execution-card rag-execution-card"><div class="tool-card-header"><div class="tool-card-title"><span>${DOC_ICON_SVG}</span><span>${title}</span></div><div class="tool-card-header-actions"><span class="tool-card-badge status-loading">${spinner} <span>${loading}</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="tool-card-result"><div class="tool-loading-placeholder">${spinner} <span>${retrieving}</span></div></div></div></div>`;
+    return card;
+  }
+  function updateLiveCard(card, _args, result = {}, _elapsedMs, ui) {
+    if (!card) return;
+    const t = ui?.t || ((key, params) => key);
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || (typeof window !== 'undefined' && window.ChatUtils) || { escapeHtml: safeEscapeHtml };
+    const checkSvg = ui?.CHECK_SVG || '';
+    const errorSvg = ui?.ERROR_SVG || '';
+    const success = result?.success !== false && !result?.error;
+    const content = result?.content || result?.error || '';
+    const badge = card.querySelector('.tool-card-badge');
+    const count = result?.count || (result?.chunkIds?.length) || 1;
+    const countLabel = count > 1 ? `${count} fragmentos recuperados` : 'Fragmento recuperado';
+    const retrievedLabel = t('tool_rag_read_retrieved', { chars: content.length }) || `${countLabel} (${content.length} caracteres)`;
+    const notFoundLabel = result?.error || t('tool_rag_read_not_found') || 'No encontrado';
+    if (badge) {
+      badge.className = `tool-card-badge ${success ? 'status-success' : 'status-error'}`;
+      badge.innerHTML = success ? `${checkSvg} <span>${retrievedLabel}</span>` : `${errorSvg} <span>${Markdown.escapeHtml(notFoundLabel)}</span>`;
+    }
+    const body = card.querySelector('.tool-card-result');
+    if (body) body.innerHTML = `<pre class="tool-result-pre"><code>${Markdown.escapeHtml(content.slice(0, 3000))}${content.length > 3000 ? '\n…' : ''}</code></pre>`;
+  }
+  function renderHistoricalCard(args, message, ui) {
+    const card = createLiveCard(args, ui); if (!card) return null;
+    let result = {}; try { result = JSON.parse(message?.content || '{}'); } catch (_) { result = { content: message?.content || '' }; }
+    updateLiveCard(card, args, result, 0, ui); return card;
+  }
+
+  function createTool(Tool) {
+    if (typeof Tool !== 'function') throw new Error('La clase Tool es necesaria para crear read_knowledge_chunk.');
+    return new Tool({
+      id: definition.name,
+      definition,
+      aliases: [],
+      category: 'rag',
+      metadata: { icon: 'file-text', label: definition.name },
+      settings: { showInSettings: false },
+      isAvailable: config => Boolean(config.activeRagBranchId || (config.activeRagBranchIds && config.activeRagBranchIds.length > 0)),
+      execute: async (args, context = {}) => {
+        const service = getRagService(context);
+        return service?.readKnowledgeChunk ? service.readKnowledgeChunk(getBranchIds(context), args) : { success: false, error: 'Servicio de RAG no disponible.' };
+      },
+      result: {
+        toModel: (_args, result) => result?.content || JSON.stringify(result || {}),
+        toMarkdown: (args, result) => {
+          const ids = result?.chunkIds || (args?.chunkIds) || [args?.chunkId || ''];
+          return `> **read_knowledge_chunk** (${ids.join(', ')})\n\n`;
+        }
+      },
+      displayMode: 'collapsed',
+      view: { id: definition.name, displayMode: 'collapsed', createLiveCard, updateLiveCard, renderHistoricalCard }
+    });
+  }
+
+  const toolModule = { id: definition.name, definition, displayMode: 'collapsed', createTool, getRagService, getBranchId, 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 (_) {} }
+  if (manifestApi?.builtin && !manifestApi.builtin.has(toolModule.id)) manifestApi.builtin.register(toolModule);
+  return toolModule;
+});

zerochat_runtime/assets/js/tools/builtin/read-knowledge-image.tool.js

@@ -0,0 +1,95 @@
+/** Tool module: read_knowledge_image. */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatBuiltinReadKnowledgeImageTool = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+  const definition = {
+    name: 'read_knowledge_image',
+    description: 'Retrieves an image from a RAG document to inspect it visually. Use only if you have native vision capability and the image may provide relevant information. Provide a full rag-image://docId:imgId reference obtained from the document; do not invent identifiers. If you cannot process images, do not use this tool.',
+    parameters: { type: 'object', properties: { imageRef: { type: 'string', description: 'Full rag-image://docId:imgId reference obtained from a RAG document.' } }, required: ['imageRef'] }
+  };
+  function getRagService(context = {}) {
+    if (context.services?.ragService) return context.services.ragService;
+    if (typeof window !== 'undefined' && window.ChatRagService) return window.ChatRagService;
+    if (typeof require !== 'undefined') { try { return require('../../rag-service.js'); } catch (_) {} }
+    return null;
+  }
+  function getBranchIds(context = {}) { return context.activeRagBranchIds || context.activeRagBranchId || context.branchId || context.config?.activeRagBranchIds || context.config?.activeRagBranchId || ''; }
+  function getMarkdown(ui) {
+    if (ui?.markdown?.escapeHtml) return ui.markdown;
+    if (typeof window !== 'undefined' && window.ChatMarkdown?.escapeHtml) return window.ChatMarkdown;
+    if (typeof require !== 'undefined') {
+      try {
+        const md = require('../../markdown.js');
+        if (md?.escapeHtml) return md;
+      } catch (_) {}
+    }
+    return {
+      escapeHtml: value => String(value || '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]))
+    };
+  }
+
+  function createLiveCard(args, 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';
+    const t = ui?.t || ((key) => key);
+    const md = getMarkdown(ui);
+    const safeRef = md.escapeHtml(args?.imageRef || '');
+    cardDiv.innerHTML = `<div class="rag-image-card"><div class="rag-card-header"><span>${t('tool_rag_image_title') || 'Imagen RAG'}</span>: <code>${safeRef}</code></div></div>`;
+    return cardDiv;
+  }
+
+  function updateLiveCard(cardDiv, args, result, _elapsedMs, ui) {
+    if (!cardDiv) return;
+    const t = ui?.t || ((key) => key);
+    const md = getMarkdown(ui);
+    const safeRef = md.escapeHtml(args?.imageRef || '');
+    const content = result?.success ? (result.documentTitle || result.imageRef) : (result?.error || 'Error');
+    const safeContent = md.escapeHtml(content || '');
+    cardDiv.innerHTML = `<div class="rag-image-card"><div class="rag-card-header"><span>${t('tool_rag_image_title') || 'Imagen RAG'}</span>: <code>${safeRef}</code></div><div class="rag-card-body">${safeContent}</div></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 (_) { result = { content: 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 read_knowledge_image.');
+    return new Tool({
+      id: definition.name,
+      definition,
+      aliases: [],
+      category: 'rag',
+      metadata: { icon: 'image', label: definition.name },
+      settings: { showInSettings: false },
+      isAvailable: config => Boolean(config.activeRagBranchId || (config.activeRagBranchIds && config.activeRagBranchIds.length > 0)),
+      execute: async (args, context = {}) => {
+        const service = getRagService(context);
+        return service?.readKnowledgeImage ? service.readKnowledgeImage(getBranchIds(context), args) : { success: false, error: 'Servicio de RAG no disponible.' };
+      },
+      result: {
+        toModel: (_args, result) => result?.success ? `Image retrieved: ${result.imageRef}${result.documentTitle ? ` (${result.documentTitle}${result.page ? `, page ${result.page}` : ''})` : ''}. Inspect it visually to answer.` : JSON.stringify(result || {}),
+        toMarkdown: (args, result) => result?.success ? `> **read_knowledge_image** (${result.imageRef})\n\n` : `> **read_knowledge_image** (${args?.imageRef || ''}) · ${result?.error || 'Error'}\n\n`
+      },
+      displayMode: 'collapsed',
+      view: { id: definition.name, displayMode: 'collapsed', createLiveCard, updateLiveCard, renderHistoricalCard }
+    });
+  }
+  const toolModule = { id: definition.name, definition, displayMode: 'collapsed', createTool, getRagService, 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 (_) {} }
+  if (manifestApi?.builtin && !manifestApi.builtin.has(toolModule.id)) manifestApi.builtin.register(toolModule);
+  return toolModule;
+});

zerochat_runtime/assets/js/tools/builtin/render-chart.tool.js

@@ -0,0 +1,90 @@
+/** Tool autocontenida: render_chart. */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatBuiltinRenderChartTool = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  const definition = {
+    name: 'render_chart',
+    description: 'Generates and displays an interactive chart (bar, line, donut, or pie) from numerical data or tables.',
+    parameters: {
+      type: 'object',
+      properties: {
+        type: { type: 'string', enum: ['bar', 'line', 'pie', 'doughnut'], description: 'Chart type.' },
+        title: { type: 'string', description: 'Descriptive chart title.' },
+        description: { type: 'string', description: 'Brief explanation of the data.' },
+        labels: { type: 'array', items: { type: 'string' }, description: 'X-axis labels or categories.' },
+        datasets: { type: 'array', items: { type: 'object', properties: { label: { type: 'string' }, data: { type: 'array', items: { type: 'number' } }, color: { type: 'string' } }, required: ['label', 'data'] }, description: 'Numerical data series.' }
+      },
+      required: ['type', 'title', 'labels', 'datasets']
+    }
+  };
+
+  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 safeEscapeHtml = (value) => String(value || '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  function renderChart(args, ui) {
+    const Charts = ui?.charts || null;
+    if (Charts?.renderChartCard) return Charts.renderChartCard(args);
+    const escapeHtml = ui?.markdown?.escapeHtml || (typeof window !== 'undefined' && window.ChatMarkdown?.escapeHtml) || (typeof window !== 'undefined' && window.ChatUtils?.escapeHtml) || safeEscapeHtml;
+    const chartIconSvg = '<svg class="ui-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="20" x2="12" y2="10"></line><line x1="18" y1="20" x2="18" y2="4"></line><line x1="6" y1="20" x2="6" y2="16"></line></svg>';
+    return `<div class="chat-chart-card">${chartIconSvg} ${escapeHtml(args.title || 'Gráfico')}</div>`;
+  }
+
+  function createLiveCard(args, ui) {
+    const cardDiv = createCardWrapper(ui);
+    if (cardDiv) cardDiv.innerHTML = renderChart(args, ui);
+    return cardDiv;
+  }
+
+  function updateLiveCard(cardDiv, args, _result, _elapsedMs, ui) {
+    if (cardDiv) cardDiv.innerHTML = renderChart(args, ui);
+  }
+
+  function renderHistoricalCard(args, _toolMessage, ui) {
+    const cardDiv = createCardWrapper(ui);
+    if (cardDiv) cardDiv.innerHTML = renderChart(args, ui);
+    return cardDiv;
+  }
+
+  function createTool(Tool) {
+    if (typeof Tool !== 'function') throw new Error('La clase Tool es necesaria para crear render_chart.');
+    return new Tool({
+      id: definition.name,
+      definition,
+      aliases: ['renderchart', 'draw_chart', 'create_chart', 'plot_chart', 'generate_chart', 'show_chart', 'chart', 'grafico'],
+      category: 'charts',
+      metadata: { icon: 'bar-chart', label: definition.name },
+      settings: { titleKey: 'agent_chart_title', titleFallback: 'Visualización de Datos y Gráficos Nativos (SVG)', descKey: 'agent_chart_desc', descFallback: 'Permite al modelo invocar render_chart para generar y mostrar gráficos interactivos de barras, líneas o sectores sin librerías externas.', icon: 'bar-chart', defaultEnabled: true, showInSettings: true },
+      promptGuide: () => '- `render_chart(type="...", title="...", labels=[...], datasets=[...])`: Generates and displays native interactive SVG charts (bar, line, pie, doughnut).',
+      execute: async (args, context = {}) => {
+        const Charts = context.services?.charts;
+        if (!Charts || (!Charts.renderChartCard && !Charts.renderBarChart)) return { success: false, error: 'Módulo Charts no disponible.' };
+        const svgHtml = Charts.renderChartCard ? Charts.renderChartCard(args) : Charts.renderBarChart(args.labels, args.datasets);
+        return { success: true, svg: svgHtml, chartData: args, title: args.title || 'Gráfico' };
+      },
+      result: {
+        toModel: (args, _result, outcome) => JSON.stringify({ success: outcome?.ok !== false, type: args.type || 'bar', title: args.title || 'Gráfico' }),
+        toMarkdown: (args) => `> **render_chart** (${args.type || 'bar'})\n> Título: "${args.title || 'Gráfico'}"\n\n`
+      },
+      displayMode: 'expanded',
+      view: { id: definition.name, displayMode: 'expanded', createLiveCard, updateLiveCard, renderHistoricalCard }
+    });
+  }
+
+  const toolModule = { id: definition.name, definition, displayMode: 'expanded', createTool, view: { id: definition.name, displayMode: 'expanded', 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/builtin/search-knowledge-base.tool.js

@@ -0,0 +1,124 @@
+/** Tool autocontenida: search_knowledge_base. */
+(function (root, factory) {
+  if (typeof exports === 'object' && typeof module !== 'undefined') module.exports = factory();
+  else root.ChatBuiltinSearchKnowledgeBaseTool = factory();
+})(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  const definition = {
+    name: 'search_knowledge_base',
+    description: 'Searches relevant knowledge-base chunks. Use scope="document" with documentHint for one exact source, scope="corpus" for comparisons or multiple sources, and scope="auto" only when the target scope is unclear. For multi-document retrieval, make one corpus search instead of repeating the same query per document.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Term, topic, metric, or keywords to search in the document or knowledge base (direct terms, no quotes).' },
+        scope: {
+          type: 'string',
+          enum: ['auto', 'document', 'corpus'],
+          description: 'Search scope: "document" for a specific identifiable source, "corpus" for multiple sources, "auto" when unclear. Defaults to "auto".'
+        },
+        documentHint: {
+          type: 'string',
+          description: 'Exact name, filename, or filter for the source mentioned by the user (e.g. "AMD_2015_10K.pdf", "WALMART_2015_10K.pdf").'
+        },
+        limit: { type: 'integer', description: 'Optional number of chunks to return (default 10).' },
+        maxPerDocument: { type: 'integer', description: 'Optional maximum number of chunks per document in corpus search (defaults dynamically to 2-4 depending on document candidates).' }
+      },
+      required: ['query']
+    }
+  };
+
+  function getBranchIds(context = {}) {
+    return context.activeRagBranchIds || context.activeRagBranchId || context.branchId || context.config?.activeRagBranchIds || context.config?.activeRagBranchId || '';
+  }
+  const getBranchId = getBranchIds;
+
+  function getRagService(context = {}) {
+    if (context.services?.ragService) return context.services.ragService;
+    if (typeof window !== 'undefined' && window.ChatRagService) return window.ChatRagService;
+    if (typeof require !== 'undefined') {
+      try { return require('../../rag-service.js'); } catch (e) {}
+    }
+    return null;
+  }
+
+  const DB_ICON_SVG = '<svg class="ui-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><ellipse cx="12" cy="5" rx="9" ry="3"></ellipse><path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path><path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path></svg>';
+
+  function createCardWrapper(ui) {
+    if (ui?.createCardWrapper) return ui.createCardWrapper();
+    const doc = ui?.document || (typeof document !== 'undefined' ? document : null);
+    if (!doc) return null;
+    const card = doc.createElement('div');
+    card.className = 'tool-card-wrapper';
+    return card;
+  }
+
+  const safeEscapeHtml = (value) => String(value || '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  function createLiveCard(args, ui) {
+    const card = createCardWrapper(ui);
+    if (!card) return null;
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || (typeof window !== 'undefined' && window.ChatUtils) || { escapeHtml: safeEscapeHtml };
+    const t = ui?.t || ((key, params) => key);
+    const spinner = ui?.SPINNER_SVG || '';
+    const chevron = ui?.CHEVRON_SVG || '';
+    const query = args?.query || args?.q || args?.search || '';
+    const title = t('tool_rag_search_title', { query: Markdown.escapeHtml(query) }) || `Conocimiento local: "${Markdown.escapeHtml(query)}"`;
+    const loading = t('tool_rag_search_loading') || 'Buscando con Orama...';
+    const building = t('tool_rag_search_building') || 'Construyendo el índice local...';
+    card.innerHTML = `<div class="tool-execution-card rag-execution-card"><div class="tool-card-header"><div class="tool-card-title"><span>${DB_ICON_SVG}</span><span>${title}</span></div><div class="tool-card-header-actions"><span class="tool-card-badge status-loading">${spinner} <span>${loading}</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="tool-card-result"><div class="tool-loading-placeholder">${spinner} <span>${building}</span></div></div></div></div>`;
+    return card;
+  }
+
+  function updateLiveCard(card, _args, result = {}, elapsedMs = 0, ui) {
+    if (!card) return;
+    const t = ui?.t || ((key, params) => key);
+    const Markdown = ui?.markdown || (typeof window !== 'undefined' && window.ChatMarkdown) || (typeof window !== 'undefined' && window.ChatUtils) || { escapeHtml: safeEscapeHtml };
+    const checkSvg = ui?.CHECK_SVG || '';
+    const errorSvg = ui?.ERROR_SVG || '';
+    const success = result?.success !== false && !result?.error;
+    const count = result?.matchesCount ?? 0;
+    const text = result?.text || (typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result || ''));
+    const badge = card.querySelector('.tool-card-badge');
+    const matchesLabel = t('tool_rag_search_matches', { count, plural: count === 1 ? '' : 's', scope: result?.appliedScope || 'auto' }) || `${count} coincidencia${count === 1 ? '' : 's'} · ${result?.appliedScope || 'auto'}`;
+    const errorLabel = result?.error || t('tool_err_query') || 'Error al consultar';
+    if (badge) {
+      badge.className = `tool-card-badge ${success ? 'status-success' : 'status-error'}`;
+      badge.innerHTML = success ? `${checkSvg} <span>${matchesLabel} (${elapsedMs || 0}ms)</span>` : `${errorSvg} <span>${Markdown.escapeHtml(errorLabel)}</span>`;
+    }
+    const body = card.querySelector('.tool-card-result');
+    if (body) body.innerHTML = `<pre class="tool-result-pre"><code>${Markdown.escapeHtml(text.slice(0, 3000))}${text.length > 3000 ? '\n... (texto completo truncado en tarjeta)' : ''}</code></pre>`;
+  }
+  function renderHistoricalCard(args, message, ui) { const card = createLiveCard(args, ui); if (!card) return null; let result = {}; if (message?.content) { try { result = JSON.parse(message.content); } catch (e) { result = { text: message.content }; } } updateLiveCard(card, args, result, 0, ui); return card; }
+
+  function createTool(Tool) {
+    if (typeof Tool !== 'function') throw new Error('La clase Tool es necesaria para crear search_knowledge_base.');
+    return new Tool({
+      id: definition.name,
+      definition,
+      aliases: ['search_kb', 'searchknowledgebase', 'search_documents', 'search_knowledge', 'buscar_en_documentos'],
+      category: 'rag',
+      metadata: { icon: 'search', label: definition.name },
+      settings: { showInSettings: false },
+      isAvailable: (config = {}) => Boolean(config.activeRagBranchId || (config.activeRagBranchIds && config.activeRagBranchIds.length > 0)),
+      execute: async (args, context = {}) => {
+        const RagService = getRagService(context);
+        if (!RagService?.searchKnowledgeBase) return { success: false, error: 'Servicio de RAG no disponible.' };
+        return RagService.searchKnowledgeBase(getBranchIds(context), args);
+      },
+      result: {
+        toModel: (_args, result) => result?.text || JSON.stringify(result || {}),
+        toMarkdown: (args, result) => `> **search_knowledge_base** ("${args.query || ''}") [${result?.matchesCount || 0} coincidencias]\n\n`
+      },
+      displayMode: 'collapsed',
+      view: { id: definition.name, displayMode: 'collapsed', createLiveCard, updateLiveCard, renderHistoricalCard }
+    });
+  }
+
+  const toolModule = { id: definition.name, definition, displayMode: 'collapsed', createTool, getBranchId, getRagService, 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;
+});