panal-mcp 0.7.0 → 0.8.1

package/README.md

@@ -37,7 +37,7 @@ Reinicia el cliente y pregunta *«¿qué agentes hay en Panal?»*.
 | `panal_get_agent` | Ficha completa: precio, skills, estado y nombre único leído de la cadena |
 | `panal_get_task` | Estado de un encargo en el escrow |
 | `panal_marketplace_stats` | Cifras del marketplace |
-| `panal_wallet` | Saldo y presupuesto restante *(escritura)* |
+| `panal_wallet` | Saldo en cada moneda (MON y $PANAL), presupuesto restante y lo que el escrow te debe *(escritura)* |
 | `panal_quote_hire` | Presupuesta un encargo sin pagar, y comprueba que el agente responde *(escritura)* |
 | `panal_hire` | Contrata y bloquea el pago *(escritura)* |
 | `panal_send_brief` | Reenvía el encargo si no llegó al contratar *(escritura)* |
@@ -46,7 +46,7 @@ Reinicia el cliente y pregunta *«¿qué agentes hay en Panal?»*.
 | `panal_quote_ask` / `panal_ask` | Pregunta suelta a un agente, sin abrir un encargo *(escritura)* |
 | `panal_cancel_task` | Recupera tu dinero si nadie empezó y venció el plazo *(escritura)* |
 | `panal_open_dispute` | Abre disputa si lo entregado no vale *(escritura)* |
-| `panal_withdraw` | Retira lo que el escrow te debe *(escritura)* |
+| `panal_withdraw` | Retira lo que el escrow te debe, en todas las monedas *(escritura)* |
 
 Las cuatro últimas existen por lo mismo: un encargo puede torcerse, y hasta que las
 hubo la única salida era esperar. El escrow es de **pago tirado** (*pull*), así que lo
@@ -66,7 +66,9 @@ Las herramientas de escritura mueven dinero real en mainnet, así que están **a
         "MCP_ENABLE_WRITES": "true",
         "MCP_PRIVATE_KEY": "0x…",
         "MCP_MAX_PER_TASK_WEI": "1000000000000000000",
-        "MCP_DAILY_BUDGET_WEI": "5000000000000000000"
+        "MCP_DAILY_BUDGET_WEI": "5000000000000000000",
+        "MCP_MAX_PER_TASK_PANAL_WEI": "3000000000000000000",
+        "MCP_DAILY_BUDGET_PANAL_WEI": "10000000000000000000"
       }
     }
   }
@@ -79,8 +81,17 @@ Las herramientas de escritura mueven dinero real en mainnet, así que están **a
 |---|---|---|
 | `MCP_ENABLE_WRITES` | `false` | Interruptor general |
 | `MCP_PRIVATE_KEY` | — | Wallet del cliente que paga |
-| `MCP_MAX_PER_TASK_WEI` | `1e18` (1 MON) | Tope por encargo |
-| `MCP_DAILY_BUDGET_WEI` | `5e18` (5 MON) | Tope por día UTC, persistido en disco |
+| `MCP_MAX_PER_TASK_WEI` | `1e18` (1 MON) | Tope por encargo, **en MON** |
+| `MCP_DAILY_BUDGET_WEI` | `5e18` (5 MON) | Tope por día UTC **en MON**, persistido en disco |
+| `MCP_MAX_PER_TASK_PANAL_WEI` | `1e18` (1 $PANAL) | Tope por encargo, **en $PANAL** |
+| `MCP_DAILY_BUDGET_PANAL_WEI` | `5e18` (5 $PANAL) | Tope por día UTC **en $PANAL** |
+
+**Cada moneda lleva su cuenta.** Panal cobra en MON nativo y en $PANAL, que no valen lo
+mismo y no tienen tipo de cambio entre sí: sumarlos en un solo número sería inventarse
+la conversión. Con un contador único, tres consultas pagadas en $PANAL agotaban un
+presupuesto puesto pensando en MON y bloqueaban una contratación que iba sobrada. Si un
+agente cobra en un token que no es ninguno de los dos, el servidor **se niega** en vez de
+tirar del presupuesto de otra moneda.
 | `MCP_TASK_DEADLINE_HOURS` | `24` | Plazo de entrega |
 | `MCP_SPEND_FILE` | `.panal-mcp/spend.json` | Dónde se guarda el gasto del día |
 | `RPC_URL` | RPC público de Monad | Tu propio RPC |

package/dist/limits.d.ts

@@ -52,11 +52,20 @@ export declare class QuoteBook {
     private prune;
 }
 /**
- * Registro de gasto diario, persistido en disco.
+ * Registro de gasto diario, persistido en disco y SEPARADO POR MONEDA.
  *
  * Un tope que se borra al reiniciar no es un tope: bastaría con reiniciar el
  * servidor para volver a gastar el presupuesto entero. Se guarda el día UTC
- * junto al importe, así que el contador se reinicia solo al cambiar de día.
+ * junto a los importes, así que el contador se reinicia solo al cambiar de día.
+ *
+ * POR QUÉ POR MONEDA
+ *
+ * Antes había un solo número. Panal cobra en dos monedas —MON nativo y $PANAL—
+ * y no hay tipo de cambio entre ellas, así que sumarlas era inventárselo: tres
+ * consultas de $PANAL agotaban un presupuesto puesto pensando en MON, y al
+ * revés, un tope generoso en $PANAL abría la mano con el MON sin que nadie lo
+ * hubiera decidido. La cuenta protegía de más, que es el lado bueno del fallo,
+ * pero un tope que no significa lo que dice no se puede ajustar.
  */
 export declare class SpendLedger {
     private readonly file;
@@ -64,12 +73,31 @@ export declare class SpendLedger {
     constructor(file: string, onWarn: (msg: string) => void);
     static defaultFile(): string;
     private static utcDay;
-    spentToday(): bigint;
-    record(wei: bigint): void;
+    /** Todo lo gastado hoy, por moneda. Vacío si el archivo es de otro día. */
+    private leer;
+    spentToday(currency: Address): bigint;
+    record(currency: Address, wei: bigint): void;
 }
-export interface Limits {
+/** El tope de una moneda concreta. */
+export interface CurrencyLimit {
     maxPerTaskWei: bigint;
     dailyBudgetWei: bigint;
+    /** El nombre de la variable de entorno, para poder decirle a alguien cuál subir. */
+    envMaxPerTask: string;
+    envDailyBudget: string;
+}
+export interface Limits {
     deadlineHours: number;
+    /** Topes por moneda, indexados por dirección en minúsculas. */
+    porMoneda: Map<string, CurrencyLimit>;
 }
+/**
+ * El tope de una moneda, o `null` si no hay ninguno puesto para ella.
+ *
+ * `null` significa NO HAY PRESUPUESTO, y quien llame debe negarse. Es
+ * deliberado: la alternativa sería reutilizar el tope de otra moneda, y eso
+ * exige un tipo de cambio que nadie tiene. Un agente que cobre en un token
+ * desconocido no se contrata hasta que alguien decida cuánto vale.
+ */
+export declare function limitFor(limits: Limits, currency: Address): CurrencyLimit | null;
 export declare function limitsFromEnv(): Limits;

package/dist/limits.js

@@ -57,12 +57,25 @@ export class QuoteBook {
                 this.quotes.delete(id);
     }
 }
+/** Clave de un contador: la dirección de la moneda, en minúsculas. */
+function clave(currency) {
+    return currency.toLowerCase();
+}
 /**
- * Registro de gasto diario, persistido en disco.
+ * Registro de gasto diario, persistido en disco y SEPARADO POR MONEDA.
  *
  * Un tope que se borra al reiniciar no es un tope: bastaría con reiniciar el
  * servidor para volver a gastar el presupuesto entero. Se guarda el día UTC
- * junto al importe, así que el contador se reinicia solo al cambiar de día.
+ * junto a los importes, así que el contador se reinicia solo al cambiar de día.
+ *
+ * POR QUÉ POR MONEDA
+ *
+ * Antes había un solo número. Panal cobra en dos monedas —MON nativo y $PANAL—
+ * y no hay tipo de cambio entre ellas, así que sumarlas era inventárselo: tres
+ * consultas de $PANAL agotaban un presupuesto puesto pensando en MON, y al
+ * revés, un tope generoso en $PANAL abría la mano con el MON sin que nadie lo
+ * hubiera decidido. La cuenta protegía de más, que es el lado bueno del fallo,
+ * pero un tope que no significa lo que dice no se puede ajustar.
  */
 export class SpendLedger {
     file;
@@ -77,27 +90,55 @@ export class SpendLedger {
     static utcDay() {
         return new Date().toISOString().slice(0, 10);
     }
-    spentToday() {
+    /** Todo lo gastado hoy, por moneda. Vacío si el archivo es de otro día. */
+    leer() {
+        const out = new Map();
         try {
             const raw = JSON.parse(readFileSync(this.file, 'utf8'));
             if (raw.day !== SpendLedger.utcDay())
-                return 0n;
-            return BigInt(raw.spentWei ?? '0');
+                return out;
+            // Formato antiguo: un solo número, sin moneda. Era el gasto de todo, pero
+            // en la práctica el que llevaba la cuenta era el nativo, así que se
+            // adopta ahí. Perderlo dejaría el tope del día a cero tras actualizar.
+            if (typeof raw.spentWei === 'string' && !raw.spent) {
+                try {
+                    out.set(clave(NATIVO), BigInt(raw.spentWei));
+                }
+                catch {
+                    /* ilegible: se ignora */
+                }
+                return out;
+            }
+            for (const [k, v] of Object.entries(raw.spent ?? {})) {
+                try {
+                    out.set(k.toLowerCase(), BigInt(v));
+                }
+                catch {
+                    /* una entrada corrupta no invalida las demás */
+                }
+            }
         }
         catch {
             // Sin archivo, ilegible o corrupto: se empieza de cero. Nunca lanza,
             // porque un ledger roto no debe dejar el servidor inservible.
-            return 0n;
         }
+        return out;
     }
-    record(wei) {
-        const total = this.spentToday() + wei;
+    spentToday(currency) {
+        return this.leer().get(clave(currency)) ?? 0n;
+    }
+    record(currency, wei) {
+        const todo = this.leer();
+        todo.set(clave(currency), (todo.get(clave(currency)) ?? 0n) + wei);
+        const spent = {};
+        for (const [k, v] of todo)
+            spent[k] = v.toString();
         try {
             mkdirSync(dirname(this.file), { recursive: true });
             // Escritura atómica: un corte a media escritura dejaría un JSON truncado
             // que se leería como 0 y borraría el tope del día.
             const tmp = `${this.file}.tmp`;
-            writeFileSync(tmp, JSON.stringify({ day: SpendLedger.utcDay(), spentWei: total.toString() }, null, 2));
+            writeFileSync(tmp, JSON.stringify({ day: SpendLedger.utcDay(), spent }, null, 2));
             renameSync(tmp, this.file);
         }
         catch (err) {
@@ -106,6 +147,21 @@ export class SpendLedger {
         }
     }
 }
+/** La moneda nativa en el escrow de Panal: la dirección cero. */
+const NATIVO = '0x0000000000000000000000000000000000000000';
+/** $PANAL en Monad mainnet. */
+const PANAL = '0x2e2e44e7fa6178822d4397299f719e89d1a67777';
+/**
+ * El tope de una moneda, o `null` si no hay ninguno puesto para ella.
+ *
+ * `null` significa NO HAY PRESUPUESTO, y quien llame debe negarse. Es
+ * deliberado: la alternativa sería reutilizar el tope de otra moneda, y eso
+ * exige un tipo de cambio que nadie tiene. Un agente que cobre en un token
+ * desconocido no se contrata hasta que alguien decida cuánto vale.
+ */
+export function limitFor(limits, currency) {
+    return limits.porMoneda.get(clave(currency)) ?? null;
+}
 export function limitsFromEnv() {
     const parse = (name, fallback) => {
         const raw = process.env[name]?.trim();
@@ -120,9 +176,22 @@ export function limitsFromEnv() {
         }
     };
     const hours = Number(process.env.MCP_TASK_DEADLINE_HOURS?.trim() || '24');
-    return {
-        maxPerTaskWei: parse('MCP_MAX_PER_TASK_WEI', 10n ** 18n), // 1 MON / $PANAL
+    const porMoneda = new Map();
+    // MON conserva los nombres de siempre: quien ya tenía un .env sigue
+    // significando exactamente lo que creía.
+    porMoneda.set(clave(NATIVO), {
+        maxPerTaskWei: parse('MCP_MAX_PER_TASK_WEI', 10n ** 18n),
         dailyBudgetWei: parse('MCP_DAILY_BUDGET_WEI', 5n * 10n ** 18n),
-        deadlineHours: Number.isFinite(hours) && hours > 0 ? hours : 24,
-    };
+        envMaxPerTask: 'MCP_MAX_PER_TASK_WEI',
+        envDailyBudget: 'MCP_DAILY_BUDGET_WEI',
+    });
+    // $PANAL estrena las suyas, con los mismos números de antes. No se copian de
+    // MON porque no valen lo mismo: son dos presupuestos que se ajustan aparte.
+    porMoneda.set(clave(PANAL), {
+        maxPerTaskWei: parse('MCP_MAX_PER_TASK_PANAL_WEI', 10n ** 18n),
+        dailyBudgetWei: parse('MCP_DAILY_BUDGET_PANAL_WEI', 5n * 10n ** 18n),
+        envMaxPerTask: 'MCP_MAX_PER_TASK_PANAL_WEI',
+        envDailyBudget: 'MCP_DAILY_BUDGET_PANAL_WEI',
+    });
+    return { deadlineHours: Number.isFinite(hours) && hours > 0 ? hours : 24, porMoneda };
 }

package/dist/server.d.ts

@@ -13,8 +13,14 @@
  *   MCP_PRIVATE_KEY=0x…      wallet dedicada del CLIENTE, con fondos
  *
  * Topes (todos opcionales, con valores conservadores por defecto):
- *   MCP_MAX_PER_TASK_WEI     por encargo    (default 1e18 = 1 MON/$PANAL)
- *   MCP_DAILY_BUDGET_WEI     por día UTC    (default 5e18)
+ *   MCP_MAX_PER_TASK_WEI          por encargo, en MON      (default 1e18)
+ *   MCP_DAILY_BUDGET_WEI          por día UTC, en MON      (default 5e18)
+ *   MCP_MAX_PER_TASK_PANAL_WEI    por encargo, en $PANAL   (default 1e18)
+ *   MCP_DAILY_BUDGET_PANAL_WEI    por día UTC, en $PANAL   (default 5e18)
+ *
+ * Cada moneda lleva su cuenta. MON y $PANAL no valen lo mismo y no hay tipo de
+ * cambio entre ellos, así que un solo contador para los dos era una suma
+ * inventada: gastar en una agotaba el presupuesto de la otra.
  *   MCP_TASK_DEADLINE_HOURS  plazo de entrega (default 24)
  *   MCP_SPEND_FILE           dónde persistir el gasto del día
  *

package/dist/server.js

@@ -13,8 +13,14 @@
  *   MCP_PRIVATE_KEY=0x…      wallet dedicada del CLIENTE, con fondos
  *
  * Topes (todos opcionales, con valores conservadores por defecto):
- *   MCP_MAX_PER_TASK_WEI     por encargo    (default 1e18 = 1 MON/$PANAL)
- *   MCP_DAILY_BUDGET_WEI     por día UTC    (default 5e18)
+ *   MCP_MAX_PER_TASK_WEI          por encargo, en MON      (default 1e18)
+ *   MCP_DAILY_BUDGET_WEI          por día UTC, en MON      (default 5e18)
+ *   MCP_MAX_PER_TASK_PANAL_WEI    por encargo, en $PANAL   (default 1e18)
+ *   MCP_DAILY_BUDGET_PANAL_WEI    por día UTC, en $PANAL   (default 5e18)
+ *
+ * Cada moneda lleva su cuenta. MON y $PANAL no valen lo mismo y no hay tipo de
+ * cambio entre ellos, así que un solo contador para los dos era una suma
+ * inventada: gastar en una agotaba el presupuesto de la otra.
  *   MCP_TASK_DEADLINE_HOURS  plazo de entrega (default 24)
  *   MCP_SPEND_FILE           dónde persistir el gasto del día
  *
@@ -28,8 +34,8 @@ import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { formatEther, isAddress, keccak256, parseEther, toBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { NATIVE_CURRENCY, TaskStatus, createPanalClient, } from '@panal/sdk';
-import { QuoteBook, SpendLedger, limitsFromEnv } from './limits.js';
+import { NATIVE_CURRENCY, TaskStatus, createPanalClient, erc20Abi, } from '@panal/sdk';
+import { QuoteBook, SpendLedger, limitFor, limitsFromEnv } from './limits.js';
 import { briefSignMessage, expiraEn, fetchAgentLimits, fetchResultText, pushBrief, resultSignMessage, } from './fetch-result.js';
 const SERVER_NAME = 'panal';
 /**
@@ -88,8 +94,67 @@ function writesBlockedReason() {
 // ---------------------------------------------------------------------------
 // Presentación
 // ---------------------------------------------------------------------------
+/** ¿Es la moneda nativa de la cadena, o un token? */
+function esNativa(currency) {
+    return currency.toLowerCase() === NATIVE_CURRENCY.toLowerCase();
+}
 function symbolOf(currency) {
-    return currency.toLowerCase() === NATIVE_CURRENCY.toLowerCase() ? 'MON' : '$PANAL';
+    return esNativa(currency) ? 'MON' : '$PANAL';
+}
+/** Las monedas que este servidor sabe manejar: las que tienen presupuesto. */
+function monedasConocidas() {
+    return [...limits.porMoneda.keys()];
+}
+/**
+ * Saldo de una wallet en una moneda: a la cadena si es la nativa, al contrato
+ * del token si es un ERC-20.
+ *
+ * `null` es «no se pudo leer», y se distingue de cero a propósito. Enseñar 0
+ * cuando la consulta falla es afirmar que no hay fondos, que es una respuesta
+ * distinta: llevaría a no intentar un pago que sí se podía hacer.
+ */
+async function saldoDe(owner, currency) {
+    try {
+        if (esNativa(currency))
+            return await panal.publicClient.getBalance({ address: owner });
+        return (await panal.publicClient.readContract({
+            address: currency,
+            abi: erc20Abi,
+            functionName: 'balanceOf',
+            args: [owner],
+        }));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * ¿Cabe este gasto en el presupuesto de SU moneda? Devuelve el motivo, o null.
+ *
+ * Cada moneda lleva su cuenta. Sumar MON y $PANAL en un solo número exigiría un
+ * tipo de cambio que nadie tiene, y el resultado era que tres consultas de
+ * $PANAL agotaban un tope puesto pensando en MON.
+ *
+ * Sin presupuesto para una moneda, se dice que no. La alternativa —tirar del
+ * tope de otra— es exactamente la conversión a ojo que este cambio elimina.
+ */
+function revisarPresupuesto(currency, amount, symbol) {
+    const lim = limitFor(limits, currency);
+    if (!lim) {
+        return (`That agent charges in a token this server has no budget for (${currency}). ` +
+            'Only MON and $PANAL have caps configured; there is no exchange rate to reuse another one.');
+    }
+    if (amount > lim.maxPerTaskWei) {
+        return (`That costs ${formatEther(amount)} ${symbol} and the per-item cap for ${symbol} is ` +
+            `${formatEther(lim.maxPerTaskWei)}. Raise ${lim.envMaxPerTask} if that is intended.`);
+    }
+    const spent = ledger.spentToday(currency);
+    if (spent + amount > lim.dailyBudgetWei) {
+        return (`That would blow today's ${symbol} budget: ${formatEther(spent)} of ` +
+            `${formatEther(lim.dailyBudgetWei)} spent and this costs ${formatEther(amount)} ${symbol}. ` +
+            `Raise ${lim.envDailyBudget} if that is intended.`);
+    }
+    return null;
 }
 /** Días desde un timestamp en segundos. */
 function daysSince(ts) {
@@ -336,28 +401,54 @@ const READ_TOOLS = [
 const WRITE_TOOLS = [
     {
         name: 'panal_wallet',
-        description: 'State of the wallet this server would pay with: address, balance, and how much of today\'s budget ' +
-            'is left. Call it before hiring to know whether there are funds.',
+        description: 'State of the wallet this server would pay with: address, the balance of EVERY currency Panal ' +
+            'takes (MON and $PANAL), and how much of today\'s budget is left. Call it before hiring to know ' +
+            'whether there are funds.',
         inputSchema: { type: 'object', properties: {} },
         handler: async () => {
             const blocked = writesBlockedReason();
             if (blocked)
                 return blocked;
             const address = account.address;
-            const [balance, spent] = [await panal.publicClient.getBalance({ address }), ledger.spentToday()];
-            const left = limits.dailyBudgetWei > spent ? limits.dailyBudgetWei - spent : 0n;
-            // Lo acreditado en el escrow no aparece en el balance de la wallet: es
-            // pull payment, así que un reembolso se queda ahí quieto hasta que se
-            // reclama. Sin decirlo, el dinero devuelto es indistinguible del perdido.
-            const pending = await panal.getPendingWithdrawal(address).catch(() => 0n);
+            const monedas = monedasConocidas();
+            // Un saldo por moneda, no solo el nativo. Antes se leía únicamente MON y
+            // justo debajo se listaban los topes de $PANAL: quien lo leía daba por
+            // comprobado un saldo que nadie había mirado, y podía contratar en $PANAL
+            // sin tener con qué pagar. Las lecturas son independientes, así que van
+            // en paralelo.
+            const [saldos, pendientes] = await Promise.all([
+                Promise.all(monedas.map((m) => saldoDe(address, m))),
+                // Lo acreditado en el escrow no aparece en el balance de la wallet: es
+                // pull payment, así que un reembolso se queda ahí quieto hasta que se
+                // reclama. Sin decirlo, el dinero devuelto es indistinguible del
+                // perdido — y también hay que preguntarlo moneda a moneda.
+                Promise.all(monedas.map((m) => panal.getPendingWithdrawal(address, m).catch(() => null))),
+            ]);
+            const importe = (v) => (v === null ? 'could not be read' : formatEther(v));
+            const balances = monedas.map((m, i) => `  ${symbolOf(m)}: ${importe(saldos[i] ?? null)}`);
+            // Un presupuesto por moneda: MON y $PANAL no valen lo mismo y no hay
+            // tipo de cambio, así que se enseñan por separado o no se entienden.
+            const presupuestos = monedas.map((moneda) => {
+                const lim = limitFor(limits, moneda);
+                const spent = ledger.spentToday(moneda);
+                const left = lim.dailyBudgetWei > spent ? lim.dailyBudgetWei - spent : 0n;
+                return (`  ${symbolOf(moneda)}: per job ${formatEther(lim.maxPerTaskWei)} · today ${formatEther(spent)} of ` +
+                    `${formatEther(lim.dailyBudgetWei)} spent · ${formatEther(left)} left`);
+            });
+            // Solo se nombra lo que hay que cobrar, o lo que no se pudo comprobar. Un
+            // «0» por cada moneda sería ruido en la respuesta más leída del servidor.
+            const enEscrow = monedas
+                .map((m, i) => ({ sym: symbolOf(m), v: pendientes[i] ?? null }))
+                .filter(({ v }) => v === null || v > 0n)
+                .map(({ sym, v }) => `  ${sym}: ${importe(v)}`);
             return [
                 `Wallet: ${address}`,
-                `Balance: ${formatEther(balance)} MON`,
-                `Per-job cap: ${formatEther(limits.maxPerTaskWei)}`,
-                `Today's budget: spent ${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)} · ${formatEther(left)} left`,
-                pending > 0n
-                    ? `Waiting in the escrow: ${formatEther(pending)} MON — collect it with panal_withdraw`
-                    : null,
+                'Balance:',
+                ...balances,
+                'Caps and budgets (each currency is counted on its own):',
+                ...presupuestos,
+                enEscrow.length ? 'Waiting in the escrow — collect it with panal_withdraw:' : null,
+                ...enEscrow,
             ]
                 .filter(Boolean)
                 .join('\n');
@@ -390,15 +481,9 @@ const WRITE_TOOLS = [
                 return `${agent.metadata.name || address} is delisted and does not take jobs.`;
             const amount = agent.pricePerTask;
             const symbol = symbolOf(agent.currency);
-            if (amount > limits.maxPerTaskWei) {
-                return (`That agent charges ${formatEther(amount)} ${symbol} and this server per-job cap is ` +
-                    `${formatEther(limits.maxPerTaskWei)}. It cannot be hired unless the person raises MCP_MAX_PER_TASK_WEI.`);
-            }
-            const spent = ledger.spentToday();
-            if (spent + amount > limits.dailyBudgetWei) {
-                return (`That would blow today's budget: ${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)} spent ` +
-                    `and this costs ${formatEther(amount)} ${symbol}.`);
-            }
+            const negativa = revisarPresupuesto(agent.currency, amount, symbol);
+            if (negativa)
+                return negativa;
             // El tope del brief se pregunta ANTES de presupuestar. Si no cabe, el
             // agente lo rechazaría con un 400 al recibirlo — pero eso ocurre ya con
             // el pago bloqueado, porque el encargo se entrega después de crear la
@@ -476,22 +561,17 @@ const WRITE_TOOLS = [
             const quote = redeemed.quote;
             // Los mismos topes que contratar. Una consulta es barata, pero nada
             // impide encadenar mil: el presupuesto del día es lo que lo impide.
-            if (quote.amount > limits.maxPerTaskWei) {
-                return (`That question costs ${formatEther(quote.amount)} ${quote.symbol} and this server per-item cap is ` +
-                    `${formatEther(limits.maxPerTaskWei)}. Raise MCP_MAX_PER_TASK_WEI if that is intended.`);
-            }
-            const spent = ledger.spentToday();
-            if (spent + quote.amount > limits.dailyBudgetWei) {
-                return (`That would blow today's budget: ${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)} spent ` +
-                    `and this costs ${formatEther(quote.amount)} ${quote.symbol}.`);
-            }
+            const negativa = revisarPresupuesto(quote.currency, quote.amount, quote.symbol);
+            if (negativa)
+                return negativa;
             try {
                 // `maxSpend` va atado al importe del presupuesto que la persona
                 // aprobó, no al tope del servidor: si el agente sube el precio entre
                 // el presupuesto y el sí, la firma no se produce.
                 const res = await panal.askAgent(quote.worker, quote.brief, { maxSpend: quote.amount });
-                // Se registra lo REALMENTE pagado, que es lo que devuelve el SDK.
-                ledger.record(res.paid);
+                // Se registra lo REALMENTE pagado, y en SU moneda: un gasto anotado en
+                // el contador equivocado agota un presupuesto que nadie tocó.
+                ledger.record(quote.currency, res.paid);
                 log(`consulta pagada a ${quote.worker}: ${formatEther(res.paid)} ${quote.symbol}`);
                 return [
                     `Paid ${formatEther(res.paid)} ${quote.symbol} to ${quote.agentName}.`,
@@ -541,14 +621,13 @@ const WRITE_TOOLS = [
             const quote = redeemed.quote;
             // Los topes se re-evalúan al contratar: entre el presupuesto y el "sí"
             // pueden haber pasado minutos y otros encargos.
-            const spent = ledger.spentToday();
-            if (spent + quote.amount > limits.dailyBudgetWei) {
-                return `Today's budget ran out in the meantime (${formatEther(spent)} of ${formatEther(limits.dailyBudgetWei)}).`;
-            }
+            const negativa = revisarPresupuesto(quote.currency, quote.amount, quote.symbol);
+            if (negativa)
+                return negativa;
             const deadline = BigInt(Math.floor(Date.now() / 1000) + limits.deadlineHours * 3600);
             try {
                 const result = await panal.hire({ agent: quote.worker, brief: quote.brief, deadline });
-                ledger.record(result.amount);
+                ledger.record(quote.currency, result.amount);
                 log(`contratada #${result.taskId} a ${quote.worker} por ${formatEther(result.amount)} ${quote.symbol}`);
                 // Contratar sin entregar el encargo deja la tarea a medias: el pago
                 // bloqueado y el agente esperando un texto que nadie le manda. Se hace
@@ -808,9 +887,9 @@ const WRITE_TOOLS = [
     },
     {
         name: 'panal_withdraw',
-        description: 'Collect what the escrow owes this wallet — refunds from cancelled jobs. The escrow is pull ' +
-            'payment: it credits balances and never pushes them, so money sits there until this is called. ' +
-            'Call panal_wallet first to see whether there is anything to collect.',
+        description: 'Collect what the escrow owes this wallet — refunds from cancelled jobs — in EVERY currency it ' +
+            'holds, one transaction each. The escrow is pull payment: it credits balances and never pushes ' +
+            'them, so money sits there until this is called. Call panal_wallet first to see what is waiting.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -826,11 +905,36 @@ const WRITE_TOOLS = [
                 return 'I will not move funds without confirmed_by_user: true.';
             }
             try {
-                const pending = await panal.getPendingWithdrawal(account.address);
-                if (pending === 0n)
+                // Se retira MONEDA A MONEDA. El escrow lleva un saldo por cada una y
+                // `withdraw` solo vacía la que se le pide; preguntando únicamente por
+                // la nativa, un reembolso en $PANAL quedaba invisible y esta misma
+                // herramienta contestaba que no había nada que cobrar. El dinero seguía
+                // en el contrato, pero desde aquí no había forma de sacarlo.
+                const monedas = monedasConocidas();
+                const pendientes = [];
+                for (const moneda of monedas) {
+                    const importe = await panal.getPendingWithdrawal(account.address, moneda);
+                    if (importe > 0n)
+                        pendientes.push({ moneda, importe });
+                }
+                if (!pendientes.length)
                     return 'The escrow owes this wallet nothing: there is nothing to collect.';
-                const hash = await panal.withdraw();
-                return `Collected ${formatEther(pending)} MON from the escrow.\n  tx: ${EXPLORER}/tx/${hash}`;
+                // Cada moneda es una transacción aparte, y si una falla se sigue con
+                // las demás: quedarse sin cobrar el $PANAL porque el MON se quedó sin
+                // gas es perder dos veces.
+                const lineas = [];
+                for (const { moneda, importe } of pendientes) {
+                    const sym = symbolOf(moneda);
+                    try {
+                        const hash = await panal.withdraw(moneda);
+                        lineas.push(`Collected ${formatEther(importe)} ${sym} from the escrow.\n  tx: ${EXPLORER}/tx/${hash}`);
+                    }
+                    catch (err) {
+                        lineas.push(`Could not collect the ${formatEther(importe)} ${sym}: ${err instanceof Error ? err.message : err}` +
+                            '\n  It is still credited in the escrow; calling this again will retry it.');
+                    }
+                }
+                return lineas.join('\n');
             }
             catch (err) {
                 return `Could not withdraw: ${err instanceof Error ? err.message : err}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "panal-mcp",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Servidor MCP de Panal: busca y contrata agentes de IA on-chain desde Claude",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "start": "tsx src/server.ts",
-    "test": "tsx test/mcp.test.ts",
+    "test": "tsx test/mcp.test.ts && tsx test/limites.test.ts && tsx test/monedas.test.ts",
     "test:limites": "tsx test/limites.test.ts"
   }
 }