@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/api/binance-skill-helpers.js

@@ -0,0 +1,745 @@
+/**
+ * Binance direct-skill request helpers.
+ *
+ * Extracted from server.ts. Handles direct dispatch of Binance DeFi skills
+ * (meme-rush, trading-signal, token-info, etc.) and fallback action parsing.
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { ModelType, } from "@elizaos/core";
+import { extractCompatTextContent } from "./compat-utils.js";
+const EXPOSED_BINANCE_SKILL_IDS = new Set([
+    "binance-crypto-market-rank",
+    "binance-meme-rush",
+    "binance-query-address-info",
+    "binance-query-token-audit",
+    "binance-query-token-info",
+    "binance-trading-signal",
+]);
+function shouldExposeBinanceSkillId(skillId) {
+    const normalized = skillId.trim();
+    if (!normalized.startsWith("binance-"))
+        return true;
+    return EXPOSED_BINANCE_SKILL_IDS.has(normalized);
+}
+const LIFEOPS_PUBLIC_MODULE = "@elizaos/app-lifeops";
+let ownerWebsiteBlockFallbackPromise = null;
+async function resolveBuiltInFallbackAction(actionName) {
+    if (actionName !== "WEBSITE_BLOCK") {
+        return null;
+    }
+    if (!ownerWebsiteBlockFallbackPromise) {
+        ownerWebsiteBlockFallbackPromise = import(__rewriteRelativeImportExtension(
+        /* @vite-ignore */ LIFEOPS_PUBLIC_MODULE))
+            .then((mod) => mod)
+            .then((mod) => mod.websiteBlockAction ?? null)
+            .catch(() => null);
+    }
+    return ownerWebsiteBlockFallbackPromise;
+}
+export function inferBalanceChainFromText(input) {
+    const normalized = input.toLowerCase();
+    if (/\bsol(?:ana)?\b/.test(normalized))
+        return "solana";
+    if (/\b(bsc|bnb|binance)\b/.test(normalized))
+        return "bsc";
+    if (/\bbase\b/.test(normalized))
+        return "base";
+    if (/\b(eth|ethereum)\b/.test(normalized))
+        return "ethereum";
+    return "all";
+}
+export function shouldForceCheckBalanceFallback(parsedActions, userText, responseText) {
+    const nonReplyActions = parsedActions.filter((a) => a.name !== "REPLY" && a.name !== "NONE" && a.name !== "IGNORE");
+    if (nonReplyActions.length > 0)
+        return false;
+    const combined = `${userText}\n${responseText}`.toLowerCase();
+    const balanceIntent = /\b(balance|wallet|holdings|portfolio|funds|how much)\b/.test(combined) ||
+        /\b(check(ing)?|look(ing)? up|fetch(ing)?)\b/.test(combined);
+    return balanceIntent;
+}
+export function isBalanceIntent(input) {
+    const normalized = input.toLowerCase();
+    return /\b(balance|wallet|holdings|portfolio|funds|how much)\b/.test(normalized);
+}
+export function parseFallbackActionBlocks(value, _responseText) {
+    const rawValues = [];
+    if (typeof value === "string") {
+        rawValues.push(value);
+    }
+    else if (Array.isArray(value)) {
+        for (const entry of value) {
+            if (typeof entry === "string" && entry.trim().length > 0) {
+                rawValues.push(entry);
+            }
+        }
+    }
+    const parsed = [];
+    for (const raw of rawValues) {
+        const normalized = raw.trim().toUpperCase();
+        if (/^[A-Z0-9_]+$/.test(normalized)) {
+            parsed.push({ name: normalized, parameters: {} });
+        }
+    }
+    return parsed;
+}
+export async function executeFallbackParsedActions(runtime, message, parsedActions, appendIncomingText, onActionCallback, options) {
+    const runtimeActions = Array.isArray(runtime.actions)
+        ? runtime.actions
+        : [];
+    const lookup = new Map();
+    for (const action of runtimeActions) {
+        if (typeof action.name === "string")
+            lookup.set(action.name.toUpperCase(), action);
+        if (!Array.isArray(action.similes))
+            continue;
+        for (const alias of action.similes) {
+            if (typeof alias === "string")
+                lookup.set(alias.toUpperCase(), action);
+        }
+    }
+    for (const parsed of parsedActions) {
+        if (parsed.name === "REPLY" ||
+            parsed.name === "NONE" ||
+            parsed.name === "IGNORE") {
+            continue;
+        }
+        // Prefer the built-in self-control actions for fallback execution.
+        // The runtime-registered wrappers can gate these too aggressively during
+        // early web-chat ownership bootstrap, while the built-in actions still
+        // enforce the actual self-control OWNER/ADMIN check.
+        const action = (await resolveBuiltInFallbackAction(parsed.name)) ??
+            lookup.get(parsed.name);
+        if (!action || typeof action.handler !== "function")
+            continue;
+        if (typeof action.validate === "function") {
+            const valid = await Promise.resolve(action.validate(runtime, message, undefined));
+            if (!valid)
+                continue;
+        }
+        let callbackSeen = false;
+        const actionResult = await Promise.resolve(action.handler(runtime, message, undefined, { parameters: parsed.parameters ?? {} }, async (content) => {
+            const contentRecord = content && typeof content === "object"
+                ? content
+                : {};
+            const actionTag = typeof contentRecord.action === "string"
+                ? contentRecord.action
+                : parsed.name;
+            const chunk = contentRecord && typeof contentRecord === "object"
+                ? extractCompatTextContent(contentRecord)
+                : "";
+            callbackSeen = true;
+            onActionCallback(actionTag, Boolean(chunk));
+            if (chunk) {
+                (options?.onCallbackText ?? appendIncomingText)(chunk);
+            }
+            return [];
+        }, []));
+        if (!callbackSeen) {
+            const currentText = options?.getCurrentText?.() ?? "";
+            const actionSucceeded = actionResult &&
+                typeof actionResult === "object" &&
+                "success" in actionResult
+                ? actionResult.success === true
+                : undefined;
+            const fallbackText = actionResult && typeof actionResult === "object"
+                ? typeof actionResult.text === "string"
+                    ? actionResult.text
+                    : ""
+                : "";
+            const currentTextLooksLikeCompletedWebsiteBlock = /\b(started|starting|blocked|blocking now|website block is active|block is active)\b/i.test(currentText);
+            const shouldSuppressSuccessFallbackText = parsed.name === "WEBSITE_BLOCK" &&
+                actionSucceeded === true &&
+                currentTextLooksLikeCompletedWebsiteBlock;
+            if (fallbackText) {
+                onActionCallback(parsed.name, !shouldSuppressSuccessFallbackText);
+                if (!shouldSuppressSuccessFallbackText) {
+                    appendIncomingText(currentText.trim().length > 0
+                        ? `\n\n${fallbackText}`
+                        : fallbackText);
+                }
+            }
+        }
+    }
+}
+/**
+ * Keyword-to-slug mapping for implicit Binance skill dispatch.
+ * Users don't need to type "binance-meme-rush" — natural language triggers work.
+ * Order matters: first match wins, so more specific patterns go first.
+ */
+const BINANCE_SKILL_KEYWORD_MAP = [
+    // meme-rush: meme tokens, pump.fun, bonding curve, launchpad tokens
+    {
+        pattern: /\b(?:meme\s*(?:token|coin|rush)?|pump\.?fun|four\.?meme|bonding\s*curve|launchpad\s*token|new\s*(?:token|coin)s?\s*on|trending\s*(?:token|coin))/i,
+        slug: "binance-meme-rush",
+    },
+    // trading-signal: smart money signals, whale signals
+    {
+        pattern: /\b(?:(?:trading|smart\s*money|whale)\s*signal|signal\s*(?:list|data))/i,
+        slug: "binance-trading-signal",
+    },
+    // crypto-market-rank: market rankings, trending, alpha, leaderboard
+    {
+        pattern: /\b(?:(?:market|crypto)\s*rank|leader\s*board|top\s*(?:trader|search|token)|alpha\s*(?:token|rank)|smart\s*money\s*(?:rank|inflow))/i,
+        slug: "binance-crypto-market-rank",
+    },
+    // query-token-audit: token/contract audit, rug check, security scan
+    {
+        pattern: /\b(?:(?:token|contract)\s*audit|audit\s*(?:this\s*)?(?:token|contract)|(?:rug|security|safety)\s*(?:check|scan)|check\s*(?:this\s*)?contract)/i,
+        slug: "binance-query-token-audit",
+    },
+    // query-token-info: token info, token price, token detail, search token
+    {
+        pattern: /\b(?:(?:token|coin)\s*(?:info|detail|price|data|search)|search\s*(?:token|coin)|look\s*up\s*(?:token|coin))/i,
+        slug: "binance-query-token-info",
+    },
+    // query-address-info: wallet balance, address info, check wallet
+    {
+        pattern: /\b(?:(?:wallet|address)\s*(?:balance|info|detail|holding)|check\s*(?:this\s*)?(?:wallet|address)|(?:wallet|address)\s*check)/i,
+        slug: "binance-query-address-info",
+    },
+];
+function extractDirectBinanceSkillSlug(userText) {
+    const normalized = userText.toLowerCase();
+    // 1. Explicit slug mention: "use binance-meme-rush ..."
+    const skillMatch = normalized.match(/\b(binance-[a-z0-9-]+)\b/);
+    if (skillMatch) {
+        // Still require an action verb for explicit slugs to avoid false positives
+        if (/\b(use|run|show|fetch|pull|get)\b/.test(normalized)) {
+            return skillMatch[1];
+        }
+    }
+    // 2. Implicit keyword matching: "show me trending meme tokens on BSC"
+    for (const { pattern, slug } of BINANCE_SKILL_KEYWORD_MAP) {
+        if (pattern.test(normalized)) {
+            return slug;
+        }
+    }
+    return null;
+}
+function pickDirectBinanceLimit(userText, fallback, max) {
+    const matches = userText.match(/\b([1-9]\d{0,2})\b/g);
+    if (!matches)
+        return String(fallback);
+    for (const raw of matches) {
+        const value = Number(raw);
+        if (value >= 1 && value <= max) {
+            return String(value);
+        }
+    }
+    return String(fallback);
+}
+function extractExplicitDirectBinanceCount(userText, max) {
+    const matches = userText.match(/\b([1-9]\d{0,2})\b/g);
+    if (!matches)
+        return null;
+    for (const raw of matches) {
+        const value = Number(raw);
+        if (value >= 1 && value <= max) {
+            return value;
+        }
+    }
+    return null;
+}
+function pickDirectBinanceChain(userText, allowed, fallback) {
+    const normalized = userText.toLowerCase();
+    const candidates = [
+        ["solana", /\bsolana\b|\bsol\b|pump\.fun/],
+        ["bsc", /\bbsc\b|\bbnb\b|four\.meme/],
+        ["base", /\bbase\b/],
+        ["eth", /\beth\b|\bethereum\b/],
+    ];
+    for (const [chain, pattern] of candidates) {
+        if (allowed.includes(chain) && pattern.test(normalized)) {
+            return chain;
+        }
+    }
+    return fallback;
+}
+function resolveDirectBinanceMemeRushCommand(userText) {
+    const normalized = userText.toLowerCase();
+    const chain = pickDirectBinanceChain(normalized, ["solana", "bsc"], "solana");
+    if (/topic|topics|narrative|narratives|social rush|hot topic|hot topics/.test(normalized)) {
+        const type = /rising|inflow/.test(normalized) ? "rising" : "latest";
+        const sort = /inflow/.test(normalized) ? "inflow" : "time";
+        const explicitCount = extractExplicitDirectBinanceCount(normalized, 50);
+        return {
+            script: "fetch-topics.sh",
+            args: explicitCount
+                ? [chain, type, sort, String(explicitCount)]
+                : [chain, type, sort],
+        };
+    }
+    const stage = /migrat/.test(normalized)
+        ? "migrated"
+        : /finaliz|about to migrate/.test(normalized)
+            ? "finalizing"
+            : "new";
+    const limit = pickDirectBinanceLimit(normalized, 20, 200);
+    return { script: "fetch-trending.sh", args: [chain, stage, limit] };
+}
+function extractQuotedUserText(userText) {
+    const quotedMatch = userText.match(/["'`“”]([^"'`“”]{2,120})["'`“”]/);
+    return quotedMatch?.[1]?.trim() || null;
+}
+function extractFirstEvmAddress(userText) {
+    return userText.match(/\b0x[a-fA-F0-9]{40}\b/)?.[0] ?? null;
+}
+function extractFirstSolanaAddress(userText) {
+    const candidates = userText.match(/\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g) ?? [];
+    for (const candidate of candidates) {
+        if (candidate.toLowerCase().startsWith("binance") ||
+            candidate.toLowerCase().startsWith("signal")) {
+            continue;
+        }
+        return candidate;
+    }
+    return null;
+}
+function extractDirectBinanceSearchKeyword(userText) {
+    const quoted = extractQuotedUserText(userText);
+    if (quoted)
+        return quoted;
+    const safeText = userText.length > 10_000 ? userText.slice(0, 10_000) : userText;
+    const patterns = [
+        /\bsearch(?: for)?\s+(.+?)(?:\s+on\s+(?:bsc|bnb|solana|sol|base|eth|ethereum)\b|$)/i,
+        /\bfind\s+(.+?)(?:\s+on\s+(?:bsc|bnb|solana|sol|base|eth|ethereum)\b|$)/i,
+        /\blook up\s+(.+?)(?:\s+on\s+(?:bsc|bnb|solana|sol|base|eth|ethereum)\b|$)/i,
+        /\bfor\s+(.+?)(?:\s+on\s+(?:bsc|bnb|solana|sol|base|eth|ethereum)\b|$)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = safeText.match(pattern);
+        const value = match?.[1]?.trim();
+        if (value)
+            return value.replace(/\s+/g, " ").trim();
+    }
+    const cleaned = safeText
+        .replace(/\b(binance-[a-z0-9-]+)\b/gi, " ")
+        .replace(/\b(use|run|show|tell|give|fetch|pull|get|search|find|lookup|look up|query|token|info|market|data|detail|details|price|please|me|and)\b/gi, " ")
+        .replace(/\b(on|in)\s+(bsc|bnb|solana|sol|base|eth|ethereum)\b/gi, " ")
+        .replace(/\b0x[a-fA-F0-9]{40}\b/g, " ")
+        .replace(/\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return cleaned || null;
+}
+function extractDirectBinanceAddressTarget(userText) {
+    const solanaAddress = extractFirstSolanaAddress(userText);
+    if (solanaAddress) {
+        return {
+            address: solanaAddress,
+            chain: "solana",
+        };
+    }
+    const evmAddress = extractFirstEvmAddress(userText);
+    if (!evmAddress)
+        return null;
+    const chain = pickDirectBinanceChain(userText, ["bsc", "base", "eth"], "");
+    return {
+        address: evmAddress,
+        chain: chain || null,
+    };
+}
+function resolveDirectBinanceTradingSignalCommand(userText) {
+    const chain = pickDirectBinanceChain(userText, ["solana", "bsc"], "solana");
+    const limit = pickDirectBinanceLimit(userText, 20, 100);
+    return {
+        kind: "run",
+        script: "signals.sh",
+        args: [chain, limit],
+    };
+}
+function resolveDirectBinanceCryptoMarketRankCommand(userText) {
+    const normalized = userText.toLowerCase();
+    let type = "trending";
+    if (/smart money|inflow/.test(normalized))
+        type = "smart-money";
+    else if (/trader|leaderboard|pnl|kol/.test(normalized))
+        type = "traders";
+    else if (/top search|searched|search ranking/.test(normalized))
+        type = "top-search";
+    else if (/\balpha\b/.test(normalized))
+        type = "alpha";
+    else if (/stock|tokenized/.test(normalized))
+        type = "stock";
+    else if (/meme/.test(normalized))
+        type = "meme";
+    const chain = pickDirectBinanceChain(userText, ["solana", "bsc", "base", "eth"], "");
+    const limit = pickDirectBinanceLimit(userText, 20, 200);
+    return {
+        kind: "run",
+        script: "rankings.sh",
+        args: [type, chain || "all", limit],
+    };
+}
+function resolveDirectBinanceTokenInfoCommand(userText) {
+    const chain = pickDirectBinanceChain(userText, ["solana", "bsc", "base", "eth"], "");
+    const target = extractDirectBinanceAddressTarget(userText);
+    if (target?.address) {
+        const targetChain = target.chain ?? (chain || null);
+        if (targetChain) {
+            return {
+                kind: "run",
+                script: "token-detail.sh",
+                args: [target.address, targetChain],
+            };
+        }
+        return {
+            kind: "run",
+            script: "search.sh",
+            args: [target.address],
+        };
+    }
+    const keyword = extractDirectBinanceSearchKeyword(userText);
+    if (!keyword) {
+        return {
+            kind: "ask",
+            text: "Please provide a token keyword, symbol, or contract address for binance-query-token-info.",
+        };
+    }
+    return {
+        kind: "run",
+        script: "search.sh",
+        args: chain ? [keyword, chain] : [keyword],
+    };
+}
+function resolveDirectBinanceTokenAuditCommand(userText) {
+    const target = extractDirectBinanceAddressTarget(userText);
+    if (!target?.address) {
+        return {
+            kind: "ask",
+            text: "Please provide a token contract address for binance-query-token-audit.",
+        };
+    }
+    if (!target.chain) {
+        return {
+            kind: "ask",
+            text: "Please specify the chain for that contract address: BSC, Base, Ethereum, or Solana.",
+        };
+    }
+    return {
+        kind: "run",
+        script: "audit.sh",
+        args: [target.address, target.chain],
+    };
+}
+function resolveDirectBinanceAddressInfoCommand(userText) {
+    const target = extractDirectBinanceAddressTarget(userText);
+    if (!target?.address) {
+        return {
+            kind: "ask",
+            text: "Please provide a wallet address for binance-query-address-info.",
+        };
+    }
+    if (!target.chain) {
+        return {
+            kind: "ask",
+            text: "Please specify the chain for that wallet address: BSC, Base, Ethereum, or Solana.",
+        };
+    }
+    return {
+        kind: "run",
+        script: "balances.sh",
+        args: [target.address, target.chain],
+    };
+}
+function resolveDirectBinanceScriptCommand(skillSlug, userText) {
+    switch (skillSlug) {
+        case "binance-meme-rush":
+            return {
+                kind: "run",
+                ...resolveDirectBinanceMemeRushCommand(userText),
+            };
+        case "binance-trading-signal":
+            return resolveDirectBinanceTradingSignalCommand(userText);
+        case "binance-crypto-market-rank":
+            return resolveDirectBinanceCryptoMarketRankCommand(userText);
+        case "binance-query-token-info":
+            return resolveDirectBinanceTokenInfoCommand(userText);
+        case "binance-query-token-audit":
+            return resolveDirectBinanceTokenAuditCommand(userText);
+        case "binance-query-address-info":
+            return resolveDirectBinanceAddressInfoCommand(userText);
+        default:
+            return null;
+    }
+}
+const DIRECT_BINANCE_SUMMARY_INPUT_MAX_CHARS = 12_000;
+const DIRECT_BINANCE_SUMMARY_DEFAULT_ITEMS = 5;
+const DIRECT_BINANCE_SUMMARY_MAX_DEPTH = 4;
+function shouldOmitDirectBinanceSummaryKey(key) {
+    return (/^(?:icon|iconUrl|image|imageUrl|logo|logoUrl|avatar|avatarUrl|cover|coverUrl)$/i.test(key) ||
+        /^(?:website|websites|twitter|telegram|discord|medium|social|socials|links?|x)$/i.test(key));
+}
+function compactDirectBinanceSummaryValue(value, itemLimit, depth = 0) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (depth >= DIRECT_BINANCE_SUMMARY_MAX_DEPTH) {
+        if (Array.isArray(value)) {
+            return value
+                .slice(0, Math.min(itemLimit, 3))
+                .map((item) => compactDirectBinanceSummaryValue(item, itemLimit, depth + 1));
+        }
+        if (typeof value === "object") {
+            const objectValue = value;
+            const compactObject = {};
+            for (const [key, entry] of Object.entries(objectValue).slice(0, 8)) {
+                if (shouldOmitDirectBinanceSummaryKey(key))
+                    continue;
+                if (entry === null ||
+                    typeof entry === "string" ||
+                    typeof entry === "number" ||
+                    typeof entry === "boolean") {
+                    compactObject[key] = entry;
+                }
+            }
+            return compactObject;
+        }
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .slice(0, itemLimit)
+            .map((item) => compactDirectBinanceSummaryValue(item, itemLimit, depth + 1))
+            .filter((item) => item !== undefined);
+    }
+    if (typeof value === "object") {
+        const objectValue = value;
+        const scalarEntries = [];
+        const complexEntries = [];
+        for (const [key, entry] of Object.entries(objectValue)) {
+            if (shouldOmitDirectBinanceSummaryKey(key))
+                continue;
+            if (entry === null ||
+                typeof entry === "string" ||
+                typeof entry === "number" ||
+                typeof entry === "boolean") {
+                scalarEntries.push([key, entry]);
+            }
+            else {
+                complexEntries.push([key, entry]);
+            }
+        }
+        const maxKeys = depth === 0 ? 24 : depth === 1 ? 16 : 10;
+        const compactObject = {};
+        for (const [key, entry] of [...scalarEntries, ...complexEntries].slice(0, maxKeys)) {
+            const compactEntry = compactDirectBinanceSummaryValue(entry, key === "data" ? itemLimit : Math.min(itemLimit, 6), depth + 1);
+            if (compactEntry === undefined)
+                continue;
+            if (Array.isArray(compactEntry) && compactEntry.length === 0)
+                continue;
+            if (compactEntry &&
+                typeof compactEntry === "object" &&
+                !Array.isArray(compactEntry) &&
+                Object.keys(compactEntry).length === 0) {
+                continue;
+            }
+            compactObject[key] = compactEntry;
+        }
+        return compactObject;
+    }
+    return String(value);
+}
+function buildDirectBinanceSummaryInput(unwrapped, explicitCount) {
+    const itemLimit = explicitCount ?? DIRECT_BINANCE_SUMMARY_DEFAULT_ITEMS;
+    try {
+        const parsed = JSON.parse(unwrapped);
+        const compact = compactDirectBinanceSummaryValue(parsed, itemLimit);
+        if (compact !== undefined) {
+            const compactText = JSON.stringify(compact, null, 2);
+            if (compactText.trim()) {
+                return compactText;
+            }
+        }
+    }
+    catch {
+        // Fall back to raw text for non-JSON outputs.
+    }
+    return unwrapped;
+}
+function wantsRawBinanceSkillResult(userText) {
+    const normalized = userText.toLowerCase();
+    return (/\braw\b/.test(normalized) ||
+        /\bjson\b/.test(normalized) ||
+        /\bverbatim\b/.test(normalized) ||
+        /\bfull (?:response|result|output)\b/.test(normalized) ||
+        /\bexact (?:response|result|output)\b/.test(normalized));
+}
+const FENCED_JSON_RE_SERVER = /```(?:json)?\s*\n([\s\S]*?)```/;
+function unwrapDirectBinanceSkillResult(rawText) {
+    const fencedBlocks = Array.from(rawText.matchAll(new RegExp(FENCED_JSON_RE_SERVER.source, "g")))
+        .map((match) => match[1]?.trim() ?? "")
+        .filter((block) => block.length > 0);
+    if (fencedBlocks.length > 0) {
+        return fencedBlocks.join("\n\n");
+    }
+    return rawText
+        .replace(/^Script executed successfully:\s*/i, "")
+        .replace(/^Script execution failed:\s*/i, "")
+        .trim();
+}
+function normalizeDirectBinanceSummaryText(summary) {
+    return summary
+        .replace(/\*\*/g, "")
+        .replace(/^[ \t]*[-*][ \t]+/gm, "")
+        .replace(/^[ \t]*\d+\.\s+/gm, "")
+        .replace(/^#{1,6}\s+/gm, "")
+        .replace(/\n?(?:For more details or the raw JSON, feel free to ask\.?|You can ask for the raw JSON if you want it\.?|If you need the raw JSON details, feel free to ask\.?)\s*$/i, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+async function summarizeDirectBinanceSkillResult(runtime, skillSlug, userText, rawText) {
+    const unwrapped = unwrapDirectBinanceSkillResult(rawText);
+    if (!unwrapped)
+        return rawText;
+    const explicitCount = extractExplicitDirectBinanceCount(userText, 50);
+    const compactInput = buildDirectBinanceSummaryInput(unwrapped, explicitCount);
+    const resultSnippet = compactInput.length > DIRECT_BINANCE_SUMMARY_INPUT_MAX_CHARS
+        ? `${compactInput.slice(0, DIRECT_BINANCE_SUMMARY_INPUT_MAX_CHARS)}\n\n[truncated]`
+        : compactInput;
+    const prompt = [
+        `Summarize this Binance skill result for the user. Be concise.`,
+        `User request: ${userText}`,
+        `Skill: ${skillSlug}`,
+        explicitCount
+            ? `Return ${explicitCount} distinct items if available.`
+            : `Choose a sensible concise count.`,
+        "",
+        "Format:",
+        "- plain prose, no markdown/bullets/numbered lists/bold/fences",
+        "- title line then compact 'field: value' lines (use real field names, not generic labels)",
+        "- blank line between multiple entries",
+        "- rankings/lists capped at 5 unless user requested otherwise",
+        "",
+        "Domain:",
+        "- mention the chain when present",
+        "- ignore icon/image/social URLs unless asked",
+        "- omit unavailable fields; never invent",
+        "- on error, explain briefly and suggest one next step",
+        "- no follow-up offers (raw JSON, more details, next questions)",
+        "",
+        "Skill result:",
+        resultSnippet,
+    ].join("\n");
+    try {
+        const summary = await runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+            maxTokens: 700,
+            temperature: 0.2,
+        });
+        const clean = summary?.trim()
+            ? normalizeDirectBinanceSummaryText(summary.trim())
+            : "";
+        return clean || rawText;
+    }
+    catch (err) {
+        runtime.logger?.warn({
+            src: "eliza-api",
+            skillSlug,
+            error: err instanceof Error ? err.message : String(err),
+        }, "[eliza-api] Binance skill summarization failed; falling back to raw output");
+        return rawText;
+    }
+}
+export async function maybeHandleDirectBinanceSkillRequest(runtime, message, appendIncomingText, replaceText) {
+    const userText = extractCompatTextContent(message.content)?.trim();
+    if (!userText)
+        return null;
+    const skillSlug = extractDirectBinanceSkillSlug(userText);
+    if (!skillSlug)
+        return null;
+    if (!shouldExposeBinanceSkillId(skillSlug)) {
+        const visibleSkills = Array.from(EXPOSED_BINANCE_SKILL_IDS)
+            .sort()
+            .join(", ");
+        return `The Binance skill "${skillSlug}" is currently hidden in this build. Available Binance skills: ${visibleSkills}.`;
+    }
+    const service = runtime.getService("AGENT_SKILLS_SERVICE");
+    const hasSkill = typeof service?.getLoadedSkill === "function"
+        ? Boolean(service.getLoadedSkill(skillSlug))
+        : typeof service?.getLoadedSkills === "function"
+            ? service
+                .getLoadedSkills()
+                .some((skill) => typeof skill.slug === "string" && skill.slug === skillSlug)
+            : false;
+    if (!hasSkill)
+        return null;
+    const runtimeActions = Array.isArray(runtime.actions)
+        ? runtime.actions
+        : [];
+    const useSkillAction = runtimeActions.find((action) => action.name === "USE_SKILL");
+    const command = resolveDirectBinanceScriptCommand(skillSlug, userText);
+    if (!command) {
+        return null;
+    }
+    if (command.kind === "ask") {
+        appendIncomingText(command.text);
+        return command.text;
+    }
+    if (typeof useSkillAction?.handler === "function") {
+        // Stream a loading hint so the user sees immediate feedback
+        const loadingHints = {
+            "binance-meme-rush": "Fetching meme tokens from Binance...",
+            "binance-trading-signal": "Fetching trading signals...",
+            "binance-crypto-market-rank": "Fetching market rankings...",
+            "binance-query-token-info": "Looking up token info...",
+            "binance-query-token-audit": "Running token audit...",
+            "binance-query-address-info": "Checking wallet balances...",
+        };
+        appendIncomingText(loadingHints[skillSlug] ?? "Fetching Binance data...");
+        let directRunText = "";
+        runtime.logger?.info({
+            src: "eliza-api",
+            action: "USE_SKILL",
+            skillSlug,
+            script: command.script,
+            args: command.args,
+        }, `[eliza-api] Direct Binance script dispatch: ${skillSlug}/${command.script}`);
+        const runResult = await Promise.resolve(useSkillAction.handler(runtime, message, undefined, {
+            slug: skillSlug,
+            mode: "script",
+            script: command.script,
+            args: command.args,
+        }, async (content) => {
+            const chunk = content && typeof content === "object"
+                ? extractCompatTextContent(content)
+                : "";
+            if (!chunk)
+                return [];
+            directRunText = chunk;
+            return [];
+        }, []));
+        const rawDirectText = directRunText.trim().length > 0
+            ? directRunText
+            : runResult &&
+                typeof runResult === "object" &&
+                "text" in runResult &&
+                typeof runResult.text === "string"
+                ? runResult.text
+                : "";
+        if (rawDirectText.trim().length > 0) {
+            const finalText = wantsRawBinanceSkillResult(userText)
+                ? rawDirectText
+                : await summarizeDirectBinanceSkillResult(runtime, skillSlug, userText, rawDirectText);
+            // Replace the loading hint with the actual result via snapshot
+            if (replaceText) {
+                replaceText(finalText);
+            }
+            else {
+                appendIncomingText(finalText);
+            }
+            return finalText;
+        }
+    }
+    return null;
+}