@blockrun/franklin 3.15.53 → 3.15.55

package/dist/agent/loop.js

@@ -288,6 +288,19 @@ function getBackoffDelay(attempt, maxDelayMs = 32_000) {
     const jitter = base * 0.25 * (Math.random() * 2 - 1); // ±25%
     return Math.max(500, Math.round(base + jitter));
 }
+/**
+ * Format the user-facing "switching model" line. Includes the resolved
+ * concrete model in parentheses when the user-facing alias (e.g.
+ * `blockrun/auto`) differs from what was actually being called (e.g.
+ * `anthropic/claude-sonnet-4.6`). Verified 2026-05-04 in a live session:
+ * a payment fail surfaced as `*blockrun/auto failed — switching to
+ * nvidia/qwen3-coder-480b*` with no hint of which concrete model
+ * actually failed, and no hint of why. The reason label closes that gap.
+ */
+function formatModelSwitch(alias, resolved, reason, newModel) {
+    const oldDisplay = alias === resolved ? alias : `${alias} (${resolved})`;
+    return `${oldDisplay} ${reason} — switching to ${newModel}`;
+}
 /**
  * Identify models known to hallucinate tool calls (invented names, literal
  * `[TOOLCALL]` / `<tool_call>` text in answers) — they need the explicit
@@ -1013,8 +1026,9 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                         const oldModel = config.model;
                         config.model = nextModel;
                         config.onModelChange?.(nextModel, 'system');
-                        logger.warn(`[franklin] ${oldModel} returned empty — switching to ${nextModel}`);
-                        onEvent({ kind: 'text_delta', text: `\n*${oldModel} returned empty — switching to ${nextModel}*\n` });
+                        const switchLine = formatModelSwitch(oldModel, resolvedModel, 'returned empty', nextModel);
+                        logger.warn(`[franklin] ${switchLine}`);
+                        onEvent({ kind: 'text_delta', text: `\n*${switchLine}*\n` });
                         continue;
                     }
                     // No fallback available OR already tried 2 models — give up, tell the user.
@@ -1177,7 +1191,11 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                         const oldModel = config.model;
                         config.model = nextFree;
                         config.onModelChange?.(nextFree, 'system');
-                        onEvent({ kind: 'text_delta', text: `\n*${oldModel} failed — switching to ${nextFree}*\n` });
+                        const reason = `failed [${classified.label}]`;
+                        onEvent({
+                            kind: 'text_delta',
+                            text: `\n*${formatModelSwitch(oldModel, resolvedModel, reason, nextFree)}*\n`,
+                        });
                         continue; // Retry with next model
                     }
                 }
@@ -1202,7 +1220,7 @@ export async function interactiveSession(config, getUserInput, onEvent, onAbortR
                         recoveryAttempts = 0;
                         onEvent({
                             kind: 'text_delta',
-                            text: `\n*${oldModel} rate-limited — switching to ${nextFree}*\n`,
+                            text: `\n*${formatModelSwitch(oldModel, resolvedModel, 'rate-limited', nextFree)}*\n`,
                         });
                         continue;
                     }

package/dist/trading/providers/coingecko/client.d.ts

@@ -7,7 +7,26 @@
  */
 import type { ProviderError } from '../standard-models.js';
 export declare const TICKER_TO_ID: Record<string, string>;
+/** For tests + cache invalidation. */
+export declare function clearIdResolutionCache(): void;
+/**
+ * Resolve a ticker to its CoinGecko id. Synchronous — checks the static
+ * map and the dynamic cache. Falls through to lowercase as a final guess.
+ *
+ * Use this from `transformData` (which is sync). Use `resolveProviderIdAsync`
+ * from `fetchData` to populate the cache before the sync read happens.
+ */
 export declare function resolveProviderId(ticker: string): string;
+/**
+ * Like `resolveProviderId`, but on a static-map miss, hits CoinGecko's
+ * `/search?query=` to find the canonical id. Caches the result for 7 days
+ * so `resolveProviderId` (sync) can read it back during `transformData`.
+ *
+ * Why not always async: `transformData` is part of the Fetcher contract
+ * and is intentionally sync. `fetchData` is async, runs first, and is the
+ * right place to do network resolution. The two share state via the cache.
+ */
+export declare function resolveProviderIdAsync(ticker: string): Promise<string>;
 export declare function cached<T>(key: string, ttlMs: number, fn: () => Promise<T>): Promise<T>;
 /** For tests: wipe every cached entry. */
 export declare function clearCache(): void;

package/dist/trading/providers/coingecko/client.js

@@ -11,7 +11,15 @@ const BASE = 'https://api.coingecko.com/api/v3';
 const UA = `franklin/${VERSION} (trading)`;
 const TIMEOUT_MS = 10_000;
 // Ticker → CoinGecko slug. Not exhaustive; unknown tickers fall through to
-// lowercase and let CoinGecko either accept the slug or 404.
+// the dynamic /search resolver below, which caches results.
+//
+// Verified 2026-05-04 in a live session: user asked Franklin for TON price,
+// TradingMarket returned "No CoinGecko data for TON" because TON wasn't in
+// this map and the lowercase fallback ("ton") doesn't match CoinGecko's
+// actual id ("the-open-network"). Same hole exists for any token whose
+// symbol differs from its id slug. Expanded the static map to cover the
+// top ~30 currently-missing tokens, and added a /search-based resolver
+// for everything else.
 export const TICKER_TO_ID = {
     BTC: 'bitcoin', ETH: 'ethereum', SOL: 'solana', BNB: 'binancecoin', XRP: 'ripple',
     ADA: 'cardano', DOGE: 'dogecoin', AVAX: 'avalanche-2', DOT: 'polkadot', MATIC: 'matic-network',
@@ -20,12 +28,87 @@ export const TICKER_TO_ID = {
     FIL: 'filecoin', AAVE: 'aave', MKR: 'maker', SNX: 'synthetix-network-token',
     COMP: 'compound-governance-token', INJ: 'injective-protocol', TIA: 'celestia',
     PEPE: 'pepe', WIF: 'dogwifcoin', RENDER: 'render-token',
+    // ── Added 2026-05-04 after live "No CoinGecko data for TON" report ──
+    TON: 'the-open-network', HYPE: 'hyperliquid', TRX: 'tron', TAO: 'bittensor',
+    WLD: 'worldcoin-wld', ENA: 'ethena', BERA: 'berachain-bera', JUP: 'jupiter-exchange-solana',
+    FET: 'fetch-ai', ONDO: 'ondo-finance', RNDR: 'render-token',
+    USDT: 'tether', USDC: 'usd-coin', DAI: 'dai', BCH: 'bitcoin-cash', ETC: 'ethereum-classic',
+    XLM: 'stellar', XMR: 'monero', IMX: 'immutable-x', GRT: 'the-graph', SAND: 'the-sandbox',
+    MANA: 'decentraland', AXS: 'axie-infinity', KAS: 'kaspa', ICP: 'internet-computer',
+    HBAR: 'hedera-hashgraph', VET: 'vechain', ALGO: 'algorand', FTM: 'fantom',
+    EGLD: 'elrond-erd-2', CRV: 'curve-dao-token', LDO: 'lido-dao', SHIB: 'shiba-inu',
+    BONK: 'bonk', POPCAT: 'popcat', FLOKI: 'floki', PNUT: 'peanut-the-squirrel',
 };
+const ID_RESOLUTION_CACHE = new Map();
+const ID_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+function normalizeTicker(ticker) {
+    return ticker.toUpperCase().replace(/-USD$/, '').replace(/USDT?$/, '');
+}
+/** For tests + cache invalidation. */
+export function clearIdResolutionCache() {
+    ID_RESOLUTION_CACHE.clear();
+}
+/**
+ * Resolve a ticker to its CoinGecko id. Synchronous — checks the static
+ * map and the dynamic cache. Falls through to lowercase as a final guess.
+ *
+ * Use this from `transformData` (which is sync). Use `resolveProviderIdAsync`
+ * from `fetchData` to populate the cache before the sync read happens.
+ */
 export function resolveProviderId(ticker) {
-    // Accept both "BTC" and "BTC-USD" — Pyth-style callers may pass the pair
-    // form even when the registry routes them to CoinGecko.
-    const normalized = ticker.toUpperCase().replace(/-USD$/, '').replace(/USDT?$/, '');
-    return TICKER_TO_ID[normalized] ?? TICKER_TO_ID[ticker.toUpperCase()] ?? normalized.toLowerCase();
+    const normalized = normalizeTicker(ticker);
+    if (TICKER_TO_ID[normalized])
+        return TICKER_TO_ID[normalized];
+    if (TICKER_TO_ID[ticker.toUpperCase()])
+        return TICKER_TO_ID[ticker.toUpperCase()];
+    const cached = ID_RESOLUTION_CACHE.get(normalized);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.id;
+    return normalized.toLowerCase();
+}
+/**
+ * Like `resolveProviderId`, but on a static-map miss, hits CoinGecko's
+ * `/search?query=` to find the canonical id. Caches the result for 7 days
+ * so `resolveProviderId` (sync) can read it back during `transformData`.
+ *
+ * Why not always async: `transformData` is part of the Fetcher contract
+ * and is intentionally sync. `fetchData` is async, runs first, and is the
+ * right place to do network resolution. The two share state via the cache.
+ */
+export async function resolveProviderIdAsync(ticker) {
+    const normalized = normalizeTicker(ticker);
+    // Static map and dynamic cache — fast path.
+    if (TICKER_TO_ID[normalized])
+        return TICKER_TO_ID[normalized];
+    if (TICKER_TO_ID[ticker.toUpperCase()])
+        return TICKER_TO_ID[ticker.toUpperCase()];
+    const cached = ID_RESOLUTION_CACHE.get(normalized);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.id;
+    // Network: ask CoinGecko's search endpoint.
+    try {
+        const result = await coingeckoGet(`/search?query=${encodeURIComponent(normalized)}`);
+        if (result && typeof result === 'object' && !('kind' in result) && 'coins' in result) {
+            const coins = result.coins;
+            if (Array.isArray(coins) && coins.length > 0) {
+                // Prefer an exact symbol match; fall back to the highest-ranked
+                // coin (lowest market_cap_rank value, ignoring null/undefined).
+                const exact = coins.find(c => c.symbol?.toUpperCase() === normalized && typeof c.id === 'string');
+                const fallback = [...coins]
+                    .filter((c) => typeof c.id === 'string')
+                    .sort((a, b) => (a.market_cap_rank ?? Infinity) - (b.market_cap_rank ?? Infinity))[0];
+                const resolved = exact?.id ?? fallback?.id;
+                if (resolved) {
+                    ID_RESOLUTION_CACHE.set(normalized, { id: resolved, expiresAt: Date.now() + ID_TTL_MS });
+                    return resolved;
+                }
+            }
+        }
+    }
+    catch {
+        // /search itself failed — fall through to the lowercase guess.
+    }
+    return normalized.toLowerCase();
 }
 const cache = new Map();
 export async function cached(key, ttlMs, fn) {

package/dist/trading/providers/coingecko/ohlcv.js

@@ -1,4 +1,4 @@
-import { cached, coingeckoGet, resolveProviderId, TTL } from './client.js';
+import { cached, coingeckoGet, resolveProviderIdAsync, TTL } from './client.js';
 export const coingeckoOHLCVFetcher = {
     providerName: 'coingecko',
     transformQuery(input) {
@@ -9,7 +9,7 @@ export const coingeckoOHLCVFetcher = {
         return { ticker, days };
     },
     async fetchData(query) {
-        const id = resolveProviderId(query.ticker);
+        const id = await resolveProviderIdAsync(query.ticker);
         return cached(`ohlcv:${id}:${query.days}`, TTL.ohlcv, async () => {
             return coingeckoGet(`/coins/${id}/market_chart?vs_currency=usd&days=${query.days}&interval=daily`);
         });

package/dist/trading/providers/coingecko/price.js

@@ -6,7 +6,7 @@
  * Coerces: the nested `{ [id]: { usd: ..., usd_24h_change: ... } }`
  *          response into the standard PriceData shape.
  */
-import { cached, coingeckoGet, resolveProviderId, TTL } from './client.js';
+import { cached, coingeckoGet, resolveProviderId, resolveProviderIdAsync, TTL } from './client.js';
 export const coingeckoPriceFetcher = {
     providerName: 'coingecko',
     transformQuery(input) {
@@ -17,7 +17,10 @@ export const coingeckoPriceFetcher = {
         return { ticker };
     },
     async fetchData(query) {
-        const id = resolveProviderId(query.ticker);
+        // resolveProviderIdAsync warms the dynamic id cache via /search when the
+        // ticker isn't in the static map (e.g. TON → the-open-network).
+        // transformData below reads back from the same cache synchronously.
+        const id = await resolveProviderIdAsync(query.ticker);
         return cached(`price:${id}`, TTL.price, async () => {
             return coingeckoGet(`/simple/price?ids=${id}` +
                 `&vs_currencies=usd&include_24hr_change=true` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/franklin",
-  "version": "3.15.53",
+  "version": "3.15.55",
   "description": "Franklin — The AI agent with a wallet. Spends USDC autonomously to get real work done. Pay per action, no subscriptions.",
   "type": "module",
   "exports": {