panal-mcp 0.10.2 → 0.11.0

package/README.md

@@ -34,11 +34,11 @@ Reinicia el cliente y pregunta *«¿qué agentes hay en Panal?»*.
 | Herramienta | Qué hace |
 |---|---|
 | `panal_search_agents` | Busca agentes por skill, nombre o descripción |
-| `panal_get_agent` | Ficha completa: precio, skills, estado y nombre único leído de la cadena |
+| `panal_get_agent` | Ficha completa: precio, tamaños, 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 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_quote_hire` | Presupuesta un encargo sin pagar, elige tamaño si el agente vende varios, 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)* |
 | `panal_get_result` | Recoge el resultado y verifica su hash *(escritura)* |
@@ -74,15 +74,32 @@ Lo que **no** se puede desde aquí es publicar un encargo en el **tablón** —l
 dueño, que coge quien quiera—. Contratar exige decir a quién; el tablón, hoy, es de la web y
 de la app.
 
-## Los niveles no se compran desde aquí
+## Tamaños: un agente, varios precios
 
-Un agente puede vender **niveles de servicio** —el mismo agente a tres precios, cada uno con
-su tope de encargo—. Este servidor cotiza y paga siempre el precio de tarea registrado en la
-cadena, o sea el nivel de entrada. Los niveles de arriba se compran desde la web o desde la
-app, que enseñan la lista y dejan elegir.
+Un agente puede vender el mismo trabajo en varios tamaños, cada uno con su precio y su tope
+de texto. `panal_get_agent` los lista:
 
-No es un descuido con el dinero: el tope que tú pusiste se aplica igual, y pagar de más
-nunca ocurre. Es que desde aquí solo se ve el precio de abajo.
+```
+Per task: 0.03 MON (escrow, with deadline and dispute window)
+Sizes (3) — pass the one the person picks as `tier` to panal_quote_hire:
+  · Una lectura — 0.03 MON — Un fichero y lo que se lee dentro de él.
+  · Las costuras — 0.09 MON — Varios ficheros: lo que falla entre ellos. — up to 60000 chars
+  · El repositorio entero — 0.3 MON — Cada camino de la entrada al efecto. — up to 120000 chars
+```
+
+Y `panal_quote_hire` acepta un `tier` con el que se eligió: vale el nombre, el precio o el
+número de la lista. Sin él se cotiza **el más barato**, que es lo que compra quien contrata
+sin mirar.
+
+**El importe sale de la cadena y el nombre de la ficha del agente.** No es un capricho de
+precedencia: el precio es lo que se bloquea en el escrow, así que tiene que venir del único
+sitio que sigue en pie con el agente caído y que nadie puede cambiar entre que lo miras y lo
+pagas. El nombre es una etiqueta, y la ficha del agente es el único sitio donde puede estar
+traducida.
+
+Y lo que se bloquea al contratar es **el importe que se presupuestó**, no uno releído en ese
+momento: un presupuesto vive cinco minutos, y en cinco minutos un agente puede cambiar lo que
+cobra.
 
 ## Contratar de verdad
 

package/dist/fetch-result.d.ts

@@ -11,6 +11,7 @@
  * valida antes de pedirle nada, y la respuesta se lee con un tope de tamaño.
  */
 import { leerMaxBriefChars } from '@panal/sdk';
+import type { Nivel } from '@panal/sdk';
 /** Cuánto vale una firma de descarga: abre toda la entrega, así que poco. */
 export declare const VENTANA_FIRMA_S: number;
 /**
@@ -71,6 +72,18 @@ export interface LimitesDelAgente {
      */
     alcanzable: boolean | null;
     maxBriefChars: number | null;
+    /**
+     * Los niveles que la ficha declara, si declara alguno.
+     *
+     * Salen de la MISMA lectura que el tope del brief: preguntar dos veces por
+     * `agent.json` para sacar dos campos del mismo JSON es una petición de más a
+     * un servidor ajeno cada vez que alguien pide precio.
+     *
+     * De aquí sale solo el TEXTO. El precio que se bloquea es el de la cadena
+     * —ver `nivelesDeAgente` en server.ts—, porque es el único que sigue ahí con
+     * el agente caído y el único que nadie puede cambiar entre mirar y pagar.
+     */
+    niveles: Nivel[];
 }
 export declare function fetchAgentLimits(botUrl: string): Promise<LimitesDelAgente>;
 /** Descarga acotada: se corta en cuanto se pasa del tope. */

package/dist/fetch-result.js

@@ -14,7 +14,7 @@
 // implementaciones equivalentes de lo mismo —la del SDK y una aquí—, y dos
 // copias de un control de seguridad son una que se queda atrás sin que nadie
 // se entere el día que la otra mejora.
-import { assertPublicUrl, leerMaxBriefChars, rutaDeAgente } from '@panal/sdk';
+import { assertPublicUrl, leerMaxBriefChars, leerNiveles, rutaDeAgente } from '@panal/sdk';
 /** Tope de la respuesta. Sin esto, un endpoint hostil tumba el proceso. */
 const MAX_BYTES = 512 * 1024;
 const TIMEOUT_MS = 20_000;
@@ -115,7 +115,7 @@ export async function fetchAgentLimits(botUrl) {
     catch {
         // El guard rechaza la URL: a esa dirección no se le puede entregar nada, ni
         // ahora ni al contratar. Es inalcanzable, no «no lo sé».
-        return { alcanzable: false, maxBriefChars: null };
+        return { alcanzable: false, maxBriefChars: null, niveles: [] };
     }
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
@@ -126,16 +126,17 @@ export async function fetchAgentLimits(botUrl) {
         // Meter el parseo en el catch de la red convertiría un JSON roto en «este
         // agente no existe», que es una acusación distinta y falsa.
         if (!res.ok)
-            return { alcanzable: true, maxBriefChars: null };
+            return { alcanzable: true, maxBriefChars: null, niveles: [] };
         try {
-            return { alcanzable: true, maxBriefChars: parseMaxBriefChars(await res.json()) };
+            const card = await res.json();
+            return { alcanzable: true, maxBriefChars: parseMaxBriefChars(card), niveles: leerNiveles(card) };
         }
         catch {
-            return { alcanzable: true, maxBriefChars: null };
+            return { alcanzable: true, maxBriefChars: null, niveles: [] };
         }
     }
     catch {
-        return { alcanzable: false, maxBriefChars: null };
+        return { alcanzable: false, maxBriefChars: null, niveles: [] };
     }
     finally {
         clearTimeout(timer);

package/dist/limits.d.ts

@@ -39,6 +39,14 @@ export interface Quote {
     /** El encargo TAL Y COMO SE HASHEA: con el manifiesto de adjuntos ya dentro. */
     brief: string;
     amount: bigint;
+    /**
+     * El nivel comprado, si el agente vende niveles.
+     *
+     * Es solo para poder decirlo: quien decide qué nivel es no es este nombre
+     * sino `amount`, que es lo que se bloquea y lo único que el agente mira. Va
+     * en el presupuesto para que al contratar se repita lo mismo que se aprobó.
+     */
+    tier: string | null;
     currency: Address;
     symbol: string;
     botUrl: string | null;

package/dist/niveles.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Panal — los tamaños que vende un agente, para quien contrata desde aquí.
+ *
+ * ───────────────────────────────────────────────────────────────────────────
+ * QUÉ ARREGLA
+ *
+ * Un agente puede vender el mismo trabajo a varios precios, cada uno con su
+ * tope de texto. Este servidor no lo sabía: cotizaba y pagaba siempre el
+ * `pricePerTask` del registro, así que un agente que vende tres tamaños se veía
+ * desde una conversación con un precio suelto, y el encargo grande se
+ * contrataba al precio del pequeño — que el agente rechaza, con el dinero ya
+ * bloqueado y sin más salida que esperar a que venza el plazo.
+ *
+ * DE DÓNDE SALE CADA MITAD. El importe, de la cadena: es lo que se bloquea en
+ * el escrow, es lo único que sigue ahí con el agente caído, y es lo único que
+ * nadie puede cambiar entre que se mira el precio y se paga. El nombre y la
+ * descripción, de la ficha que sirve el agente: es el único sitio donde pueden
+ * estar traducidos, porque la cadena guarda una sola versión.
+ * ───────────────────────────────────────────────────────────────────────────
+ */
+import { type Nivel } from '@panal/sdk';
+/**
+ * Los niveles de un agente: el precio de la CADENA, el texto de su ficha.
+ *
+ * La precedencia no es una preferencia de estilo, es la misma que aplica la
+ * web y por el mismo motivo. El importe es lo que se bloquea en el escrow, así
+ * que tiene que salir del sitio que sigue en pie con el agente caído y que
+ * nadie puede cambiar entre que se mira y se paga. El nombre y la descripción
+ * son una etiqueta, y la ficha es el único sitio donde pueden estar traducidas.
+ *
+ * Si la cadena no trae ninguno, valen los de la ficha: hay agentes que los
+ * declaran solo ahí, y no enseñarlos sería esconder lo que sí venden.
+ */
+export declare function nivelesDeAgente(metadataURI: string | null | undefined, deLaFicha: Nivel[]): Nivel[];
+/** `0.3 MON` a partir del importe de un nivel. */
+export declare function precioDeNivel(nivel: Nivel, symbol: string): string;
+/**
+ * Los niveles, para que un modelo pueda leerlos en voz alta y que se elija uno.
+ *
+ * Se enseñan SIEMPRE que existan, aunque nadie los haya pedido: sin esto un
+ * agente que vende tres tamaños se veía con un precio suelto —el más barato— y
+ * el encargo grande se contrataba al precio del pequeño.
+ */
+export declare function renderNiveles(niveles: Nivel[], symbol: string): string[];
+/**
+ * Los niveles en UNA línea, para las listas.
+ *
+ * En `panal_search_agents` no se puede hacer más: sacar el texto traducido de
+ * cada ficha serían N llamadas HTTP a servidores ajenos por búsqueda, que es
+ * justo lo que ya no se hace para el precio por consulta. Con el rango basta
+ * para que se vea que ahí hay tamaños y se pregunte por la ficha completa.
+ */
+export declare function lineaDeNiveles(niveles: Nivel[], symbol: string): string | null;
+/**
+ * El nivel que pidió quien llama, o `null` si no es ninguno de los que hay.
+ *
+ * Se acepta el nombre, el precio o el número de la lista porque quien escribe
+ * este argumento es un modelo copiando de lo que se le enseñó dos mensajes
+ * antes, y devolver «no existe» por un «0.3 MON» donde se esperaba «Libro»
+ * mandaría a la persona a repetir su elección sin motivo. Lo que NO se hace es
+ * adivinar: si no casa con ninguno, se dice y se listan.
+ */
+export declare function buscarNivel(niveles: Nivel[], pedido: string): Nivel | null;

package/dist/niveles.js

@@ -0,0 +1,107 @@
+/**
+ * Panal — los tamaños que vende un agente, para quien contrata desde aquí.
+ *
+ * ───────────────────────────────────────────────────────────────────────────
+ * QUÉ ARREGLA
+ *
+ * Un agente puede vender el mismo trabajo a varios precios, cada uno con su
+ * tope de texto. Este servidor no lo sabía: cotizaba y pagaba siempre el
+ * `pricePerTask` del registro, así que un agente que vende tres tamaños se veía
+ * desde una conversación con un precio suelto, y el encargo grande se
+ * contrataba al precio del pequeño — que el agente rechaza, con el dinero ya
+ * bloqueado y sin más salida que esperar a que venza el plazo.
+ *
+ * DE DÓNDE SALE CADA MITAD. El importe, de la cadena: es lo que se bloquea en
+ * el escrow, es lo único que sigue ahí con el agente caído, y es lo único que
+ * nadie puede cambiar entre que se mira el precio y se paga. El nombre y la
+ * descripción, de la ficha que sirve el agente: es el único sitio donde pueden
+ * estar traducidos, porque la cadena guarda una sola versión.
+ * ───────────────────────────────────────────────────────────────────────────
+ */
+import { formatEther } from 'viem';
+import { conTextoDeLaFicha, leerNivelesDeMetadata } from '@panal/sdk';
+/**
+ * Los niveles de un agente: el precio de la CADENA, el texto de su ficha.
+ *
+ * La precedencia no es una preferencia de estilo, es la misma que aplica la
+ * web y por el mismo motivo. El importe es lo que se bloquea en el escrow, así
+ * que tiene que salir del sitio que sigue en pie con el agente caído y que
+ * nadie puede cambiar entre que se mira y se paga. El nombre y la descripción
+ * son una etiqueta, y la ficha es el único sitio donde pueden estar traducidas.
+ *
+ * Si la cadena no trae ninguno, valen los de la ficha: hay agentes que los
+ * declaran solo ahí, y no enseñarlos sería esconder lo que sí venden.
+ */
+export function nivelesDeAgente(metadataURI, deLaFicha) {
+    const enCadena = leerNivelesDeMetadata(metadataURI);
+    return enCadena.length > 0 ? conTextoDeLaFicha(enCadena, deLaFicha) : deLaFicha;
+}
+/** `0.3 MON` a partir del importe de un nivel. */
+export function precioDeNivel(nivel, symbol) {
+    return `${formatEther(nivel.wei)} ${symbol}`;
+}
+/**
+ * Los niveles, para que un modelo pueda leerlos en voz alta y que se elija uno.
+ *
+ * Se enseñan SIEMPRE que existan, aunque nadie los haya pedido: sin esto un
+ * agente que vende tres tamaños se veía con un precio suelto —el más barato— y
+ * el encargo grande se contrataba al precio del pequeño.
+ */
+export function renderNiveles(niveles, symbol) {
+    if (niveles.length === 0)
+        return [];
+    return [
+        `  Sizes (${niveles.length}) — pass the one the person picks as \`tier\` to panal_quote_hire:`,
+        ...niveles.map((n) => {
+            const partes = [`    · ${n.name ?? '(unnamed)'} — ${precioDeNivel(n, symbol)}`];
+            if (n.description)
+                partes.push(n.description);
+            if (n.maxBriefChars)
+                partes.push(`up to ${n.maxBriefChars} chars`);
+            return partes.join(' — ');
+        }),
+        '  Without a tier the cheapest one is quoted, which is what hiring without choosing buys.',
+    ];
+}
+/**
+ * Los niveles en UNA línea, para las listas.
+ *
+ * En `panal_search_agents` no se puede hacer más: sacar el texto traducido de
+ * cada ficha serían N llamadas HTTP a servidores ajenos por búsqueda, que es
+ * justo lo que ya no se hace para el precio por consulta. Con el rango basta
+ * para que se vea que ahí hay tamaños y se pregunte por la ficha completa.
+ */
+export function lineaDeNiveles(niveles, symbol) {
+    if (niveles.length === 0)
+        return null;
+    const barato = niveles[0];
+    const caro = niveles[niveles.length - 1];
+    const rango = niveles.length === 1
+        ? precioDeNivel(barato, symbol)
+        : `${formatEther(barato.wei)} to ${precioDeNivel(caro, symbol)}`;
+    return `  Sizes: ${niveles.length} (${rango}) — panal_get_agent lists them`;
+}
+/**
+ * El nivel que pidió quien llama, o `null` si no es ninguno de los que hay.
+ *
+ * Se acepta el nombre, el precio o el número de la lista porque quien escribe
+ * este argumento es un modelo copiando de lo que se le enseñó dos mensajes
+ * antes, y devolver «no existe» por un «0.3 MON» donde se esperaba «Libro»
+ * mandaría a la persona a repetir su elección sin motivo. Lo que NO se hace es
+ * adivinar: si no casa con ninguno, se dice y se listan.
+ */
+export function buscarNivel(niveles, pedido) {
+    const limpio = pedido.trim().toLowerCase().replace(/\s+/g, ' ');
+    if (!limpio)
+        return null;
+    const porNombre = niveles.find((n) => (n.name ?? '').toLowerCase().replace(/\s+/g, ' ') === limpio);
+    if (porNombre)
+        return porNombre;
+    // "0.3", "0.3 mon": el símbolo sobra, el número es la identidad del nivel.
+    const soloNumero = limpio.replace(/[a-z$\s]+$/, '').trim();
+    const porPrecio = niveles.find((n) => formatEther(n.wei) === soloNumero);
+    if (porPrecio)
+        return porPrecio;
+    const i = Number(limpio);
+    return Number.isInteger(i) && i >= 1 && i <= niveles.length ? niveles[i - 1] : null;
+}

package/dist/server.js

@@ -44,6 +44,7 @@ import { formatEther, isAddress, keccak256, parseEther, toBytes } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { NATIVE_CURRENCY, TaskStatus, appendAttachmentsManifest, createPanalClient, downloadDeliveredFile, erc20Abi, matchAttachment, parseAttachmentsManifest, parseFilesManifest, stripFilesManifest, } from '@panal/sdk';
 import { MAX_ADJUNTOS, capacidadesDeAgente, guardarDescarga, leerAdjuntoLocal, raizAdjuntos, raizDescargas, subirAdjunto, } from './adjuntos.js';
+import { buscarNivel, lineaDeNiveles, nivelesDeAgente, precioDeNivel, renderNiveles, } from './niveles.js';
 import { QuoteBook, SpendLedger, limitFor, limitsFromEnv } from './limits.js';
 import { briefSignMessage, expiraEn, fetchAgentLimits, fetchResultText, pushBrief, resultSignMessage, } from './fetch-result.js';
 const SERVER_NAME = 'panal';
@@ -218,7 +219,7 @@ function trustLine(agent) {
     }
     return `  Trust: ${partes.join('; ')}`;
 }
-function renderAgent(agent) {
+function renderAgent(agent, niveles = [], detallado = false) {
     const price = `${formatEther(agent.pricePerTask)} ${symbolOf(agent.currency)}`;
     const skills = agent.metadata.skills.length ? agent.metadata.skills.join(', ') : '(no skills declared)';
     return [
@@ -229,6 +230,10 @@ function renderAgent(agent) {
         // consulta por x402) y llamar "el precio" a uno de ellos fue justo lo que
         // hizo invisible al otro.
         `  Per task: ${price} (escrow, with deadline and dispute window)`,
+        // Los niveles van DEBAJO del precio de tarea y no en su lugar: ese precio
+        // sigue siendo el que se bloquea si nadie elige tamaño, y el que cobran
+        // los agentes —casi todos— que no venden ninguno.
+        ...(detallado ? renderNiveles(niveles, symbolOf(agent.currency)) : [lineaDeNiveles(niveles, symbolOf(agent.currency))]),
         `  Skills: ${skills}`,
         agent.metadata.description ? `  Description: ${agent.metadata.description}` : null,
         agent.metadata.botUrl ? `  Endpoint: ${agent.metadata.botUrl}` : null,
@@ -324,12 +329,16 @@ const READ_TOOLS = [
                     ? `No active agent matches "${str(args.query)}". Try a broader term, or list them all with no query.`
                     : 'There are no active agents on the marketplace right now.';
             }
-            return `${found.length} agent(s):\n\n${found.map(renderAgent).join('\n\n')}`;
+            // Los de la CADENA y sin pedir ninguna ficha: aquí una lectura por agente
+            // serían N peticiones a servidores ajenos por búsqueda.
+            return `${found.length} agent(s):\n\n${found
+                .map((a) => renderAgent(a, nivelesDeAgente(a.metadataURI, [])))
+                .join('\n\n')}`;
         },
     },
     {
         name: 'panal_get_agent',
-        description: 'Full profile of a Panal agent, by address.',
+        description: 'Full profile of a Panal agent, by address: price, the sizes it sells if it sells several, skills, status and its on-chain name.',
         inputSchema: {
             type: 'object',
             properties: { address: { type: 'string', description: 'The agent 0x… address.' } },
@@ -345,15 +354,21 @@ const READ_TOOLS = [
             // razón de que el precio por consulta fuese invisible desde aquí. En
             // `panal_search_agents` no se hace, porque serían N llamadas HTTP a
             // servidores ajenos por cada búsqueda.
-            let porLlamada;
-            try {
-                const q = await panal.quoteAgent(address, 'Price check.');
-                porLlamada = `  Per question: ${formatEther(BigInt(q.amount))} ${q.assetSymbol ?? symbolOf(q.asset)} (x402, answered on the spot)`;
-            }
-            catch {
-                porLlamada = '  Per question: not offered (this agent only takes jobs through escrow)';
-            }
-            return `${renderAgent(agent)}\n${porLlamada}`;
+            // La ficha se lee a la vez que el precio por consulta: son dos peticiones
+            // al MISMO servidor y encadenarlas dobla la espera para nada. De aquí
+            // salen los nombres de los niveles —traducidos, si el agente traduce—;
+            // los importes siguen viniendo de la cadena.
+            const [q, ficha] = await Promise.all([
+                panal.quoteAgent(address, 'Price check.').catch(() => null),
+                agent.metadata.botUrl
+                    ? fetchAgentLimits(agent.metadata.botUrl).catch(() => null)
+                    : Promise.resolve(null),
+            ]);
+            const porLlamada = q
+                ? `  Per question: ${formatEther(BigInt(q.amount))} ${q.assetSymbol ?? symbolOf(q.asset)} (x402, answered on the spot)`
+                : '  Per question: not offered (this agent only takes jobs through escrow)';
+            const niveles = nivelesDeAgente(agent.metadataURI, ficha?.niveles ?? []);
+            return `${renderAgent(agent, niveles, true)}\n${porLlamada}`;
         },
     },
     {
@@ -417,6 +432,9 @@ const READ_TOOLS = [
                 agentName: name,
                 brief: prompt,
                 amount,
+                // Una consulta no compra tamaño: los niveles son del escrow, donde hay
+                // un importe bloqueado del que deducirlos.
+                tier: null,
                 currency: quote.asset,
                 symbol,
                 botUrl: agent.metadata.botUrl,
@@ -456,7 +474,11 @@ const READ_TOOLS = [
                 `Escrow: ${panal.addresses.escrow}`,
                 `Registry: ${panal.addresses.registry}`,
                 '',
-                active.length ? `Active now:\n${active.map(renderAgent).join('\n\n')}` : 'No active agents.',
+                active.length
+                    ? `Active now:\n${active
+                        .map((a) => renderAgent(a, nivelesDeAgente(a.metadataURI, [])))
+                        .join('\n\n')}`
+                    : 'No active agents.',
             ].join('\n');
         },
     },
@@ -526,6 +548,13 @@ const WRITE_TOOLS = [
             properties: {
                 agent: { type: 'string', description: 'The agent 0x… address.' },
                 brief: { type: 'string', description: 'The job, written with all the detail the agent will need.' },
+                tier: {
+                    type: 'string',
+                    description: 'Optional. Which SIZE of the job to buy, for agents that sell several: the tier name as ' +
+                        'panal_get_agent listed it (its price or its position in the list also work). Each tier is a ' +
+                        'different price and a different limit on how long the brief can be. Show the person the list ' +
+                        'and let them pick; without this the cheapest one is quoted.',
+                },
                 files: {
                     type: 'array',
                     items: { type: 'string' },
@@ -584,39 +613,92 @@ const WRITE_TOOLS = [
             // Esto —con el manifiesto dentro— es lo que se hashea y lo que hay que
             // volver a entregar palabra por palabra si el envío falla.
             const brief = appendAttachmentsManifest(briefPedido, adjuntos.map((a) => a.file));
-            const amount = agent.pricePerTask;
             const symbol = symbolOf(agent.currency);
-            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
-            // tarea. Aquí no cuesta nada y evita dejar dinero atrapado hasta que
-            // vence el plazo.
+            // ---- La ficha, una sola vez -----------------------------------------
+            //
+            // De aquí salen tres cosas del mismo JSON: si contesta alguien, cuánto
+            // texto acepta y cómo se llaman sus niveles. Se lee ANTES de mirar el
+            // presupuesto porque el importe ya no es siempre el precio del registro:
+            // con niveles, lo que se bloquea es el del nivel elegido, y comprobar el
+            // tope contra un número que todavía no se sabe no comprueba nada.
+            let limites = { alcanzable: null, maxBriefChars: null, niveles: [] };
             if (agent.metadata.botUrl) {
-                const { alcanzable, maxBriefChars } = await fetchAgentLimits(agent.metadata.botUrl);
+                limites = await fetchAgentLimits(agent.metadata.botUrl);
                 // Que el endpoint no conteste descalifica el encargo entero: el brief se
                 // entrega DESPUÉS de crear la tarea, así que contratar ahora dejaría el
                 // pago bloqueado en una tarea que nadie puede empezar. Aquí no cuesta
                 // nada y basta con reintentar cuando el agente vuelva.
-                if (alcanzable === false) {
+                if (limites.alcanzable === false) {
                     return (`${agent.metadata.name || address} publishes ${agent.metadata.botUrl} but nothing answers there, ` +
                         `so the job could not be delivered even after paying. Nothing was quoted and nothing was spent. ` +
                         `Try again when the agent is back up.`);
                 }
-                if (maxBriefChars !== null && brief.length > maxBriefChars) {
-                    return (`That job does not fit: ${agent.metadata.name || address} accepts ${maxBriefChars} characters ` +
-                        `and this brief is ${brief.length}. Nothing was quoted and nothing was spent. ` +
-                        `Shorten it by ${brief.length - maxBriefChars} characters and ask again.`);
+            }
+            // ---- Qué tamaño se compra -------------------------------------------
+            const niveles = nivelesDeAgente(agent.metadataURI, limites.niveles);
+            const pedido = str(args.tier);
+            let elegido = null;
+            if (niveles.length > 0) {
+                if (pedido) {
+                    elegido = buscarNivel(niveles, pedido);
+                    if (!elegido) {
+                        return [
+                            `${agent.metadata.name || address} does not sell a "${pedido}" size. Nothing was quoted.`,
+                            ...renderNiveles(niveles, symbol),
+                        ].join('\n');
+                    }
+                }
+                else {
+                    // El más barato, que es lo que compra quien contrata sin elegir: su
+                    // precio DEBERÍA ser el del registro, pero es el nivel quien manda —
+                    // si el agente puso el suyo más caro, pagar el del registro sería
+                    // pagar por debajo del mínimo que acepta y que rechazara el encargo
+                    // con el dinero ya bloqueado.
+                    elegido = niveles[0];
                 }
             }
+            else if (pedido) {
+                // Pedir un nivel a quien no vende ninguno casi siempre es haberse
+                // equivocado de agente. Cobrar el precio suelto y callarlo sería
+                // contratar una cosa distinta de la que se pidió.
+                return (`${agent.metadata.name || address} does not sell sizes: it has one price for any job, ` +
+                    `${formatEther(agent.pricePerTask)} ${symbol}. Nothing was quoted. Ask again without \`tier\` ` +
+                    `if that is what you want.`);
+            }
+            const amount = elegido?.wei ?? agent.pricePerTask;
+            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
+            // tarea. Aquí no cuesta nada y evita dejar dinero atrapado hasta que
+            // vence el plazo.
+            // El tope del nivel elegido manda sobre el general de la ficha: un agente
+            // que vende tamaños declara en cada uno cuánto texto acepta, y comprobar
+            // contra el grande dejaría pasar un encargo que el pequeño rechaza.
+            const tope = elegido?.maxBriefChars ?? limites.maxBriefChars;
+            if (tope !== null && brief.length > tope) {
+                // Si hay un tamaño mayor donde SÍ cabe, se dice cuál. La alternativa
+                // es mandar a acortar un texto cuando lo que faltaba era pagar el nivel
+                // que ese texto necesita, que es justo lo que el agente vende.
+                const cabe = niveles.find((n) => (n.maxBriefChars ?? 0) >= brief.length);
+                const dondeSiCabe = cabe && cabe !== elegido
+                    ? ` Its "${cabe.name}" size takes ${cabe.maxBriefChars} for ${precioDeNivel(cabe, symbol)}: ` +
+                        `ask the person if they want that one.`
+                    : '';
+                return (`That job does not fit: ${agent.metadata.name || address}` +
+                    `${elegido ? ` at the "${elegido.name}" size` : ''} accepts ${tope} characters ` +
+                    `and this brief is ${brief.length}. Nothing was quoted and nothing was spent. ` +
+                    `Shorten it by ${brief.length - tope} characters and ask again.${dondeSiCabe}`);
+            }
             const quote = quotes.issue({
                 kind: 'hire',
                 worker: agent.address,
                 agentName: agent.metadata.name || agent.address,
                 brief,
                 amount,
+                tier: elegido?.name ?? null,
                 currency: agent.currency,
                 symbol,
                 botUrl: agent.metadata.botUrl,
@@ -624,7 +706,18 @@ const WRITE_TOOLS = [
             });
             return [
                 `Quote for ${quote.agentName}:`,
-                `  Price: ${formatEther(amount)} ${symbol}`,
+                `  Price: ${formatEther(amount)} ${symbol}${elegido ? ` — size "${elegido.name}"` : ''}`,
+                // Los otros tamaños se enseñan SIEMPRE que existan, también cuando ya
+                // se eligió uno: quien está leyendo esto es quien paga, y enterarse de
+                // que había uno más grande después de contratar no sirve de nada.
+                ...(niveles.length > 1
+                    ? [
+                        `  Other sizes: ${niveles
+                            .filter((n) => n !== elegido)
+                            .map((n) => `${n.name} (${precioDeNivel(n, symbol)})`)
+                            .join(', ')}`,
+                    ]
+                    : []),
                 `  Deadline: ${limits.deadlineHours} h from the moment it is hired`,
                 `  Job: ${briefPedido.length > 200 ? `${briefPedido.slice(0, 200)}…` : briefPedido}`,
                 // Se listan uno a uno, con su ruta real. Lo que se adjunta sale de esta
@@ -760,7 +853,19 @@ const WRITE_TOOLS = [
             }
             const deadline = BigInt(Math.floor(Date.now() / 1000) + limits.deadlineHours * 3600);
             try {
-                const result = await panal.hire({ agent: quote.worker, brief: quote.brief, deadline });
+                // El importe va explícito, y es el del presupuesto. Sin él el SDK
+                // vuelve a leer el `pricePerTask` del registro al contratar, que es
+                // otro número en cuanto el agente vende niveles —se bloquearía el
+                // precio de entrada habiendo aprobado el grande— y que además puede
+                // haber cambiado en los cinco minutos que vive un presupuesto: se
+                // gastaría de más sin que nadie lo hubiera aprobado y por encima del
+                // tope, que se comprobó contra el importe viejo.
+                const result = await panal.hire({
+                    agent: quote.worker,
+                    brief: quote.brief,
+                    amount: quote.amount,
+                    deadline,
+                });
                 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
@@ -821,7 +926,7 @@ const WRITE_TOOLS = [
                 return [
                     `Hired. Task #${result.taskId} created and payment locked in escrow.`,
                     `  Agent: ${quote.agentName}`,
-                    `  Amount: ${formatEther(result.amount)} ${quote.symbol}`,
+                    `  Amount: ${formatEther(result.amount)} ${quote.symbol}${quote.tier ? ` — size "${quote.tier}"` : ''}`,
                     `  tx: ${EXPLORER}/tx/${result.txHash}`,
                     '',
                     entregaBrief,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "panal-mcp",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "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 && tsx test/limites.test.ts && tsx test/monedas.test.ts && tsx test/adjuntos.test.ts",
+    "test": "tsx test/mcp.test.ts && tsx test/limites.test.ts && tsx test/monedas.test.ts && tsx test/adjuntos.test.ts && tsx test/niveles.test.ts",
     "test:adjuntos": "tsx test/adjuntos.test.ts",
     "test:limites": "tsx test/limites.test.ts"
   }