zyn-ai 1.3.4 → 1.3.5

package/src/providers/gemini/index.js

@@ -0,0 +1,338 @@
+const { Buffer } = require('buffer');
+const { REQUEST_TIMEOUT_MS } = require('../../config');
+const { parseAgentResponse } = require('../../core/prompts');
+
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36';
+const GEMINI_BASE = 'https://gemini.google.com';
+const ANON_COOKIE_URL = `${GEMINI_BASE}/_/BardChatUi/data/batchexecute?rpcids=maGuAc&source-path=%2F&hl=en-US&rt=c`;
+const STREAM_URL = `${GEMINI_BASE}/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate?hl=en-US&rt=c`;
+
+function btoa2(str) {
+  return Buffer.from(str, 'utf8').toString('base64');
+}
+
+function atob2(b64) {
+  return Buffer.from(b64, 'base64').toString('utf8');
+}
+
+function sleep(ms, signal) {
+  if (!ms || ms <= 0) return Promise.resolve();
+  if (signal?.aborted) return Promise.reject(new Error('aborted'));
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      cleanup();
+      reject(new Error('aborted'));
+    };
+    function cleanup() {
+      if (signal) signal.removeEventListener('abort', onAbort);
+    }
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+function createTimeoutSignal(signal, timeoutMs = REQUEST_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const onExternalAbort = () => controller.abort();
+
+  if (signal) {
+    if (signal.aborted) controller.abort();
+    else signal.addEventListener('abort', onExternalAbort, { once: true });
+  }
+
+  return {
+    signal: controller.signal,
+    cleanup() {
+      clearTimeout(timeout);
+      if (signal) signal.removeEventListener('abort', onExternalAbort);
+    },
+  };
+}
+
+async function fetchWithTimeout(url, options = {}) {
+  const timeoutSignal = createTimeoutSignal(options.signal, options.timeoutMs || REQUEST_TIMEOUT_MS);
+  try {
+    return await fetch(url, {
+      ...options,
+      signal: timeoutSignal.signal,
+    });
+  } finally {
+    timeoutSignal.cleanup();
+  }
+}
+
+function walkDeep(node, visit, depth = 0, maxDepth = 7) {
+  if (depth > maxDepth) return;
+  if (visit(node, depth) === false) return;
+  if (Array.isArray(node)) {
+    for (const x of node) walkDeep(x, visit, depth + 1, maxDepth);
+  } else if (node && typeof node === 'object') {
+    for (const k of Object.keys(node)) walkDeep(node[k], visit, depth + 1, maxDepth);
+  }
+}
+
+async function getAnonCookie(signal) {
+  const res = await fetchWithTimeout(ANON_COOKIE_URL, {
+    method: 'POST',
+    redirect: 'manual',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
+      'user-agent': UA,
+    },
+    body: 'f.req=%5B%5B%5B%22maGuAc%22%2C%22%5B0%5D%22%2Cnull%2C%22generic%22%5D%5D%5D&',
+    signal,
+  });
+
+  const setCookie = res.headers.get('set-cookie');
+  if (!setCookie) throw new Error('Gemini no devolvió cookies');
+  return setCookie.split(';')[0];
+}
+
+async function getXsrfToken(cookieHeader, signal) {
+  try {
+    const res = await fetchWithTimeout(`${GEMINI_BASE}/app`, {
+      method: 'GET',
+      headers: {
+        'user-agent': UA,
+        cookie: cookieHeader,
+        accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      },
+      signal,
+    });
+    const html = await res.text();
+    const m1 = html.match(/"SNlM0e":"([^"]+)"/);
+    if (m1?.[1]) return m1[1];
+    const m2 = html.match(/"at":"([^"]+)"/);
+    if (m2?.[1]) return m2[1];
+  } catch {}
+  return null;
+}
+
+
+function extractLooseFinalContent(text) {
+  const raw = String(text || '').trim();
+  if (!/(?:["'])type(?:["'])\s*:\s*(?:["'])final(?:["'])/i.test(raw)) return null;
+
+  const contentMatch = raw.match(/(?:["'])content(?:["'])\s*:\s*(["'])/i);
+  if (!contentMatch) return null;
+
+  const quote = contentMatch[1];
+  const start = contentMatch.index + contentMatch[0].length;
+  let escaped = false;
+
+  for (let i = start; i < raw.length; i += 1) {
+    const ch = raw[i];
+    if (escaped) { escaped = false; continue; }
+    if (ch === '\\') { escaped = true; continue; }
+    if (ch !== quote) continue;
+
+    const tail = raw.slice(i + 1).trim();
+    if (!tail || /^}\s*$/.test(tail) || /^,\s*["']\w+["']\s*:/.test(tail)) {
+      return raw.slice(start, i);
+    }
+  }
+
+  return raw.slice(start).replace(/"?\s*}\s*$/, '');
+}
+
+function unescapeLooseJsonString(text) {
+  return String(text || '')
+    .replace(/\\n/g, '\n')
+    .replace(/\\t/g, '\t')
+    .replace(/\\r/g, '\r')
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, '\\')
+    .trim();
+}
+
+function cleanGeminiResponseText(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return '';
+
+  const unfenced = raw.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+  const parsed = parseAgentResponse(unfenced);
+  if (parsed?.type === 'final' && typeof parsed.content === 'string' && parsed.content.trim()) {
+    return parsed.content.trim();
+  }
+  if (parsed?.type === 'tool') return unfenced;
+
+  const looseFinal = extractLooseFinalContent(unfenced);
+  if (looseFinal !== null) return unescapeLooseJsonString(looseFinal);
+
+  return unfenced;
+}
+
+function isLikelyText(value) {
+  if (typeof value !== 'string') return false;
+  const text = value.trim();
+  if (!text) return false;
+  if (text.length < 2) return false;
+  if (/^https?:\/\//i.test(text)) return false;
+  if (/^\/\/www\./i.test(text)) return false;
+  if (/maps\/vt\/data/i.test(text)) return false;
+  if (/^c_[0-9a-f]{6,}$/i.test(text)) return false;
+  if (/^[A-Za-z0-9_\-+/=]{16,}$/.test(text) && !/\s/.test(text)) return false;
+  if (/^\{.*\}$/.test(text) || /^\[.*\]$/.test(text)) return false;
+  return text.length >= 8 || /\s/.test(text);
+}
+
+function pickBestTextFromAny(parsed) {
+  const found = [];
+  walkDeep(parsed, (node) => {
+    if (typeof node !== 'string' || !isLikelyText(node)) return;
+    const cleaned = cleanGeminiResponseText(node);
+    if (cleaned) found.push(cleaned);
+  });
+  found.sort((a, b) => b.length - a.length);
+  return found[0] || '';
+}
+
+function pickFirstString(parsed, accept) {
+  let first = '';
+  walkDeep(parsed, (node) => {
+    if (first) return false;
+    if (typeof node !== 'string') return undefined;
+    const text = node.trim();
+    if (text && (!accept || accept(text))) first = text;
+    if (first) return false;
+    return undefined;
+  });
+  return first;
+}
+
+function findInnerPayloadString(outer) {
+  const candidates = [];
+  const add = (value) => {
+    if (typeof value !== 'string') return;
+    const text = value.trim();
+    if (!text) return;
+    candidates.push(text);
+  };
+
+  add(outer?.[0]?.[2]);
+  add(outer?.[2]);
+  add(outer?.[0]?.[0]?.[2]);
+  walkDeep(outer, (node) => {
+    if (typeof node === 'string') {
+      const text = node.trim();
+      if ((text.startsWith('[') || text.startsWith('{')) && text.length > 20) add(text);
+    }
+  }, 0, 5);
+
+  for (const candidate of candidates) {
+    try {
+      JSON.parse(candidate);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+
+function parseStream(data) {
+  if (typeof data !== 'string' || !data.trim()) throw new Error('Respuesta vacía');
+
+  const chunks = Array.from(
+    data.matchAll(/^\d+\r?\n([\s\S]+?)\r?\n(?=\d+\r?\n|$)/gm),
+  ).map(match => match[1]).reverse();
+
+  if (!chunks.length) throw new Error('Respuesta inválida');
+
+  let best = { text: '', resumeArray: null, parsed: null };
+  for (const chunk of chunks) {
+    try {
+      const outer = JSON.parse(chunk);
+      const inner = findInnerPayloadString(outer);
+      if (!inner) continue;
+      const parsed = JSON.parse(inner);
+      const text = pickBestTextFromAny(parsed);
+      const resumeArray = Array.isArray(parsed?.[1]) ? parsed[1] : null;
+      if (!best.parsed || (text && text.length > (best.text?.length || 0))) {
+        best = { text, resumeArray, parsed };
+      }
+    } catch {}
+  }
+
+  if (!best.parsed) throw new Error('Error de parseo');
+
+  let cleanText = cleanGeminiResponseText(best.text).replace(/\*\*(.+?)\*\*/g, '*$1*').trim();
+  if (!cleanText) {
+    const accept = text => !/^https?:\/\/|^\/\/www\.|maps\/vt\/data/i.test(text);
+    cleanText = cleanGeminiResponseText(pickFirstString(best.parsed, accept) || pickFirstString(best.parsed)).replace(/\*\*(.+?)\*\*/g, '*$1*').trim();
+  }
+
+  return { text: cleanText, resumeArray: best.resumeArray };
+}
+
+async function geminiScraper(prompt, previousId = null, options = {}) {
+  let resumeArray = null;
+  if (previousId) {
+    try {
+      const json = JSON.parse(atob2(previousId));
+      resumeArray = json?.resumeArray || null;
+    } catch {}
+  }
+
+  let lastErr = null;
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    try {
+      if (options.signal?.aborted) throw new Error('aborted');
+      const cookie = await getAnonCookie(options.signal);
+      const xsrf = await getXsrfToken(cookie, options.signal);
+      const payload = [[prompt.trim()], ['en-US'], resumeArray];
+      const fReq = [null, JSON.stringify(payload)];
+      const params = new URLSearchParams({ 'f.req': JSON.stringify(fReq) });
+      if (xsrf) params.append('at', xsrf);
+
+      const response = await fetchWithTimeout(STREAM_URL, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
+          'user-agent': UA,
+          'x-same-domain': '1',
+          cookie,
+        },
+        body: params,
+        signal: options.signal,
+      });
+
+      const data = await response.text();
+      if (!response.ok) throw new Error(`Gemini fallo (${response.status}): ${data.slice(0, 200)}`);
+      const parsed = parseStream(data);
+      const id = btoa2(JSON.stringify({ resumeArray: parsed.resumeArray }));
+      return { status: true, response: cleanGeminiResponseText(parsed.text), id };
+    } catch (err) {
+      lastErr = err;
+      if (options.signal?.aborted) break;
+      if (attempt < 3) await sleep(700, options.signal);
+    }
+  }
+
+  return { status: false, message: lastErr?.message || 'Gemini fallo' };
+}
+
+async function gemini(messages, _modelId, onChunk = null, options = {}) {
+  const prompt = Array.isArray(messages)
+    ? messages.map(message => {
+        if (message.role === 'system') return `[Sistema]\n${message.content}`;
+        if (message.role === 'assistant') return `[Asistente]\n${message.content}`;
+        return `[Usuario]\n${message.content}`;
+      }).join('\n\n')
+    : String(messages || '');
+
+  const result = await geminiScraper(prompt, options.previousId || null, options);
+  if (!result.status) throw new Error(result.message || 'Gemini fallo');
+  if (onChunk && result.response) onChunk(result.response, 'answer');
+  return { text: result.response || '', thinking: '', id: result.id };
+}
+
+module.exports = {
+  gemini,
+  geminiScraper,
+  cleanGeminiResponseText,
+  parseStream,
+};

package/src/providers/scraperClient.js

@@ -1,7 +1,6 @@
 const { qwen } = require('./qwen/index');
 const { zen } = require('./zen/index');
-const { ollama } = require('./ollama/index');
-const { openaiCompatible } = require('./openaiCompatible/index');
+const { gemini } = require('./gemini/index');
 const { DEFAULT_MODEL_KEY, MODELS } = require('../config');
 
 function buildPromptFromMessages(messages) {
@@ -29,10 +28,8 @@ async function runProvider(provider, messages, model, onChunk, options = {}) {
   switch (provider) {
     case 'zen':
       return zen(messages, model.zenModel, onChunk, options);
-    case 'ollama':
-      return ollama(messages, model.ollamaModel || model.model || model.label, onChunk, options);
-    case 'openai-compatible':
-      return openaiCompatible(messages, model.openaiModel || model.model || model.label, onChunk, options);
+    case 'gemini':
+      return gemini(messages, model.geminiModel || 'gemini-flash', onChunk, options);
     case 'qwen':
     default: {
       const prompt = buildPromptFromMessages(messages);

package/src/tools/index.js

@@ -18,6 +18,7 @@ const {
   upsertGitSecret,
 } = require('../utils/secretStorage');
 const { resolveInputPath } = require('../utils/pathUtils');
+const { getGmailAuthStatus, gmailApiRequest } = require('../utils/gmailAuth');
 const {
   formatLineRange,
   shortText,
@@ -42,6 +43,8 @@ const TOOL_DEFINITIONS = [
   { name: 'scrape_site', usage: '{ url, selectors, limit?, headers? }' },
   { name: 'web_search', usage: '{ query, lang?, limit? }' },
   { name: 'web_read', usage: '{ url }' },
+  { name: 'upload_file', usage: '{ path, field?, name?, type? }' },
+  { name: 'gmail', usage: '{ action, query?, maxResults?, id?, to?, subject?, body? }' },
   { name: 'create_canvas_image', usage: '{ width, height, background?, elements?, format?, outputPath? }' },
   { name: 'git', usage: '{ provider, action, method?, path?, body?, headers?, name?, repoUrl?, destination?, branch?, timeoutMs? }' },
 ];
@@ -134,6 +137,19 @@ function getToolPromptText() {
     '  Ideal para leer articulos, documentacion o contenido de paginas.',
     '  Ejemplo: {"type":"tool","tool":"web_read","args":{"url":"https://docs.example.com/guide"}}',
     '',
+    'upload_file { path, field?, name?, type? }',
+    '  Sube un archivo local a https://cdn.soymaycol.icu/upload por POST multipart/form-data y devuelve el link directo.',
+    '  Limite estricto: maximo 5 MB. field por defecto: "file". name/type son opcionales.',
+    '  Usa esta tool cuando necesites entregar un archivo como enlace directo al agente o al usuario.',
+    '  Ejemplo: {"type":"tool","tool":"upload_file","args":{"path":"dist/116.zip"}}',
+    '',
+    'gmail { action, query?, maxResults?, id?, to?, subject?, body? }',
+    '  Usa Gmail conectado con /gmail connect. Acciones: status, list, read, send.',
+    '  list: query usa la sintaxis de busqueda de Gmail; maxResults default 10, max 20.',
+    '  read: requiere id de mensaje. send: requiere to, subject y body; pide confirmacion antes de enviar.',
+    '  Ejemplo listar: {"type":"tool","tool":"gmail","args":{"action":"list","query":"is:unread newer_than:7d","maxResults":5}}',
+    '  Ejemplo leer: {"type":"tool","tool":"gmail","args":{"action":"read","id":"MESSAGE_ID"}}',
+    '',
     '## Imagen profesional con Jimp',
     '',
     'create_canvas_image { width, height, background?, elements?, format?, outputPath? }',
@@ -256,6 +272,10 @@ function describeToolCall(call) {
       const readUrl = cleanUrl(call.args.url || '');
       return `Leyendo ${shortText(readUrl, 60)}`;
     }
+    case 'upload_file':
+      return `Subiendo ${call.args.path}`;
+    case 'gmail':
+      return `Gmail ${call.args.action || 'status'}`;
     case 'create_canvas_image':
       return `Creando imagen ${call.args.width || '?'}x${call.args.height || '?'}`;
     case 'git':
@@ -903,6 +923,210 @@ async function fetchHttpTool(args, state, paint) {
   return truncateText(`Status: ${res.status}\nContent-Type: ${res.headers.get('content-type') || '-'}\n\n${text}`);
 }
 
+
+function guessContentType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const types = {
+    '.zip': 'application/zip',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.json': 'application/json',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.csv': 'text/csv',
+  };
+  return types[ext] || 'application/octet-stream';
+}
+
+async function uploadFileTool(args, state, paint) {
+  if (!args.path || typeof args.path !== 'string') throw new Error('upload_file requiere path');
+  const filePath = resolveInputPath(args.path, state.cwd);
+  const stats = await fsp.stat(filePath).catch(() => null);
+  if (!stats?.isFile()) throw new Error(`Archivo no encontrado: ${filePath}`);
+
+  const maxBytes = 5 * 1024 * 1024;
+  if (stats.size > maxBytes) {
+    throw new Error(`El archivo supera el limite de 5 MB (${stats.size} bytes)`);
+  }
+
+  const endpoint = 'https://cdn.soymaycol.icu/upload';
+  const displayName = args.name || path.basename(filePath);
+  const allowed = await askConfirmation(state.rl, 'Subir archivo a CDN', `${displayName} (${stats.size} bytes) -> ${endpoint}`, paint, state);
+  if (!allowed) return 'Subida cancelada.';
+
+  const buffer = await fsp.readFile(filePath);
+  const type = args.type || guessContentType(filePath);
+  const form = new FormData();
+  form.append(String(args.field || 'file'), new Blob([buffer], { type }), displayName);
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 60000);
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: 'POST',
+      body: form,
+      signal: controller.signal,
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  const text = await res.text();
+  let payload = null;
+  try { payload = JSON.parse(text); } catch {}
+  if (!res.ok) {
+    throw new Error(`Upload fallo (${res.status}): ${shortText(text, 500)}`);
+  }
+  if (!payload || typeof payload.link !== 'string' || !payload.link.trim()) {
+    throw new Error(`Respuesta de upload invalida: ${shortText(text, 500)}`);
+  }
+
+  return [
+    'Archivo subido correctamente.',
+    `Nombre: ${payload.name || displayName}`,
+    `Tamano: ${payload.size ?? stats.size}`,
+    `Tipo: ${payload.type || type}`,
+    `Link directo: ${payload.link}`,
+    '',
+    JSON.stringify(payload, null, 2),
+  ].join('\n');
+}
+
+
+function decodeBase64UrlText(value = '') {
+  if (!value) return '';
+  const normalized = String(value).replace(/-/g, '+').replace(/_/g, '/');
+  const padded = normalized + '='.repeat((4 - (normalized.length % 4)) % 4);
+  return Buffer.from(padded, 'base64').toString('utf8');
+}
+
+function encodeBase64UrlText(value = '') {
+  return Buffer.from(String(value), 'utf8')
+    .toString('base64')
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/g, '');
+}
+
+function getHeader(headers = [], name) {
+  const found = headers.find(header => String(header.name || '').toLowerCase() === String(name).toLowerCase());
+  return found?.value || '';
+}
+
+function collectMessageText(payload, out = []) {
+  if (!payload) return out;
+  if (payload.mimeType === 'text/plain' && payload.body?.data) {
+    out.push(decodeBase64UrlText(payload.body.data));
+  }
+  for (const part of payload.parts || []) collectMessageText(part, out);
+  if (out.length === 0 && payload.body?.data) out.push(decodeBase64UrlText(payload.body.data));
+  return out;
+}
+
+function formatMessageSummary(message) {
+  const headers = message.payload?.headers || [];
+  return [
+    `ID: ${message.id}`,
+    `From: ${getHeader(headers, 'From') || '-'}`,
+    `To: ${getHeader(headers, 'To') || '-'}`,
+    `Subject: ${getHeader(headers, 'Subject') || '-'}`,
+    `Date: ${getHeader(headers, 'Date') || '-'}`,
+    `Snippet: ${message.snippet || '-'}`,
+  ].join('\n');
+}
+
+function encodeSubject(subject) {
+  const text = String(subject || '');
+  return /^[\x00-\x7F]*$/.test(text)
+    ? text
+    : `=?UTF-8?B?${Buffer.from(text, 'utf8').toString('base64')}?=`;
+}
+
+function buildRawEmail({ to, subject, body }) {
+  return encodeBase64UrlText([
+    `To: ${String(to || '').trim()}`,
+    `Subject: ${encodeSubject(subject)}`,
+    'MIME-Version: 1.0',
+    'Content-Type: text/plain; charset="UTF-8"',
+    'Content-Transfer-Encoding: 8bit',
+    '',
+    String(body || ''),
+  ].join('\r\n'));
+}
+
+async function gmailTool(args = {}, state, paint) {
+  const action = String(args.action || 'status').toLowerCase().trim();
+
+  if (action === 'status') {
+    const status = await getGmailAuthStatus();
+    if (!status.connected) return 'Gmail no conectado. Usa /gmail connect para iniciar sesion.';
+    return [
+      'Gmail conectado.',
+      `Cuenta: ${status.email || 'desconocida'}`,
+      `Scopes: ${status.scopes.join(', ') || '-'}`,
+      `Expira: ${status.expiryDate ? new Date(status.expiryDate).toISOString() : '-'}`,
+    ].join('\n');
+  }
+
+  if (action === 'list') {
+    const maxResults = Math.max(1, Math.min(20, Number(args.maxResults || 10)));
+    const data = await gmailApiRequest('GET', '/users/me/messages', {
+      query: {
+        q: args.query || '',
+        maxResults,
+      },
+    });
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    if (messages.length === 0) return 'No se encontraron correos.';
+    const details = [];
+    for (const message of messages) {
+      const full = await gmailApiRequest('GET', `/users/me/messages/${encodeURIComponent(message.id)}`, {
+        query: { format: 'metadata' },
+      });
+      details.push(formatMessageSummary(full));
+    }
+    return [`Correos encontrados: ${details.length}`, '', details.join('\n\n---\n\n')].join('\n');
+  }
+
+  if (action === 'read') {
+    if (!args.id || typeof args.id !== 'string') throw new Error('gmail read requiere id');
+    const message = await gmailApiRequest('GET', `/users/me/messages/${encodeURIComponent(args.id)}`, {
+      query: { format: 'full' },
+    });
+    const text = collectMessageText(message.payload).join('\n').trim();
+    return [
+      formatMessageSummary(message),
+      '',
+      'Contenido:',
+      truncateText(text || message.snippet || '(sin texto legible)', 8000),
+    ].join('\n');
+  }
+
+  if (action === 'send') {
+    if (!args.to || !args.subject || !args.body) throw new Error('gmail send requiere to, subject y body');
+    const allowed = await askConfirmation(
+      state.rl,
+      'Enviar correo por Gmail',
+      `Para: ${args.to}\nAsunto: ${args.subject}\n${shortText(String(args.body), 300)}`,
+      paint,
+      state,
+    );
+    if (!allowed) return 'Envio de Gmail cancelado.';
+    const data = await gmailApiRequest('POST', '/users/me/messages/send', {
+      body: { raw: buildRawEmail(args) },
+    });
+    return [`Correo enviado.`, `ID: ${data.id || '-'}`, `Thread: ${data.threadId || '-'}`].join('\n');
+  }
+
+  throw new Error('gmail action invalida. Usa status, list, read o send.');
+}
+
 async function scrapeSiteTool(args, state, paint) {
   if (!args.url || typeof args.url !== 'string') throw new Error('scrape_site requiere url');
   if (!args.selectors || typeof args.selectors !== 'object') throw new Error('scrape_site requiere selectors objeto');
@@ -1155,6 +1379,12 @@ async function executeToolCall(call, state, ui) {
     case 'web_read':
       result = await webReadTool(call.args, state, ui.paint);
       break;
+    case 'upload_file':
+      result = await uploadFileTool(call.args, state, ui.paint);
+      break;
+    case 'gmail':
+      result = await gmailTool(call.args, state, ui.paint);
+      break;
     case 'create_canvas_image':
       result = await createCanvasImageTool(call.args, state, ui.paint);
       break;

package/src/tui/app.mjs

@@ -5,6 +5,7 @@ import { EventEmitter } from 'events';
 
 const require = createRequire(import.meta.url);
 const { runAgentTurn } = require('../core/agent');
+const { parseAgentResponse } = require('../core/prompts');
 const { handleLocalCommand, SLASH_COMMANDS } = require('../cli/commands');
 const {
   loadOrCreateSessionState,
@@ -229,6 +230,20 @@ function parseInline(text) {
   return parts;
 }
 
+
+function normalizeAssistantDisplayText(text) {
+  const raw = String(text || '');
+  const trimmed = raw.trim();
+  if (!trimmed) return raw;
+
+  const parsed = parseAgentResponse(trimmed);
+  if (parsed?.type === 'final' && typeof parsed.content === 'string' && parsed.content.trim()) {
+    return parsed.content.trim();
+  }
+
+  return raw;
+}
+
 function InlineLine({ text, color }) {
   const parts = parseInline(text);
   const base = color || T.text;
@@ -514,13 +529,14 @@ function ThinkingBlock({ text, elapsed, live, width }) {
 
 function AnswerBlock({ text, live, width }) {
   if (!text) return null;
+  const displayText = normalizeAssistantDisplayText(text);
   return h(Box, { flexDirection: 'column', paddingLeft: 3, paddingRight: 3, marginTop: 1 },
     h(Box, { gap: 1, marginBottom: 0 },
       h(Text, { color: T.accentSoft, bold: true }, '\u25c9'),
       h(Text, { color: T.textDim, bold: true }, APP_NAME),
     ),
     h(Box, { flexDirection: 'column', paddingLeft: 2 },
-      h(MarkdownContent, { text, width: Math.max(40, (width || 80) - 8) }),
+      h(MarkdownContent, { text: displayText, width: Math.max(40, (width || 80) - 8) }),
       live ? h(Text, { color: T.accent }, '\u258e') : null,
     ),
   );