@fullqueso/mcp-bc-gastos 1.28.0 → 1.33.0

package/scripts/generate-tools-doc.mjs

@@ -0,0 +1,129 @@
+// scripts/generate-tools-doc.mjs
+// Regenera la sección "## Tools (N)" del README.md leyendo las definiciones
+// REALES exportadas por tools/**/*.js (objetos *Tool con name/description/inputSchema).
+// Uso:  node scripts/generate-tools-doc.mjs            → imprime el markdown
+//       node scripts/generate-tools-doc.mjs --write    → reescribe README.md
+// Así el README nunca vuelve a quedar stale: se regenera desde el código.
+
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { dirname, join, relative } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const TOOLS_DIR = join(ROOT, 'tools');
+const README = join(ROOT, 'README.md');
+
+const CATEGORY_LABELS = {
+  '': 'Expense Analysis & Core',
+  'auditoria': 'Auditoría / POS Reconciliation',
+  'cierre-mensual': 'Cierre Mensual Bancario',
+  'cobranzas': 'Cobranzas (AR / AP)',
+  'financials': 'Financial Statements & Cash Flow',
+  'inventario': 'Inventario',
+  'multi-payment': 'Draft Visibility (Multi-Payments + facturas sin postear)',
+  'payroll': 'Nómina',
+  'reports': 'Reports',
+  'ventas': 'Ventas',
+};
+
+function jsFiles(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) out.push(...jsFiles(join(dir, entry.name)));
+    else if (entry.name.endsWith('.js') && !entry.name.startsWith('.')) {
+      // index.js incluido: algunos tools se DEFINEN ahí (ej. financials/index.js);
+      // los re-exports duplicados se filtran después con dedup por name.
+      out.push(join(dir, entry.name));
+    }
+  }
+  return out.sort();
+}
+
+function firstSentence(text, max = 240) {
+  const clean = String(text || '').replace(/\s+/g, ' ').trim();
+  const dot = clean.indexOf('. ');
+  const s = dot > 30 ? clean.slice(0, dot + 1) : clean;
+  return s.length > max ? s.slice(0, max - 1).trimEnd() + '…' : s;
+}
+
+function paramsLine(schema) {
+  const props = schema?.properties || {};
+  const required = new Set(schema?.required || []);
+  const parts = Object.keys(props).map((k) => (required.has(k) ? `\`${k}\`*` : `\`${k}\``));
+  return parts.length ? `- Params: ${parts.join(', ')}` : '- Params: (ninguno)';
+}
+
+async function collectTools() {
+  const byCategory = new Map();
+  for (const file of jsFiles(TOOLS_DIR)) {
+    const rel = relative(TOOLS_DIR, file);
+    const category = rel.includes('/') ? rel.split('/')[0] : '';
+    let mod;
+    try {
+      mod = await import(pathToFileURL(file).href);
+    } catch (e) {
+      console.error(`WARN: no se pudo importar ${rel}: ${e.message}`);
+      continue;
+    }
+    for (const [key, val] of Object.entries(mod)) {
+      if (!key.endsWith('Tool')) continue;
+      if (!val || typeof val !== 'object' || !val.name || !val.description) continue;
+      if (!byCategory.has(category)) byCategory.set(category, []);
+      byCategory.get(category).push(val);
+    }
+  }
+  // dedup por name (algunos módulos re-exportan)
+  for (const [cat, tools] of byCategory) {
+    const seen = new Set();
+    byCategory.set(cat, tools.filter((t) => (seen.has(t.name) ? false : seen.add(t.name))));
+  }
+  return byCategory;
+}
+
+function buildMarkdown(byCategory) {
+  const order = Object.keys(CATEGORY_LABELS).filter((k) => byCategory.has(k));
+  for (const k of byCategory.keys()) if (!order.includes(k)) order.push(k); // dirs nuevos
+  const total = [...byCategory.values()].reduce((n, t) => n + t.length, 0);
+
+  const lines = [`## Tools (${total})`, '',
+    '_Sección generada por `scripts/generate-tools-doc.mjs` — no editar a mano._',
+    '_Regenerar con: `node scripts/generate-tools-doc.mjs --write`_', ''];
+  for (const cat of order) {
+    const tools = byCategory.get(cat);
+    const label = CATEGORY_LABELS[cat] || cat;
+    lines.push(`### ${label} (${tools.length} tool${tools.length !== 1 ? 's' : ''})`, '');
+    for (const t of tools.sort((a, b) => a.name.localeCompare(b.name))) {
+      lines.push(`#### ${t.name}`);
+      lines.push(firstSentence(t.description));
+      lines.push(paramsLine(t.inputSchema), '');
+    }
+  }
+  lines.push('_Los params marcados con `*` son requeridos. Detalle completo en `docs/tool_*.md`._', '');
+  return lines.join('\n');
+}
+
+function spliceReadme(md) {
+  const readme = readFileSync(README, 'utf8');
+  const lines = readme.split('\n');
+  const start = lines.findIndex((l) => /^## Tools/.test(l));
+  if (start === -1) throw new Error('No se encontró la sección "## Tools" en README.md');
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^## /.test(lines[i])) { end = i; break; }
+  }
+  const next = [...lines.slice(0, start), ...md.split('\n'), ...lines.slice(end)];
+  writeFileSync(README, next.join('\n'));
+  return { start: start + 1, end, total_lines: next.length };
+}
+
+const byCategory = await collectTools();
+const md = buildMarkdown(byCategory);
+
+if (process.argv.includes('--write')) {
+  const info = spliceReadme(md);
+  const total = [...byCategory.values()].reduce((n, t) => n + t.length, 0);
+  console.log(`README.md actualizado: ${total} tools, sección en línea ${info.start} (antes terminaba en ${info.end}). Total ${info.total_lines} líneas.`);
+} else {
+  console.log(md);
+}

package/server.js

@@ -33,6 +33,7 @@ import { accountTransactionsTool, handleAccountTransactions } from './tools/acco
 import { vendorTransactionsTool, handleVendorTransactions } from './tools/vendor-transactions.js';
 import { listVendorsTool, handleListVendors } from './tools/list-vendors.js';
 import { exchangeRateTool, handleGetExchangeRate } from './tools/get-exchange-rate.js';
+import { crmRateTool, handleGetCrmRate } from './tools/get-crm-rate.js';
 
 // Auditoria tools (bank reconciliation)
 import { listBankAccountsTool, handleListBankAccounts } from './tools/auditoria/list-bank-accounts.js';
@@ -61,6 +62,7 @@ import {
   draftReceivablesTool, handleDraftReceivables,
   draftPayablesTool, handleDraftPayables,
   draftSummaryTool, handleDraftSummary,
+  unpostedInvoicesTool, handleUnpostedInvoices,
 } from './tools/multi-payment/index.js';
 
 // Payroll tools
@@ -103,10 +105,11 @@ import {
   reconcileWithBcTool, handleReconcileWithBc,
 } from './tools/cierre-mensual/index.js';
 
-// Financials (P&L / Financial Statements) + Cash Flow (FCF)
+// Financials (P&L / Financial Statements) + Cash Flow (FCF) + Income Statement (Power BI)
 import {
   financialStatementsTool, handleFinancialStatements,
   cashFlowTool, handleCashFlow,
+  incomeStatementTool, handleIncomeStatement,
 } from './tools/financials/index.js';
 
 const pkg = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf-8'));
@@ -138,6 +141,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       vendorTransactionsTool,
       listVendorsTool,
       exchangeRateTool,
+      crmRateTool,
       // Auditoria (bank reconciliation)
       listBankAccountsTool,
       reconciliationStatusTool,
@@ -162,6 +166,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       draftReceivablesTool,
       draftPayablesTool,
       draftSummaryTool,
+      unpostedInvoicesTool,
       // Payroll
       payrollDocumentsTool,
       payrollLinesTool,
@@ -189,9 +194,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       getClosingQuestionnaireTool,
       getClosingMatchResultsTool,
       reconcileWithBcTool,
-      // Financials (P&L / Financial Statements) + Cash Flow (FCF)
+      // Financials (P&L / Financial Statements) + Cash Flow (FCF) + Income Statement (Power BI)
       financialStatementsTool,
       cashFlowTool,
+      incomeStatementTool,
     ],
   };
 });
@@ -234,6 +240,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'get_exchange_rate':
         result = await handleGetExchangeRate(bcClient, args);
         break;
+      case 'get_crm_rate':
+        result = await handleGetCrmRate(bcClient, args);
+        break;
       // Auditoria (bank reconciliation)
       case 'list_bank_accounts':
         result = await handleListBankAccounts(bcClient, args);
@@ -300,6 +309,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'get_draft_summary':
         result = await handleDraftSummary(bcClient, args);
         break;
+      case 'get_unposted_invoices':
+        result = await handleUnpostedInvoices(bcClient, args);
+        break;
       // Payroll
       case 'get_payroll_documents':
         result = await handlePayrollDocuments(bcClient, args);
@@ -378,6 +390,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       case 'get_cash_flow':
         result = await handleCashFlow(bcClient, args);
         break;
+      case 'get_income_statement':
+        result = await handleIncomeStatement(bcClient, args);
+        break;
       default:
         return {
           content: [{ type: 'text', text: `Herramienta desconocida: ${name}` }],

package/tools/financials/income-statement.js

@@ -0,0 +1,265 @@
+// tools/financials/income-statement.js
+//
+// get_income_statement — Estado de resultados en el formato exacto del reporte Power BI
+// "Income Statement by Month" (G/L Account Level 1). Agrega los General Ledger entries por
+// bucket level-1 con la convención de signos de Power BI:
+//     amount = debitAmount − creditAmount
+//   → ingresos (crédito) salen NEGATIVOS, costos/gastos (débito) POSITIVOS,
+//     Total = Σ(debit − credit); Total NEGATIVO = ganancia.
+//
+// Resuelve la parte frágil que el skill hacía a mano: partir los gastos por las fronteras
+// level-1 (nómina 71000 vs impuestos 74000, otros 74000 vs 90000). Aquí se hace desde los
+// entries por cuenta, así que cuadra 1:1 con Power BI. La columna Ajustado (drafts como
+// posteados) y la reclasificación de dividendos las agrega el skill sobre este posted.
+//
+// Consumido por skill-fq-resultados-mensual (build_income_statement.py). READ-ONLY.
+
+import { resolveStores } from '../../config/company-config.js';
+import { getDateRange } from '../../utils/date-helper.js';
+import { round2 } from '../../utils/currency-converter.js';
+import { logger } from '../../utils/logger.js';
+import { periodLabel } from './statements.js';
+
+// ── Estructura level-1 de Power BI ────────────────────────────────────────────
+// Fuente: screenshots del reporte Power BI FQ28 (refresh 2026-05-04). CoA compartido
+// FQ01/FQ28/FQ88. MANTENER SINCRONIZADO con
+// skill-fq-resultados-mensual/references/income_statement_coa.json.
+export const COA_PBI = {
+  sections: [
+    {
+      id: 'ingresos', total_account: '40001', total_name: 'TOTAL INGRESOS', range: [40000, 49999],
+      level1: [
+        { account: '40100', name: 'Ingreso Ventas', from: 40000, to: 40299 },
+        { account: '40300', name: 'Ingreso Facturación Directa', from: 40300, to: 40399 },
+        { account: '40400', name: 'Ingreso por Servicios', from: 40400, to: 40499 },
+        { account: '40500', name: 'Otros Ingresos', from: 40500, to: 40599 },
+        { account: '40600', name: 'Ingresos por Alquiler', from: 40600, to: 40899 },
+        { account: '40900', name: 'Ingresos Extraordinarios', from: 40900, to: 49999 },
+      ],
+    },
+    {
+      id: 'costo_ventas', total_account: '50001', total_name: 'TOTAL COSTO DE VENTAS', range: [50000, 59999],
+      level1: [
+        { account: '50100', name: 'Costo de Productos', from: 50000, to: 50999 },
+        { account: '51000', name: 'Otros Costos de Producción', from: 51000, to: 51999 },
+        { account: '52000', name: 'Costos Desechables y Empaques', from: 52000, to: 55999 },
+        { account: '56000', name: 'Fletes', from: 56000, to: 56999 },
+        { account: '57000', name: 'Mantenimiento y reparación de equipos cocina', from: 57000, to: 59999 },
+      ],
+    },
+    {
+      id: 'gastos_operativos', total_account: '60001', total_name: 'TOTAL GASTOS OPERATIVOS', range: [60000, 99999],
+      level1: [
+        { account: '60002', name: 'Gastos Planta Física', from: 60000, to: 61999 },
+        { account: '62000', name: 'gastos de logistica', from: 62000, to: 62999 },
+        { account: '63000', name: 'Gastos Mercadeo, Publicidad y Ventas', from: 63000, to: 63999 },
+        { account: '64000', name: 'Gastos Administrativos Tienda', from: 64000, to: 66999 },
+        { account: '67000', name: 'Egresos Financieros', from: 67000, to: 67999 },
+        { account: '68000', name: 'Gastos Servicios Contratados', from: 68000, to: 70999 },
+        { account: '71000', name: 'sueldos y salarios', from: 71000, to: 73999 },
+        { account: '74000', name: 'Impuestos y permisologias', from: 74000, to: 89999 },
+        { account: '90000', name: 'Otros Egresos', from: 90000, to: 99999 },
+      ],
+    },
+  ],
+};
+
+function sectionIdFor(acctNum) {
+  if (acctNum >= 40000 && acctNum <= 49999) return 'ingresos';
+  if (acctNum >= 50000 && acctNum <= 59999) return 'costo_ventas';
+  if (acctNum >= 60000 && acctNum <= 99999) return 'gastos_operativos';
+  return null;
+}
+
+function bucketFor(section, acctNum) {
+  for (const b of section.level1) {
+    if (acctNum >= b.from && acctNum <= b.to) return b;
+  }
+  return section.level1[section.level1.length - 1]; // fallback defensivo
+}
+
+// ── Agregación pura (testeable sin BC) ────────────────────────────────────────
+// entries: [{ accountNumber, debitAmount, creditAmount, description? }]
+// opts: { level = 1, accountNames = {} }
+export function buildStatement(entries, { level = 1, accountNames = {} } = {}) {
+  const secDefById = Object.fromEntries(COA_PBI.sections.map((s) => [s.id, s]));
+  const acc = {};
+  for (const s of COA_PBI.sections) {
+    acc[s.id] = { total: 0, buckets: {} };
+    for (const b of s.level1) acc[s.id].buckets[b.account] = { amount: 0, children: {} };
+  }
+
+  for (const e of entries || []) {
+    const acctNum = parseInt(e.accountNumber, 10);
+    if (!Number.isFinite(acctNum)) continue;
+    const secId = sectionIdFor(acctNum);
+    if (!secId) continue;
+    const bucket = bucketFor(secDefById[secId], acctNum);
+    const amt = (e.debitAmount || 0) - (e.creditAmount || 0); // convención Power BI
+    const box = acc[secId];
+    box.total += amt;
+    box.buckets[bucket.account].amount += amt;
+    if (level >= 2) {
+      const key = String(e.accountNumber);
+      const ch = box.buckets[bucket.account].children;
+      if (!ch[key]) ch[key] = { account: key, name: accountNames[key] || e.description || `Cuenta ${key}`, amount: 0 };
+      ch[key].amount += amt;
+    }
+  }
+
+  const sections = [];
+  const accounts_map = {};
+  let grand = 0;
+  for (const s of COA_PBI.sections) {
+    const box = acc[s.id];
+    const accounts = [];
+    for (const b of s.level1) {
+      const bk = box.buckets[b.account];
+      const amount = round2(bk.amount);
+      const childArr = Object.values(bk.children)
+        .map((c) => ({ account: c.account, name: c.name, amount: round2(c.amount) }))
+        .sort((x, y) => x.account.localeCompare(y.account));
+      const row = { account: b.account, name: b.name, amount };
+      if (level >= 2) row.children = childArr;
+      accounts.push(row);
+
+      const mapEntry = { posted: amount };
+      if (level >= 2 && childArr.length) {
+        mapEntry.children = {};
+        for (const c of childArr) mapEntry.children[c.account] = { name: c.name, posted: c.amount };
+      }
+      accounts_map[b.account] = mapEntry;
+    }
+    const total = round2(box.total);
+    grand += total;
+    sections.push({ id: s.id, total_account: s.total_account, total_name: s.total_name, total, accounts });
+  }
+
+  return {
+    sign_convention: 'power_bi (amount = debit − credit): ingresos negativos, costos/gastos positivos, Total negativo = ganancia',
+    sections,
+    grand_total: round2(grand),
+    accounts_map,
+  };
+}
+
+// ── Orquestador ───────────────────────────────────────────────────────────────
+export async function getIncomeStatement(bcClient, params = {}) {
+  const t0 = Date.now();
+  const period = params.period || 'last_month';
+  const level = Number(params.level) === 2 ? 2 : 1;
+
+  let storeCodes = params.stores && params.stores.length ? params.stores : (params.store ? [params.store] : ['all']);
+  const stores = resolveStores(storeCodes.includes('all') ? null : storeCodes);
+  const { start, end } = getDateRange(period, params.start_date, params.end_date, params.month);
+  const label = periodLabel(start, end);
+
+  logger.info(`[income_statement] stores=${stores.map((s) => s.code).join(',')} ${start}→${end} level=${level}`);
+
+  const fxTask = bcClient
+    .getExchangeRates(stores[0].code)
+    .then((rates) => bcClient.getExchangeRateForDate(rates, end))
+    .catch((err) => {
+      logger.warn(`[income_statement] exchange rate fetch failed: ${err.message}`);
+      return null;
+    });
+
+  const perStore = await Promise.all(
+    stores.map(async (s) => {
+      const [income, cogs, expenses] = await Promise.all([
+        bcClient.getGLEntries(s.companyId, start, end, '40000', '49999'),
+        bcClient.getGLEntries(s.companyId, start, end, '50000', '59999'),
+        bcClient.getGLEntries(s.companyId, start, end, '60000', '99999'),
+      ]);
+      let accountNames = {};
+      if (level >= 2) {
+        accountNames = await bcClient.getChartOfAccountNames(s.companyId).catch((err) => {
+          logger.warn(`[income_statement] CoA names fetch failed (${s.code}): ${err.message}`);
+          return {};
+        });
+      }
+      const statement = buildStatement([...income, ...cogs, ...expenses], { level, accountNames });
+      return {
+        code: s.code, name: s.name,
+        companyName: decodeURIComponent(s.companyName || '') || s.name,
+        statement,
+      };
+    })
+  );
+
+  const fx = await fxTask;
+
+  const storesOut = {};
+  for (const r of perStore) {
+    storesOut[r.code] = {
+      store_code: r.code,
+      store_name: r.name,
+      company_name: r.companyName,
+      ...r.statement,
+    };
+  }
+
+  return {
+    format: 'power_bi_income_statement',
+    level,
+    period: { start, end, label },
+    exchange_rate: fx ? { rate: round2(fx.rate), label: `1 USD = ${round2(fx.rate)} VES` } : null,
+    generated_at: new Date().toISOString(),
+    note:
+      'Columna POSTED = Power BI tal cual (amount = debit − credit; ingresos negativos; Total negativo = ganancia). ' +
+      'El skill-fq-resultados-mensual agrega la columna Ajustado (drafts como posteados vía get_unposted_invoices + ' +
+      'nómina Draft) y la reclasificación de nómina gerencial a dividendos. `accounts_map` va listo para el data.json ' +
+      'del generador (build_income_statement.py): clave = cuenta level-1, valor = { posted, children? }.',
+    stores: storesOut,
+    query_duration_ms: Date.now() - t0,
+  };
+}
+
+// ── Definición del tool + handler ─────────────────────────────────────────────
+export const incomeStatementTool = {
+  name: 'get_income_statement',
+  description:
+    'Estado de resultados (Income Statement) en el formato EXACTO del reporte Power BI "Income Statement by Month" ' +
+    '(G/L Account Level 1) para una tienda Full Queso (FQ01, FQ28, FQ88) y un mes. Agrega los General Ledger entries ' +
+    'por cuenta level-1 con la convención de signos de Power BI (ingresos negativos, costos/gastos positivos, Total ' +
+    'negativo = ganancia), listo para comparar 1:1 con Power BI. Devuelve las 3 secciones (40001 TOTAL INGRESOS, ' +
+    '50001 TOTAL COSTO DE VENTAS, 60001 TOTAL GASTOS OPERATIVOS) con sus cuentas level-1, totales y Total general, ' +
+    'más un `accounts_map` listo para el generador Excel del skill. Con level=2 incluye las cuentas de posteo hijas ' +
+    'con su nombre real de BC. Resuelve las fronteras 71000/74000 y 74000/90000 que get_financial_statements no separa. ' +
+    'Úsalo para: income statement, estado de resultados level 1, resultado mensual comparable con Power BI, P&L por ' +
+    'cuenta. La columna Ajustado (drafts) la agrega el skill. READ-ONLY.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      store: {
+        type: 'string',
+        enum: ['FQ01', 'FQ28', 'FQ88', 'FQFR'],
+        description: 'Tienda a analizar (una sola, recomendado). Alternativa a `stores`.',
+      },
+      stores: {
+        type: 'array',
+        items: { type: 'string', enum: ['FQ01', 'FQ28', 'FQ88', 'FQFR', 'all'] },
+        description: 'Tiendas a analizar. Default: ["all"]. Para el income statement de una tienda usar `store`.',
+      },
+      period: {
+        type: 'string',
+        enum: ['last_month', 'this_month', 'specific_month', 'custom'],
+        description: 'Período. Default: last_month. Para un mes exacto usar period="specific_month" + month.',
+        default: 'last_month',
+      },
+      month: { type: 'string', description: 'Mes "YYYY-MM" (con period="specific_month").' },
+      start_date: { type: 'string', description: 'Fecha inicio "YYYY-MM-DD" (con period="custom").' },
+      end_date: { type: 'string', description: 'Fecha fin "YYYY-MM-DD" (con period="custom").' },
+      level: {
+        type: 'number',
+        enum: [1, 2],
+        description: 'Nivel de detalle: 1 = level-1 como Power BI (default); 2 = con cuentas de posteo hijas.',
+        default: 1,
+      },
+    },
+  },
+};
+
+export async function handleIncomeStatement(bcClient, args) {
+  return getIncomeStatement(bcClient, args || {});
+}

package/tools/financials/index.js

@@ -8,6 +8,7 @@
 import { getFinancialStatements } from './statements.js';
 
 export { cashFlowTool, handleCashFlow } from './cash-flow.js';
+export { incomeStatementTool, handleIncomeStatement } from './income-statement.js';
 
 export const financialStatementsTool = {
   name: 'get_financial_statements',

package/tools/get-crm-rate.js

@@ -0,0 +1,109 @@
+// tools/get-crm-rate.js
+// Tasa de cambio Bs/USD desde el CRM de Full Queso (hora Caracas).
+// Fuente: https://crm-rate.fullqueso.com
+//   - USDT == Binance == tasa paralelo
+//   - VES  == BCV     == tasa oficial
+// Histórica (con fecha) o del día (sin fecha).
+
+import { DateTime } from 'luxon';
+
+const CRM_RATE_BASE =
+  process.env.CRM_RATE_BASE || 'https://crm-rate.fullqueso.com/api/v1';
+
+// Normaliza el coin del usuario al símbolo del endpoint.
+function normalizeCoin(raw) {
+  const c = String(raw || '').trim().toUpperCase();
+  if (['USDT', 'BINANCE', 'PARALELO', 'PARALELA'].includes(c)) {
+    return { history: 'USDT', live: 'usdt', label: 'USDT/Binance' };
+  }
+  if (['VES', 'BCV', 'OFICIAL', 'BS'].includes(c)) {
+    return { history: 'VES', live: 'bcv', label: 'BCV (oficial)' };
+  }
+  return null;
+}
+
+export const crmRateTool = {
+  name: 'get_crm_rate',
+  description:
+    'Obtiene la tasa de cambio Bs/USD desde el CRM de Full Queso (hora Caracas). ' +
+    'Dos monedas: USDT (equivalente a la tasa Binance / paralelo) y VES (tasa BCV oficial). ' +
+    'Si se pasa una fecha (YYYY-MM-DD) retorna la tasa histórica guardada de ese día; ' +
+    'si se omite la fecha retorna la tasa del momento de la consulta. ' +
+    'Usar SIEMPRE que se pida: tasa USDT, tasa Binance, dólar Binance, tasa paralelo/paralela, ' +
+    'tasa BCV, tasa oficial, tasa del día o tasa histórica de una fecha. ' +
+    'Para tasa BCV vigente contable en Business Central usar get_exchange_rate; este tool es la tasa de referencia del CRM.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      coin: {
+        type: 'string',
+        enum: ['USDT', 'BINANCE', 'VES', 'BCV'],
+        description:
+          'Moneda/tasa. USDT y BINANCE son equivalentes (paralelo). VES y BCV son equivalentes (oficial BCV).',
+      },
+      date: {
+        type: 'string',
+        description:
+          'Fecha histórica (YYYY-MM-DD), hora Caracas. Si se omite, devuelve la tasa actual.',
+      },
+    },
+    required: ['coin'],
+  },
+};
+
+export async function handleGetCrmRate(_bcClient, args) {
+  const coin = normalizeCoin(args.coin);
+  if (!coin) {
+    throw new Error(
+      `coin inválido: "${args.coin}". Válidos: USDT/BINANCE (paralelo) o VES/BCV (oficial).`
+    );
+  }
+
+  const isHistorical = !!args.date;
+  let url;
+  if (isHistorical) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(args.date)) {
+      throw new Error(`date inválida: "${args.date}". Formato esperado YYYY-MM-DD.`);
+    }
+    url = `${CRM_RATE_BASE}/history/price?coin=${coin.history}&date=${args.date}`;
+  } else {
+    url = `${CRM_RATE_BASE}/coin/${coin.live}`;
+  }
+
+  let res;
+  try {
+    res = await fetch(url, { headers: { Accept: 'application/json' } });
+  } catch (e) {
+    throw new Error(`No se pudo conectar al CRM de tasas (${CRM_RATE_BASE}): ${e.message}`);
+  }
+
+  if (res.status === 400) {
+    throw new Error('CRM 400: coin o date inválidos.');
+  }
+  if (res.status === 404) {
+    return {
+      coin: coin.label,
+      date: args.date || null,
+      price: null,
+      message: `No hay registro de tasa ${coin.label} para ${args.date}.`,
+    };
+  }
+  if (!res.ok) {
+    throw new Error(`CRM respondió ${res.status} en ${url}`);
+  }
+
+  const data = await res.json();
+  const nowCcs = DateTime.now().setZone('America/Caracas');
+  const price =
+    typeof data.price === 'number' ? Math.round(data.price * 100) / 100 : data.price;
+
+  return {
+    coin: coin.label,
+    type: isHistorical ? 'historica' : 'del_dia',
+    date: isHistorical ? args.date : nowCcs.toISODate(),
+    queried_at_caracas: nowCcs.toFormat('yyyy-MM-dd HH:mm:ss'),
+    price,
+    label: `1 USD = ${price} Bs (${coin.label})`,
+    source: url,
+  };
+}

package/tools/multi-payment/index.js

@@ -1,3 +1,4 @@
 export { draftReceivablesTool, handleDraftReceivables } from './draft-receivables.js';
 export { draftPayablesTool, handleDraftPayables } from './draft-payables.js';
 export { draftSummaryTool, handleDraftSummary } from './draft-summary.js';
+export { unpostedInvoicesTool, handleUnpostedInvoices } from './unposted-invoices.js';