@elizaos/plugin-steward-app 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/api/binance-skill-helpers.js

@@ -0,0 +1,790 @@
+import { extractCompatTextContent } from "@elizaos/agent";
+import {
+  ModelType
+} from "@elizaos/core";
+const EXPOSED_BINANCE_SKILL_IDS = /* @__PURE__ */ 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);
+}
+async function rewriteFallbackActionText(args) {
+  const text = args.text.trim();
+  if (!text) return args.text;
+  const fallback = () => {
+    const error = typeof args.content?.error === "string" && args.content.error.trim() ? ` It reported: ${args.content.error.trim()}` : "";
+    return `I ran ${args.actionName} and got a result, but I couldn't format the details cleanly here.${error}`;
+  };
+  if (typeof args.runtime.useModel !== "function") return fallback();
+  try {
+    const raw = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt: [
+        "Rewrite this fallback action output in the assistant character's user-facing voice.",
+        'Return strict JSON only: {"response":"..."}.',
+        "",
+        "Rules:",
+        "- Preserve status, IDs, names, URLs, counts, errors, warnings, and next steps.",
+        "- Do not expose raw JSON, shell output, schema names, stack traces, or internal action plumbing unless an exact value is necessary.",
+        "- Do not claim success if the payload says failed or pending.",
+        "- Keep it brief and natural.",
+        "",
+        `Character: ${JSON.stringify({
+          name: args.runtime.character?.name,
+          system: args.runtime.character?.system,
+          bio: args.runtime.character?.bio,
+          style: args.runtime.character?.style
+        })}`,
+        `Action: ${JSON.stringify(args.actionName)}`,
+        `Payload: ${JSON.stringify(text)}`,
+        `Metadata: ${JSON.stringify({
+          source: args.content?.source,
+          actions: args.content?.actions,
+          actionStatus: args.content?.actionStatus,
+          error: args.content?.error
+        })}`
+      ].join("\n"),
+      maxTokens: 260,
+      providerOptions: { eliza: { thinking: "off" } }
+    });
+    const parsed = JSON.parse(String(raw).trim());
+    return typeof parsed.response === "string" && parsed.response.trim() ? parsed.response.trim() : fallback();
+  } catch (err) {
+    args.runtime.logger?.debug?.(
+      {
+        src: "eliza-api",
+        action: args.actionName,
+        err: err instanceof Error ? err.message : String(err)
+      },
+      "[eliza-api] Fallback action voice rewrite failed"
+    );
+    return fallback();
+  }
+}
+let ownerBlockFallbackPromise = null;
+async function resolveBuiltInFallbackAction(actionName) {
+  if (actionName !== "BLOCK") {
+    return null;
+  }
+  if (!ownerBlockFallbackPromise) {
+    ownerBlockFallbackPromise = import("@elizaos/plugin-personal-assistant").then((mod) => mod.websiteBlockAction ?? null).catch(() => null);
+  }
+  return ownerBlockFallbackPromise;
+}
+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";
+}
+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}
+${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;
+}
+function isBalanceIntent(input) {
+  const normalized = input.toLowerCase();
+  return /\b(balance|wallet|holdings|portfolio|funds|how much)\b/.test(
+    normalized
+  );
+}
+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;
+}
+async function executeFallbackParsedActions(runtime, message, parsedActions, appendIncomingText, onActionCallback, options) {
+  const runtimeActions = Array.isArray(
+    runtime.actions
+  ) ? runtime.actions : [];
+  const lookup = /* @__PURE__ */ 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;
+    }
+    const action = lookup.get(parsed.name) ?? await resolveBuiltInFallbackAction(parsed.name);
+    if (!action || typeof action.handler !== "function") continue;
+    if (typeof action.validate === "function") {
+      const valid = await Promise.resolve(
+        action.validate(runtime, message, void 0)
+      );
+      if (!valid) continue;
+    }
+    let callbackSeen = false;
+    const actionResult = await Promise.resolve(
+      action.handler(
+        runtime,
+        message,
+        void 0,
+        { 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) {
+            const voicedChunk = await rewriteFallbackActionText({
+              runtime,
+              actionName: actionTag,
+              text: chunk,
+              content: contentRecord
+            });
+            (options?.onCallbackText ?? appendIncomingText)(voicedChunk);
+          }
+          return [];
+        },
+        []
+      )
+    );
+    if (!callbackSeen) {
+      const currentText = options?.getCurrentText?.() ?? "";
+      const actionSucceeded = actionResult && typeof actionResult === "object" && "success" in actionResult ? actionResult.success === true : void 0;
+      const fallbackText = actionResult && typeof actionResult === "object" ? typeof actionResult.text === "string" ? actionResult.text : "" : "";
+      const shouldSuppressSuccessFallbackText = parsed.name === "BLOCK" && actionSucceeded === true && /\b(block|blocking|self ?control)\b/i.test(currentText);
+      if (fallbackText) {
+        onActionCallback(parsed.name, !shouldSuppressSuccessFallbackText);
+        if (!shouldSuppressSuccessFallbackText) {
+          const voicedFallbackText = await rewriteFallbackActionText({
+            runtime,
+            actionName: parsed.name,
+            text: fallbackText
+          });
+          appendIncomingText(
+            currentText.trim().length > 0 ? `
+
+${voicedFallbackText}` : voicedFallbackText
+          );
+        }
+      }
+    }
+  }
+}
+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();
+  const skillMatch = normalized.match(/\b(binance-[a-z0-9-]+)\b/);
+  if (skillMatch) {
+    if (/\b(use|run|show|fetch|pull|get)\b/.test(normalized)) {
+      return skillMatch[1];
+    }
+  }
+  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 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 = userText.match(pattern);
+    const value = match?.[1]?.trim();
+    if (value) return value.replace(/\s+/g, " ").trim();
+  }
+  const cleaned = userText.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 = 12e3;
+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 void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, itemLimit).map(
+      (item) => compactDirectBinanceSummaryValue(item, itemLimit, depth + 1)
+    ).filter((item) => item !== void 0);
+  }
+  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 === void 0) 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 !== void 0) {
+      const compactText = JSON.stringify(compact, null, 2);
+      if (compactText.trim()) {
+        return compactText;
+      }
+    }
+  } catch {
+  }
+  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 fallback = () => `I ran ${skillSlug} and got a Binance skill result, but I couldn't format the raw details cleanly here.`;
+  const unwrapped = unwrapDirectBinanceSkillResult(rawText);
+  if (!unwrapped) return fallback();
+  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)}
+
+[truncated]` : compactInput;
+  const prompt = [
+    "You are formatting the result of a Binance skill for the end user.",
+    "The official skill instructions say to run the skill first and then summarize the results.",
+    "",
+    `User request: ${userText}`,
+    `Skill: ${skillSlug}`,
+    explicitCount ? `The user explicitly requested ${explicitCount} items. Return ${explicitCount} distinct items if the result contains that many.` : "If the user did not request a count, choose a sensible concise amount.",
+    "",
+    "Rules:",
+    "- Answer the user's request directly using only the result below.",
+    "- Default to a concise summary, not raw JSON.",
+    "- If the result is a ranking or list, show at most 5 items unless the user explicitly requested a different count.",
+    "- Output plain text only.",
+    "- Do not use markdown, bullets, numbered lists, bold markers, or code fences.",
+    "- Prefer a clean title line followed by compact 'Label: value' lines, with blank lines between items when listing multiple entries.",
+    "- Do not prefix lines with generic labels like 'Label:' or 'Item:'. Use the actual field name directly.",
+    "- Mention the chain when it is present in the result.",
+    "- Ignore icon URLs, image links, and social links unless the user explicitly asked for them.",
+    "- Do not mention scripts, stdout, code fences, or internal tooling.",
+    "- Do not invent missing fields. If a field is unavailable, omit it.",
+    "- If the result is an error, explain it briefly and suggest one next step.",
+    "- Do not append any follow-up sentence about raw JSON, more details, or 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 || fallback();
+  } catch (err) {
+    runtime.logger?.warn(
+      {
+        src: "eliza-api",
+        skillSlug,
+        error: err instanceof Error ? err.message : String(err)
+      },
+      "[eliza-api] Binance skill summarization failed; suppressing raw output"
+    );
+    return fallback();
+  }
+}
+async function rewriteRawDirectBinanceSkillResult(runtime, skillSlug, userText, rawText) {
+  const fallback = () => `I ran ${skillSlug} and got the requested raw Binance skill payload, but I couldn't format it safely here.`;
+  const unwrapped = unwrapDirectBinanceSkillResult(rawText) || rawText;
+  const boundedPayload = unwrapped.length > DIRECT_BINANCE_SUMMARY_INPUT_MAX_CHARS ? `${unwrapped.slice(0, DIRECT_BINANCE_SUMMARY_INPUT_MAX_CHARS)}
+
+[truncated]` : unwrapped;
+  const prompt = [
+    "Write a brief character-voiced response that includes the requested raw Binance skill payload.",
+    'Return strict JSON only: {"response":"..."}.',
+    "",
+    "Rules:",
+    "- Preserve the raw payload exactly inside the response as much as possible.",
+    "- Add only a short natural-language wrapper before the payload.",
+    "- Do not invent fields, interpretation, or extra analysis.",
+    "- If the payload is truncated, say it is truncated.",
+    "",
+    `Character: ${JSON.stringify({
+      name: runtime.character?.name,
+      system: runtime.character?.system,
+      bio: runtime.character?.bio,
+      style: runtime.character?.style
+    })}`,
+    `User request: ${JSON.stringify(userText)}`,
+    `Skill: ${JSON.stringify(skillSlug)}`,
+    `Raw payload: ${JSON.stringify(boundedPayload)}`
+  ].join("\n");
+  try {
+    const raw = await runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt,
+      maxTokens: 900,
+      temperature: 0.1,
+      providerOptions: { eliza: { thinking: "off" } }
+    });
+    const parsed = JSON.parse(String(raw).trim());
+    return typeof parsed.response === "string" && parsed.response.trim() ? parsed.response.trim() : fallback();
+  } catch (err) {
+    runtime.logger?.warn?.(
+      {
+        src: "eliza-api",
+        skillSlug,
+        error: err instanceof Error ? err.message : String(err)
+      },
+      "[eliza-api] Binance raw skill rewrite failed; suppressing raw output"
+    );
+    return fallback();
+  }
+}
+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") {
+    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,
+        void 0,
+        {
+          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) ? await rewriteRawDirectBinanceSkillResult(
+        runtime,
+        skillSlug,
+        userText,
+        rawDirectText
+      ) : await summarizeDirectBinanceSkillResult(
+        runtime,
+        skillSlug,
+        userText,
+        rawDirectText
+      );
+      if (replaceText) {
+        replaceText(finalText);
+      } else {
+        appendIncomingText(finalText);
+      }
+      return finalText;
+    }
+  }
+  return null;
+}
+export {
+  executeFallbackParsedActions,
+  inferBalanceChainFromText,
+  isBalanceIntent,
+  maybeHandleDirectBinanceSkillRequest,
+  parseFallbackActionBlocks,
+  shouldForceCheckBalanceFallback
+};
+//# sourceMappingURL=binance-skill-helpers.js.map