@panal/sdk 0.12.0 → 0.14.0

package/dist/agent-card.d.ts

@@ -68,6 +68,36 @@ export interface FichaGetResult {
  * el del bot sí— y un esquema que obligue a rellenar lo que no se sabe termina
  * rellenándose con mentiras.
  */
+/**
+ * Un nivel de servicio: cuánto cobra y cuánto acepta a cambio.
+ *
+ * El registro guarda UN `pricePerTask` por agente y no va a guardar más, así
+ * que este es el único sitio donde un agente puede anunciar que hace el mismo
+ * trabajo en varios tamaños. Lo publica quien lo va a cumplir, que es la
+ * diferencia entre un nivel y un multiplicador inventado por el escaparate.
+ *
+ * Los topes se declaran EN CARACTERES a propósito. Son lo que el cliente puede
+ * contar antes de pagar y lo que cualquiera puede recontar después, porque el
+ * encargo se ancla en la cadena y el tamaño de cada adjunto viaja dentro de su
+ * manifiesto. Un nivel que prometiera «más esfuerzo» no se podría comprobar.
+ */
+export interface FichaNivel {
+    /** Nombre corto para enseñar. El cliente elige por aquí. */
+    name?: string;
+    /** Una línea de qué compra. */
+    description?: string;
+    /**
+     * Lo que hay que bloquear para tener este nivel, en unidades mínimas de la
+     * moneda del agente y como cadena decimal, igual que `price.amountWei`.
+     */
+    amountWei?: string;
+    /** Tope de caracteres del encargo en este nivel. */
+    maxBriefChars?: number;
+    /** Tope de caracteres que aporta CADA adjunto. */
+    maxAttachChars?: number;
+    /** Y el de todos los adjuntos juntos. */
+    maxAttachCharsTotal?: number;
+}
 export interface AgentCard {
     /** La dirección on-chain que este dominio declara suya. Es lo que verifica. */
     agent?: Address;
@@ -84,6 +114,16 @@ export interface AgentCard {
         currency?: Address;
         symbol?: string;
     } | null;
+    /**
+     * Los niveles que ofrece, de menor a mayor. Opcional y casi siempre ausente.
+     *
+     * AUSENTE NO ES «tiene un nivel»: es que este agente no los ofrece, y hay
+     * que tratarlo exactamente como se le trataba antes de que esto existiera.
+     * Quien lee no debe inventarle niveles a partir de `price`, que es
+     * justamente lo que hacía el escaparate y por lo que enseñaba precios que
+     * luego no se cobraban.
+     */
+    tiers?: FichaNivel[];
     active?: boolean | null;
     contracts?: {
         escrow?: Address;
@@ -119,3 +159,41 @@ export declare function leerX402(card: unknown): FichaX402 | null;
  * basura en un campo.
  */
 export declare function leerMaxBriefChars(card: unknown): number | null;
+/** Un nivel ya validado: precio en bigint y `null` en todo lo que la ficha no diga. */
+export interface Nivel {
+    name: string | null;
+    description: string | null;
+    /** Lo que hay que bloquear, en unidades mínimas de la moneda del agente. */
+    wei: bigint;
+    maxBriefChars: number | null;
+    maxAttachChars: number | null;
+    maxAttachCharsTotal: number | null;
+}
+/**
+ * Los niveles que ofrece un agente, de menor a mayor precio.
+ *
+ * Devuelve `[]` cuando la ficha no los declara, y eso significa que el agente
+ * NO ofrece niveles: quien llama tiene que seguir tratándolo como siempre, no
+ * fabricarle uno a partir de `price`.
+ *
+ * La ficha la sirve un desconocido, así que un nivel sin precio legible se cae
+ * de la lista en vez de tumbarla entera: un campo mal escrito no puede dejar
+ * incontratable a un agente que sí tiene otros niveles buenos.
+ */
+export declare function leerNiveles(card: unknown): Nivel[];
+/**
+ * Qué nivel compró quien bloqueó `pagado`.
+ *
+ * EL NIVEL LO DECIDE LA CADENA, NO EL ENCARGO. El brief lo escribe el cliente
+ * y podría afirmar que compró el más caro; el importe bloqueado no se puede
+ * discutir. Por eso esta función toma un `bigint` del escrow y nada más.
+ *
+ * Se queda con el nivel más alto que quepa en lo pagado. Pagar de más da el
+ * nivel pagado, no el siguiente: quien bloquea 10 veces el precio del mayor
+ * sigue comprando el mayor, y el resto es cosa del agente y su cliente.
+ *
+ * `null` significa que lo bloqueado no llega ni al nivel más barato. Qué hacer
+ * entonces —trabajar igual, devolver, no empezar— lo decide el agente; el SDK
+ * no lo va a decidir por él.
+ */
+export declare function nivelPara(niveles: Nivel[], pagado: bigint): Nivel | null;

package/dist/agent-card.js

@@ -52,3 +52,92 @@ export function leerMaxBriefChars(card) {
     const max = card?.endpoints?.postBrief?.maxBriefChars;
     return typeof max === 'number' && Number.isInteger(max) && max > 0 ? max : null;
 }
+/** Tope de niveles que se leen de una ficha ajena. Ocho ya son demasiados para elegir. */
+const MAX_NIVELES = 8;
+/**
+ * Cuántas entradas se miran para sacar esos ocho.
+ *
+ * El recorte va DESPUÉS de filtrar, no antes: recortando primero, un nivel
+ * bueno colocado detrás de ocho mal escritos desaparecía sin que nadie lo
+ * notara. Y aun así se mira un número fijo, porque la lista la escribe un
+ * desconocido y nadie tiene ocho niveles buenos detrás de doscientos malos.
+ */
+const MAX_MIRADOS = 200;
+/** Un entero positivo, o `null`. Misma regla que `leerMaxBriefChars`. */
+function tope(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : null;
+}
+/** Texto de una ficha ajena: recortado, porque va a un escaparate. */
+function letrero(v, max) {
+    if (typeof v !== 'string')
+        return null;
+    const limpio = v.replace(/\s+/g, ' ').trim().slice(0, max);
+    return limpio || null;
+}
+/**
+ * Los niveles que ofrece un agente, de menor a mayor precio.
+ *
+ * Devuelve `[]` cuando la ficha no los declara, y eso significa que el agente
+ * NO ofrece niveles: quien llama tiene que seguir tratándolo como siempre, no
+ * fabricarle uno a partir de `price`.
+ *
+ * La ficha la sirve un desconocido, así que un nivel sin precio legible se cae
+ * de la lista en vez de tumbarla entera: un campo mal escrito no puede dejar
+ * incontratable a un agente que sí tiene otros niveles buenos.
+ */
+export function leerNiveles(card) {
+    const crudos = card?.tiers;
+    if (!Array.isArray(crudos))
+        return [];
+    const out = [];
+    for (const n of crudos.slice(0, MAX_MIRADOS)) {
+        if (out.length >= MAX_NIVELES)
+            break;
+        if (!n || typeof n !== 'object')
+            continue;
+        const wei = enteroWei(n.amountWei);
+        if (wei === null)
+            continue;
+        out.push({
+            name: letrero(n.name, 60),
+            description: letrero(n.description, 200),
+            wei,
+            maxBriefChars: tope(n.maxBriefChars),
+            maxAttachChars: tope(n.maxAttachChars),
+            maxAttachCharsTotal: tope(n.maxAttachCharsTotal),
+        });
+    }
+    // De menor a mayor: es el orden en que se enseñan y el que hace que
+    // `nivelPara` pueda quedarse con el último que entra en lo pagado.
+    return out.sort((a, b) => (a.wei < b.wei ? -1 : a.wei > b.wei ? 1 : 0));
+}
+/** `amountWei` como bigint. Solo dígitos: `BigInt('0x10')` valdría 16 y no es eso. */
+function enteroWei(v) {
+    if (typeof v !== 'string' || !/^\d+$/.test(v.trim()))
+        return null;
+    const n = BigInt(v.trim());
+    return n > 0n ? n : null;
+}
+/**
+ * Qué nivel compró quien bloqueó `pagado`.
+ *
+ * EL NIVEL LO DECIDE LA CADENA, NO EL ENCARGO. El brief lo escribe el cliente
+ * y podría afirmar que compró el más caro; el importe bloqueado no se puede
+ * discutir. Por eso esta función toma un `bigint` del escrow y nada más.
+ *
+ * Se queda con el nivel más alto que quepa en lo pagado. Pagar de más da el
+ * nivel pagado, no el siguiente: quien bloquea 10 veces el precio del mayor
+ * sigue comprando el mayor, y el resto es cosa del agente y su cliente.
+ *
+ * `null` significa que lo bloqueado no llega ni al nivel más barato. Qué hacer
+ * entonces —trabajar igual, devolver, no empezar— lo decide el agente; el SDK
+ * no lo va a decidir por él.
+ */
+export function nivelPara(niveles, pagado) {
+    let elegido = null;
+    for (const n of niveles) {
+        if (n.wei <= pagado)
+            elegido = n;
+    }
+    return elegido;
+}

package/dist/client.d.ts

@@ -90,6 +90,18 @@ export interface HireResult {
  * búsqueda y no cambia nada.
  */
 export declare function variantesDeSkill(skill: string): string[];
+/**
+ * Las variantes que se pueden buscar de verdad, dada la lista de permitidas.
+ *
+ * Va aparte y exportada porque es LA regla que impide que un agente de código
+ * acabe pagando a uno de vídeo. Sin lista devuelve todas, que es como se
+ * comportaba esto antes de que la lista existiera.
+ *
+ * La comparación normaliza espacios y mayúsculas: la lista la escribe una
+ * persona en su `agent.ts` y la skill la escribe un modelo, y no van a coincidir
+ * en el formato.
+ */
+export declare function variantesPermitidas(skill: string, permitidas?: string[]): string[];
 export declare class PanalClient {
     readonly network: PanalNetwork;
     readonly addresses: PanalAddresses;
@@ -313,6 +325,20 @@ export declare class PanalClient {
         envelope?: CallEnvelope | null;
         /** Saltos permitidos al abrir una cadena nueva. */
         depth?: number;
+        /**
+         * LAS ÚNICAS SKILLS QUE SE PUEDEN COMPRAR. Sin esto, cualquiera.
+         *
+         * Existe por la degradación de aquí abajo. Quien pide la skill suele ser
+         * un modelo, y al no encontrar a nadie se recorta por la izquierda:
+         * "python video encoding" acaba buscando "video". Para un agente de
+         * código eso es contratar a un agente de vídeo con su dinero, y lo peor
+         * es que el resultado parece razonable — pagó, le contestaron, entregó.
+         *
+         * Con esta lista, una variante que no esté en ella NI SE BUSCA. La
+         * comprobación va antes de cotizar, así que un intento prohibido no
+         * cuesta ni una petición.
+         */
+        skillsPermitidas?: string[];
     }): Promise<AskResult & {
         agent: Address;
         skill: string;

package/dist/client.js

@@ -63,6 +63,21 @@ export function variantesDeSkill(skill) {
     }
     return out;
 }
+/**
+ * Las variantes que se pueden buscar de verdad, dada la lista de permitidas.
+ *
+ * Va aparte y exportada porque es LA regla que impide que un agente de código
+ * acabe pagando a uno de vídeo. Sin lista devuelve todas, que es como se
+ * comportaba esto antes de que la lista existiera.
+ *
+ * La comparación normaliza espacios y mayúsculas: la lista la escribe una
+ * persona en su `agent.ts` y la skill la escribe un modelo, y no van a coincidir
+ * en el formato.
+ */
+export function variantesPermitidas(skill, permitidas) {
+    const blancas = permitidas?.map((p) => p.trim().replace(/\s+/g, ' ').toLowerCase()).filter(Boolean);
+    return variantesDeSkill(skill).filter((v) => !blancas || blancas.includes(v.replace(/\s+/g, ' ').toLowerCase()));
+}
 function esNombre(v) {
     if (v === null || typeof v !== 'object')
         return false;
@@ -188,11 +203,16 @@ export class PanalClient {
                 catch {
                     continue;
                 }
+                // La ficha en crudo, si el indexador la manda. Los enlaces del creador
+                // salen de ahí, y quedarse con ella entera es además más fiel que
+                // recomponerla: lo que este SDK no entienda se conserva tal cual.
+                const uri = typeof raw.metadataURI === 'string' ? raw.metadataURI : '';
                 const metadata = {
                     name: typeof raw.name === 'string' ? raw.name : '',
                     description: typeof raw.description === 'string' ? raw.description : '',
                     skills,
                     botUrl: typeof raw.botUrl === 'string' ? raw.botUrl : null,
+                    links: parseAgentMetadata(uri).links,
                 };
                 out.push({
                     address: getAddress(address),
@@ -201,7 +221,7 @@ export class PanalClient {
                     currency: getAddress(typeof raw.currency === 'string' && /^0x[0-9a-fA-F]{40}$/.test(raw.currency) ? raw.currency : NATIVE_CURRENCY),
                     active: raw.active !== false,
                     registeredAt,
-                    metadataURI: formatAgentMetadata(metadata),
+                    metadataURI: uri || formatAgentMetadata(metadata),
                     metadata,
                     // Solo `true` cuenta como verificado. Un indexador viejo no manda el
                     // campo, y tratar «no lo sé» como «sí» es justo al revés de lo que
@@ -681,9 +701,18 @@ export class PanalClient {
         // núcleo va al final: "Spanish tax law" → "tax law" → "law". Así se
         // generaliza sin perder de qué se estaba hablando; recortar por la derecha
         // dejaría "Spanish", que casaría con cualquier cosa española.
+        // Las variantes que este agente tiene permitido comprar. Sin lista, todas.
+        const permitidas = options.skillsPermitidas;
+        const variantes = variantesPermitidas(skill, permitidas);
+        if (!variantes.length) {
+            throw new X402Error(`Este agente no tiene permitido subcontratar "${skill}". ` +
+                (permitidas?.length
+                    ? `Sólo puede comprar: ${permitidas.join(', ')}.`
+                    : 'No tiene ninguna skill permitida.'));
+        }
         let candidates = [];
         let usada = skill;
-        for (const intento of variantesDeSkill(skill)) {
+        for (const intento of variantes) {
             candidates = (await this.searchAgents(intento, { skill: intento }))
                 .filter((a) => !excluded.has(a.address.toLowerCase()) && a.metadata.botUrl)
                 .slice(0, options.maxCandidates ?? 5);

package/dist/index.d.ts

@@ -23,8 +23,8 @@ export { PanalClient, createPanalClient } from './client.js';
 export type { PanalClientOptions, HireParams, HireResult } from './client.js';
 export { monad, monadTestnet, addressesFor, chainFor, MAINNET_ADDRESSES, TESTNET_ADDRESSES, NATIVE_CURRENCY, FEE_BPS, AUTO_RELEASE_SECONDS, DISPUTE_TIMEOUT_SECONDS, } from './chains.js';
 export type { PanalNetwork, PanalAddresses } from './chains.js';
-export { TaskStatus, TASK_STATUS_LABEL, formatAgentMetadata, parseAgentMetadata, } from './types.js';
-export type { Agent, AgentMetadata, Task } from './types.js';
+export { TaskStatus, TASK_STATUS_LABEL, formatAgentMetadata, normalizeAgentLink, parseAgentMetadata, AGENT_LINK_KEYS, } from './types.js';
+export type { Agent, AgentLinkKey, AgentLinks, AgentMetadata, Task } from './types.js';
 export { erc20Abi, escrowAbi, registryAbi } from './abis.js';
 export { X402_SCHEME, X402Error, payAndAsk, quoteAsk } from './x402.js';
 export type { AskResult, PayAndAskOptions, PermitDomain, X402Accept, X402Quote } from './x402.js';
@@ -38,5 +38,5 @@ export type { SettleDeps, SettleResult, X402Payment, X402ServerAccept, X402Serve
 export { ENVELOPE_HEADERS, DEFAULT_DEPTH, MAX_DEPTH, BudgetExhausted, DepthExhausted, LoopDetected, assertCanServe, descend, envelopeHeaders, newEnvelope, parseEnvelope, remainingBudget, } from './envelope.js';
 export type { CallEnvelope } from './envelope.js';
 export type { UrlGuardOptions } from './net.js';
-export { leerDireccion, leerMaxBriefChars, leerX402 } from './agent-card.js';
-export type { AgentCard, FichaGetResult, FichaPostBrief, FichaX402 } from './agent-card.js';
+export { leerDireccion, leerMaxBriefChars, leerNiveles, leerX402, nivelPara } from './agent-card.js';
+export type { AgentCard, FichaGetResult, FichaNivel, FichaPostBrief, FichaX402, Nivel } from './agent-card.js';

package/dist/index.js

@@ -21,7 +21,7 @@
  */
 export { PanalClient, createPanalClient } from './client.js';
 export { monad, monadTestnet, addressesFor, chainFor, MAINNET_ADDRESSES, TESTNET_ADDRESSES, NATIVE_CURRENCY, FEE_BPS, AUTO_RELEASE_SECONDS, DISPUTE_TIMEOUT_SECONDS, } from './chains.js';
-export { TaskStatus, TASK_STATUS_LABEL, formatAgentMetadata, parseAgentMetadata, } from './types.js';
+export { TaskStatus, TASK_STATUS_LABEL, formatAgentMetadata, normalizeAgentLink, parseAgentMetadata, AGENT_LINK_KEYS, } from './types.js';
 export { erc20Abi, escrowAbi, registryAbi } from './abis.js';
 // x402: pagar a otro agente por una consulta, sin escrow y sin humano.
 export { X402_SCHEME, X402Error, payAndAsk, quoteAsk } from './x402.js';
@@ -39,4 +39,4 @@ export { X402_VERSION, X402_SERVER_SCHEME, buildQuote, enqueueByPayer, parsePaym
 export { ENVELOPE_HEADERS, DEFAULT_DEPTH, MAX_DEPTH, BudgetExhausted, DepthExhausted, LoopDetected, assertCanServe, descend, envelopeHeaders, newEnvelope, parseEnvelope, remainingBudget, } from './envelope.js';
 // La ficha de GET /agent.json: un solo formato, y lectores que perdonan el
 // antiguo. En agent-card.ts está por qué llegó a haber dos.
-export { leerDireccion, leerMaxBriefChars, leerX402 } from './agent-card.js';
+export { leerDireccion, leerMaxBriefChars, leerNiveles, leerX402, nivelPara } from './agent-card.js';

package/dist/llm.js

@@ -42,8 +42,18 @@ export const PROVEEDORES = {
         dialecto: 'gemini',
         modeloSugerido: 'gemini-2.0-flash',
     },
-    kimi: { baseUrl: 'https://api.moonshot.ai/v1', dialecto: 'openai', modeloSugerido: 'moonshot-v1-8k' },
-    moonshot: { baseUrl: 'https://api.moonshot.ai/v1', dialecto: 'openai', modeloSugerido: 'moonshot-v1-8k' },
+    // `moonshot-v1-8k` era la sugerencia y es de la generación anterior: medido
+    // contra la API en agosto de 2026, es además el único de la lista que
+    // devolvía 429 por límite de cuota. Quien escribía `LLM_PROVIDER=kimi` sin
+    // más se llevaba el peor modelo disponible.
+    //
+    // `kimi-k2.6` es de propósito general y cabe de sobra en el timeout por
+    // defecto. `kimi-k3` responde mejor y tarda bastante más —medido: entre 40 s
+    // y 114 s en encargos normales, contra un timeout de 120 s—, así que se
+    // elige a mano con LLM_MODEL y no por defecto. Los `kimi-k2.7-code` son los
+    // rápidos, y para código.
+    kimi: { baseUrl: 'https://api.moonshot.ai/v1', dialecto: 'openai', modeloSugerido: 'kimi-k2.6' },
+    moonshot: { baseUrl: 'https://api.moonshot.ai/v1', dialecto: 'openai', modeloSugerido: 'kimi-k2.6' },
     grok: { baseUrl: 'https://api.x.ai/v1', dialecto: 'openai', modeloSugerido: 'grok-2-vision-1212' },
     xai: { baseUrl: 'https://api.x.ai/v1', dialecto: 'openai', modeloSugerido: 'grok-2-vision-1212' },
     glm: { baseUrl: 'https://open.bigmodel.cn/api/paas/v4', dialecto: 'openai', modeloSugerido: 'glm-4v' },

package/dist/types.d.ts

@@ -39,7 +39,33 @@ export interface AgentMetadata {
      * se entrega por otros medios y en la cadena solo queda su hash.
      */
     botUrl: string | null;
+    /**
+     * El logo y los enlaces del creador, si los publicó. Todo opcional.
+     *
+     * Van en la misma cadena, como tokens `clave:valor`:
+     *
+     *     "Lint · Revisa contratos · solidity · logo:https://lint.dev/l.png · github:lintlabs"
+     *
+     * Se leen aparte por lo mismo que `bot:`: sin apartarlos, el `logo:` de un
+     * agente saldría de skill suya. Un token solo cuenta si su valor vale —una
+     * `https://` de verdad, o un usuario con forma de usuario—, porque la
+     * descripción es texto libre y alguien va a escribir «web: la mejor» dentro.
+     */
+    links: AgentLinks;
 }
+/** Las claves de marca que entiende el marketplace, en el orden en que se pintan. */
+export declare const AGENT_LINK_KEYS: readonly ["logo", "web", "github", "x", "telegram"];
+export type AgentLinkKey = (typeof AGENT_LINK_KEYS)[number];
+/** Cadena vacía = el agente no lo publicó. */
+export type AgentLinks = Record<AgentLinkKey, string>;
+/**
+ * Deja un valor de marca como se guarda, o vacío si no sirve.
+ *
+ * Acepta las tres formas que la gente usa de verdad —`@panal`, `panal` y
+ * `https://x.com/panal`— y guarda siempre la misma. La referencia es
+ * `src/lib/marca.ts` del marketplace: si cambias una, cambia la otra.
+ */
+export declare function normalizeAgentLink(key: AgentLinkKey, raw: string): string;
 /** Un agente del registry, con su metadata ya interpretada. */
 export interface Agent {
     /** La dirección del agente: la que ejecuta el trabajo y cobra. */
@@ -119,7 +145,9 @@ export interface Task {
  * descripción desplazaría las skills a otro segmento y dejaría la ficha del
  * agente descuadrada sin ningún error visible.
  */
-export declare function formatAgentMetadata(meta: AgentMetadata): string;
+export declare function formatAgentMetadata(meta: Omit<AgentMetadata, 'links'> & {
+    links?: Partial<AgentLinks>;
+}): string;
 /**
  * Lee el metadata de un agente. Nunca lanza: un agente puede haberse registrado
  * con cualquier cadena, y un marketplace que se rompe por una ficha mal escrita

package/dist/types.js

@@ -23,6 +23,71 @@ export const TASK_STATUS_LABEL = {
     [TaskStatus.Disputed]: 'disputed',
     [TaskStatus.Cancelled]: 'cancelled',
 };
+/** Las claves de marca que entiende el marketplace, en el orden en que se pintan. */
+export const AGENT_LINK_KEYS = ['logo', 'web', 'github', 'x', 'telegram'];
+const NO_LINKS = { logo: '', web: '', github: '', x: '', telegram: '' };
+/**
+ * Deja un valor de marca como se guarda, o vacío si no sirve.
+ *
+ * Acepta las tres formas que la gente usa de verdad —`@panal`, `panal` y
+ * `https://x.com/panal`— y guarda siempre la misma. La referencia es
+ * `src/lib/marca.ts` del marketplace: si cambias una, cambia la otra.
+ */
+export function normalizeAgentLink(key, raw) {
+    const value = raw.trim().slice(0, 120);
+    if (!value)
+        return '';
+    // Un espacio o un `·` por dentro invalida en vez de borrarse: borrarlos
+    // convertiría «dos palabras» en el usuario `dospalabras`, que es de otro.
+    if (/[\u00b7\s]/.test(value))
+        return '';
+    if (key === 'logo' || key === 'web') {
+        try {
+            const u = new URL(value);
+            return u.protocol === 'https:' && u.hostname.includes('.') ? value : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    const hosts = {
+        github: /^(www\.)?github\.com$/i,
+        x: /^(www\.)?(x|twitter)\.com$/i,
+        telegram: /^(www\.)?(t\.me|telegram\.me)$/i,
+    };
+    let user = value.replace(/^@/, '');
+    if (/^https?:\/\//i.test(user)) {
+        try {
+            const u = new URL(user);
+            if (!hosts[key].test(u.hostname))
+                return '';
+            user = u.pathname.replace(/^\/+|\/+$/g, '');
+        }
+        catch {
+            return '';
+        }
+    }
+    user = user.replace(/^@/, '');
+    if (!user)
+        return '';
+    const simple = /^[A-Za-z0-9][A-Za-z0-9._-]{0,38}$/;
+    if (key === 'github')
+        return simple.test(user) || /^[A-Za-z0-9][A-Za-z0-9-]{0,38}\/[A-Za-z0-9._-]{1,100}$/.test(user) ? user : '';
+    if (key === 'telegram')
+        return simple.test(user) || /^\+[A-Za-z0-9_-]{5,64}$/.test(user) ? user : '';
+    return simple.test(user) ? user : '';
+}
+/** `github:panal/lint` → la pareja, o null si no es un token de marca válido. */
+function parseLinkToken(segment) {
+    const i = segment.indexOf(':');
+    if (i <= 0)
+        return null;
+    const key = segment.slice(0, i).trim().toLowerCase();
+    if (!AGENT_LINK_KEYS.includes(key))
+        return null;
+    const value = normalizeAgentLink(key, segment.slice(i + 1));
+    return value ? [key, value] : null;
+}
 /**
  * Compone el metadata en el formato que espera el marketplace.
  *
@@ -35,6 +100,13 @@ export function formatAgentMetadata(meta) {
     const parts = [clean(meta.name), clean(meta.description), meta.skills.map(clean).join(', ')];
     if (meta.botUrl)
         parts.push(`bot:${meta.botUrl.trim()}`);
+    // La marca al final: primero lo que el protocolo necesita, luego lo que el
+    // creador quiere enseñar. Sin enlaces sale exactamente la ficha de siempre.
+    for (const key of AGENT_LINK_KEYS) {
+        const value = normalizeAgentLink(key, meta.links?.[key] ?? '');
+        if (value)
+            parts.push(`${key}:${value}`);
+    }
     return parts.join(' · ');
 }
 /**
@@ -48,6 +120,7 @@ export function parseAgentMetadata(metadataURI) {
         .map((s) => s.trim())
         .filter(Boolean);
     let botUrl = null;
+    const links = { ...NO_LINKS };
     const rest = [];
     for (const seg of segments) {
         const candidate = seg.toLowerCase().startsWith('bot:') ? seg.slice(4).trim() : null;
@@ -55,6 +128,14 @@ export function parseAgentMetadata(metadataURI) {
             botUrl = candidate;
             continue;
         }
+        const link = parseLinkToken(seg);
+        // El primero manda: una ficha con dos `logo:` no puede quedar a merced del
+        // orden en que se lean.
+        if (link) {
+            if (!links[link[0]])
+                links[link[0]] = link[1];
+            continue;
+        }
         rest.push(seg);
     }
     // Los campos que falten quedan vacíos en vez de desplazar a los siguientes:
@@ -68,5 +149,6 @@ export function parseAgentMetadata(metadataURI) {
             .map((s) => s.trim())
             .filter(Boolean),
         botUrl,
+        links,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@panal/sdk",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "SDK de Panal: contrata agentes de IA autonomos on-chain en Monad",
   "type": "module",
   "license": "MIT",