@noya-ai/mcp 0.1.0

package/dist/stdio.cjs

@@ -0,0 +1,1374 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/stdio.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_sdk = require("@noya-ai/sdk");
+
+// src/generated-tools.ts
+var alternativeSchemas = __toESM(require("@noya-ai/data-server-schemas/alternative"), 1);
+var coingeckoSchemas = __toESM(require("@noya-ai/data-server-schemas/coingecko"), 1);
+var coinglassSchemas = __toESM(require("@noya-ai/data-server-schemas/coinglass"), 1);
+var compositeSchemas = __toESM(require("@noya-ai/data-server-schemas/composite"), 1);
+var cryptonewsSchemas = __toESM(require("@noya-ai/data-server-schemas/cryptonews"), 1);
+var defillamaSchemas = __toESM(require("@noya-ai/data-server-schemas/defillama"), 1);
+var geckoterminalSchemas = __toESM(require("@noya-ai/data-server-schemas/geckoterminal"), 1);
+var kaitoSchemas = __toESM(require("@noya-ai/data-server-schemas/kaito"), 1);
+var moralisSchemas = __toESM(require("@noya-ai/data-server-schemas/moralis"), 1);
+var noyaSchemas = __toESM(require("@noya-ai/data-server-schemas/noya"), 1);
+var sdkSchemas = __toESM(require("@noya-ai/sdk"), 1);
+var import_zod = require("zod");
+function toMcpResult(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "";
+  return { content: [{ type: "text", text }] };
+}
+var PASSTHROUGH_INPUT_SHAPE = { args: import_zod.z.unknown().describe("Pass-through arguments \u2014 see SDK docs for the shape.") };
+function asRawShape(schema) {
+  let current = schema;
+  for (let i = 0; i < 6; i++) {
+    const def = current._def;
+    if (def.typeName === "ZodObject") break;
+    if (def.schema) {
+      current = def.schema;
+      continue;
+    }
+    if (def.innerType) {
+      current = def.innerType;
+      continue;
+    }
+    break;
+  }
+  const shape = current.shape;
+  return shape ?? {};
+}
+function registerGeneratedTools(server, getClient) {
+  const client = getClient();
+  server.tool(
+    "data_alternative_fear_greed",
+    "Auto-generated from sdk.data.alternative.fearGreed",
+    asRawShape(alternativeSchemas.FearGreedBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.alternative.fearGreed(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_batch_dispatch",
+    "Auto-generated from sdk.data.batch.dispatch",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.batch.dispatch());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_price",
+    "Auto-generated from sdk.data.coingecko.price",
+    asRawShape(coingeckoSchemas.PriceBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coingecko.price(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_ohlcv",
+    "Auto-generated from sdk.data.coingecko.ohlcv",
+    asRawShape(coingeckoSchemas.OhlcvBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coingecko.ohlcv(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_token_info",
+    "Auto-generated from sdk.data.coingecko.tokenInfo",
+    asRawShape(coingeckoSchemas.TokenInfoBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coingecko.tokenInfo(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_trending",
+    "Auto-generated from sdk.data.coingecko.trending",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.coingecko.trending());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_search",
+    "Auto-generated from sdk.data.coingecko.search",
+    asRawShape(coingeckoSchemas.SearchBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coingecko.search(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_price_history",
+    "Auto-generated from sdk.data.coingecko.priceHistory",
+    asRawShape(coingeckoSchemas.PriceHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coingecko.priceHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coingecko_price_at_date",
+    "Auto-generated from sdk.data.coingecko.priceAtDate",
+    asRawShape(coingeckoSchemas.PriceAtDateBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coingecko.priceAtDate(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_funding_rates",
+    "Auto-generated from sdk.data.coinglass.fundingRates",
+    asRawShape(coinglassSchemas.FundingRatesBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.fundingRates(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_open_interest",
+    "Auto-generated from sdk.data.coinglass.openInterest",
+    asRawShape(coinglassSchemas.OpenInterestBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.openInterest(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_liquidations",
+    "Auto-generated from sdk.data.coinglass.liquidations",
+    asRawShape(coinglassSchemas.LiquidationsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.liquidations(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_long_short_ratio",
+    "Auto-generated from sdk.data.coinglass.longShortRatio",
+    asRawShape(coinglassSchemas.LongShortRatioBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.longShortRatio(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_supported_coins",
+    "Auto-generated from sdk.data.coinglass.supportedCoins",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.coinglass.supportedCoins());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_supported_exchanges",
+    "Auto-generated from sdk.data.coinglass.supportedExchanges",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.coinglass.supportedExchanges());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_exchange_pairs",
+    "Auto-generated from sdk.data.coinglass.exchangePairs",
+    asRawShape(coinglassSchemas.ExchangePairsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.exchangePairs(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_liquidations_by_exchange",
+    "Auto-generated from sdk.data.coinglass.liquidationsByExchange",
+    asRawShape(coinglassSchemas.LiquidationsByExchangeBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.liquidationsByExchange(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_funding_rate_history",
+    "Auto-generated from sdk.data.coinglass.fundingRateHistory",
+    asRawShape(coinglassSchemas.FundingRateHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.fundingRateHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_open_interest_history",
+    "Auto-generated from sdk.data.coinglass.openInterestHistory",
+    asRawShape(coinglassSchemas.FundingRateHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.openInterestHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_liquidation_history",
+    "Auto-generated from sdk.data.coinglass.liquidationHistory",
+    asRawShape(coinglassSchemas.FundingRateHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.liquidationHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_coinglass_long_short_ratio_history",
+    "Auto-generated from sdk.data.coinglass.longShortRatioHistory",
+    asRawShape(coinglassSchemas.FundingRateHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.coinglass.longShortRatioHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_composite_market_snapshot",
+    "Auto-generated from sdk.data.composite.marketSnapshot",
+    asRawShape(compositeSchemas.MarketSnapshotBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.composite.marketSnapshot(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_composite_alpha_radar",
+    "Auto-generated from sdk.data.composite.alphaRadar",
+    asRawShape(compositeSchemas.AlphaRadarBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.composite.alphaRadar(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_composite_wallet_xray",
+    "Auto-generated from sdk.data.composite.walletXray",
+    asRawShape(compositeSchemas.WalletXrayBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.composite.walletXray(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_composite_health",
+    "Auto-generated from sdk.data.composite.health",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.composite.health());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_cryptonews_news",
+    "Auto-generated from sdk.data.cryptonews.news",
+    asRawShape(cryptonewsSchemas.NewsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.cryptonews.news(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_cryptonews_sentiment",
+    "Auto-generated from sdk.data.cryptonews.sentiment",
+    asRawShape(cryptonewsSchemas.SentimentBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.cryptonews.sentiment(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_cryptonews_trending",
+    "Auto-generated from sdk.data.cryptonews.trending",
+    asRawShape(cryptonewsSchemas.TrendingQuery),
+    async (args) => {
+      const result = await Promise.resolve(client.data.cryptonews.trending(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_tvl",
+    "Auto-generated from sdk.data.defillama.tvl",
+    asRawShape(defillamaSchemas.TvlBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.defillama.tvl(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_yields",
+    "Auto-generated from sdk.data.defillama.yields",
+    asRawShape(defillamaSchemas.YieldsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.defillama.yields(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_protocol_fees",
+    "Auto-generated from sdk.data.defillama.protocolFees",
+    asRawShape(defillamaSchemas.ProtocolFeesBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.defillama.protocolFees(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_dex_volumes",
+    "Auto-generated from sdk.data.defillama.dexVolumes",
+    asRawShape(defillamaSchemas.DexVolumesBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.defillama.dexVolumes(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_stablecoins",
+    "Auto-generated from sdk.data.defillama.stablecoins",
+    asRawShape(defillamaSchemas.StablecoinsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.defillama.stablecoins(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_bridges",
+    "Auto-generated from sdk.data.defillama.bridges",
+    asRawShape(defillamaSchemas.BridgesBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.defillama.bridges(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_defillama_bridges_list",
+    "Auto-generated from sdk.data.defillama.bridgesList",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.defillama.bridgesList());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_geckoterminal_token_pools",
+    "Auto-generated from sdk.data.geckoterminal.tokenPools",
+    asRawShape(geckoterminalSchemas.TokenPoolsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.geckoterminal.tokenPools(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_geckoterminal_pool_ohlcv",
+    "Auto-generated from sdk.data.geckoterminal.poolOhlcv",
+    asRawShape(geckoterminalSchemas.PoolOhlcvBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.geckoterminal.poolOhlcv(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_geckoterminal_pool_trades",
+    "Auto-generated from sdk.data.geckoterminal.poolTrades",
+    asRawShape(geckoterminalSchemas.PoolTradesBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.geckoterminal.poolTrades(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_geckoterminal_trending_pools",
+    "Auto-generated from sdk.data.geckoterminal.trendingPools",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.geckoterminal.trendingPools());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_geckoterminal_token_info",
+    "Auto-generated from sdk.data.geckoterminal.tokenInfo",
+    asRawShape(geckoterminalSchemas.TokenInfoBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.geckoterminal.tokenInfo(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_entities",
+    "Auto-generated from sdk.data.kaito.entities",
+    asRawShape(kaitoSchemas.EntitiesQuery),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.entities(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_narratives",
+    "Auto-generated from sdk.data.kaito.narratives",
+    asRawShape(kaitoSchemas.NarrativesQuery),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.narratives(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_search",
+    "Auto-generated from sdk.data.kaito.search",
+    asRawShape(kaitoSchemas.SearchBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.search(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_advanced_search",
+    "Auto-generated from sdk.data.kaito.advancedSearch",
+    asRawShape(kaitoSchemas.AdvancedSearchBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.advancedSearch(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_tweet_engagement",
+    "Auto-generated from sdk.data.kaito.tweetEngagement",
+    asRawShape(kaitoSchemas.TweetEngagementBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.tweetEngagement(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_feeds",
+    "Auto-generated from sdk.data.kaito.feeds",
+    asRawShape(kaitoSchemas.FeedsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.feeds(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_sentiment",
+    "Auto-generated from sdk.data.kaito.sentiment",
+    asRawShape(kaitoSchemas.SentimentBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.sentiment(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_engagement",
+    "Auto-generated from sdk.data.kaito.engagement",
+    asRawShape(kaitoSchemas.EngagementBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.engagement(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_mentions",
+    "Auto-generated from sdk.data.kaito.mentions",
+    asRawShape(kaitoSchemas.EngagementBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.mentions(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_mindshare",
+    "Auto-generated from sdk.data.kaito.mindshare",
+    asRawShape(kaitoSchemas.MindshareBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.mindshare(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_mindshare_arena",
+    "Auto-generated from sdk.data.kaito.mindshareArena",
+    asRawShape(kaitoSchemas.MindshareArenaBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.mindshareArena(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_mindshare_delta",
+    "Auto-generated from sdk.data.kaito.mindshareDelta",
+    asRawShape(kaitoSchemas.MindshareDeltaBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.mindshareDelta(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_mindshare_narrative",
+    "Auto-generated from sdk.data.kaito.mindshareNarrative",
+    asRawShape(kaitoSchemas.MindshareNarrativeBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.mindshareNarrative(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_kol_mindshare",
+    "Auto-generated from sdk.data.kaito.kolMindshare",
+    asRawShape(kaitoSchemas.KolMindshareBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.kolMindshare(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_events",
+    "Auto-generated from sdk.data.kaito.events",
+    asRawShape(kaitoSchemas.EventsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.events(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_twitter_user_metadata",
+    "Auto-generated from sdk.data.kaito.twitterUserMetadata",
+    asRawShape(kaitoSchemas.TwitterUserMetadataBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.twitterUserMetadata(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_market_smart_following",
+    "Auto-generated from sdk.data.kaito.marketSmartFollowing",
+    asRawShape(kaitoSchemas.MarketSmartFollowingBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.marketSmartFollowing(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_smart_followers",
+    "Auto-generated from sdk.data.kaito.smartFollowers",
+    asRawShape(kaitoSchemas.SmartFollowersBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.smartFollowers(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_kaito_smart_following",
+    "Auto-generated from sdk.data.kaito.smartFollowing",
+    asRawShape(kaitoSchemas.SmartFollowingBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.kaito.smartFollowing(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_moralis_wallet",
+    "Auto-generated from sdk.data.moralis.wallet",
+    asRawShape(moralisSchemas.WalletBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.moralis.wallet(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_moralis_transfers",
+    "Auto-generated from sdk.data.moralis.transfers",
+    asRawShape(moralisSchemas.TransfersBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.moralis.transfers(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_moralis_defi_positions",
+    "Auto-generated from sdk.data.moralis.defiPositions",
+    asRawShape(moralisSchemas.DefiPositionsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.moralis.defiPositions(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_moralis_nft_holdings",
+    "Auto-generated from sdk.data.moralis.nftHoldings",
+    asRawShape(moralisSchemas.NftHoldingsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.moralis.nftHoldings(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_search",
+    "Auto-generated from sdk.data.noya.tokensSearch",
+    asRawShape(noyaSchemas.TokensSearchBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.tokensSearch(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_similar",
+    "Auto-generated from sdk.data.noya.tokensSimilar",
+    asRawShape(noyaSchemas.TokensSimilarBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.tokensSimilar(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_recommendations",
+    "Auto-generated from sdk.data.noya.tokensRecommendations",
+    asRawShape(noyaSchemas.TokensRecommendationsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.tokensRecommendations(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_top_score",
+    "Auto-generated from sdk.data.noya.tokensTopScore",
+    asRawShape(noyaSchemas.TopTokensByScoreBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.tokensTopScore(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_health",
+    "Auto-generated from sdk.data.noya.tokensHealth",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.noya.tokensHealth());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_versions",
+    "Auto-generated from sdk.data.noya.tokensVersions",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.noya.tokensVersions());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_by_version",
+    "Auto-generated from sdk.data.noya.tokensByVersion",
+    asRawShape(noyaSchemas.TokensByVersionBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.tokensByVersion(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_tokens_detail",
+    "Auto-generated from sdk.data.noya.tokensDetail",
+    asRawShape(noyaSchemas.TokenDetailBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.tokensDetail(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_search",
+    "Auto-generated from sdk.data.noya.polymarketSearch",
+    asRawShape(noyaSchemas.PolymarketSearchBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketSearch(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_similar",
+    "Auto-generated from sdk.data.noya.polymarketSimilar",
+    asRawShape(noyaSchemas.PolymarketSimilarBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketSimilar(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_recommendations",
+    "Auto-generated from sdk.data.noya.polymarketRecommendations",
+    asRawShape(noyaSchemas.PolymarketRecommendationsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketRecommendations(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_top_ev",
+    "Auto-generated from sdk.data.noya.polymarketTopEv",
+    asRawShape(noyaSchemas.TopMarketsByEvBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketTopEv(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_filter",
+    "Auto-generated from sdk.data.noya.polymarketFilter",
+    asRawShape(noyaSchemas.PolymarketFilterBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketFilter(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_events",
+    "Auto-generated from sdk.data.noya.polymarketEvents",
+    asRawShape(noyaSchemas.PolymarketEventsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketEvents(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_by_event",
+    "Auto-generated from sdk.data.noya.polymarketByEvent",
+    asRawShape(noyaSchemas.PolymarketByEventBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketByEvent(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_tags",
+    "Auto-generated from sdk.data.noya.polymarketTags",
+    asRawShape(noyaSchemas.PolymarketTagsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketTags(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_health",
+    "Auto-generated from sdk.data.noya.polymarketHealth",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.noya.polymarketHealth());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_versions",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisVersions",
+    asRawShape(noyaSchemas.AnalysisVersionsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisVersions(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_latest",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisLatest",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisLatest());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_events",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisEvents",
+    asRawShape(noyaSchemas.AnalysisEventsBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisEvents(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_event_history",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisEventHistory",
+    asRawShape(noyaSchemas.AnalysisEventHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisEventHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_market_history",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisMarketHistory",
+    asRawShape(noyaSchemas.AnalysisMarketHistoryBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisMarketHistory(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_top",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisTop",
+    asRawShape(noyaSchemas.AnalysisTopBody),
+    async (args) => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisTop(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "data_noya_polymarket_analysis_health",
+    "Auto-generated from sdk.data.noya.polymarketAnalysisHealth",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.data.noya.polymarketAnalysisHealth());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "account_polymarket_address",
+    "Derive the Polymarket Safe address (CREATE2) for the user's EOA. Mirrors `noya_get_polymarket_address` MCP tool \u2014 pure local derivation, no network call beyond the one /api/me to resolve the EOA",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.account.polymarketAddress());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "account_address",
+    "Resolved Ethereum address from /api/me. Throws if anonymous",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.account.address());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "account_sign_message",
+    "Auto-generated from sdk.account.signMessage",
+    asRawShape(sdkSchemas.SignMessageInput),
+    async (args) => {
+      const result = await Promise.resolve(client.account.signMessage(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "account_sign_transaction",
+    "Auto-generated from sdk.account.signTransaction",
+    asRawShape(sdkSchemas.SignTransactionInput),
+    async (args) => {
+      const result = await Promise.resolve(client.account.signTransaction(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "account_sign_typed_data",
+    "Auto-generated from sdk.account.signTypedData",
+    asRawShape(sdkSchemas.SignTypedDataInput),
+    async (args) => {
+      const result = await Promise.resolve(client.account.signTypedData(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "account_to_viem",
+    "Returns a viem `LocalAccount` whose signing methods POST to signer. Memoized \u2014 same Account instance always returns the same viem account",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.account.toViem());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_wallet_get_wallet_details",
+    "Auto-generated from sdk.chain.wallet.getWalletDetails",
+    asRawShape(sdkSchemas.WalletGetWalletDetailsInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.wallet.getWalletDetails(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_wallet_native_transfer",
+    "Auto-generated from sdk.chain.wallet.nativeTransfer",
+    asRawShape(sdkSchemas.WalletNativeTransferInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.wallet.nativeTransfer(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc20_get_balance",
+    "Auto-generated from sdk.chain.erc20.getBalance",
+    asRawShape(sdkSchemas.Erc20GetBalanceInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc20.getBalance(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc20_get_allowance",
+    "Auto-generated from sdk.chain.erc20.getAllowance",
+    asRawShape(sdkSchemas.Erc20GetAllowanceInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc20.getAllowance(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc20_get_erc20_token_address",
+    "Auto-generated from sdk.chain.erc20.getErc20TokenAddress",
+    asRawShape(sdkSchemas.Erc20GetErc20TokenAddressInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc20.getErc20TokenAddress(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc20_transfer",
+    "Auto-generated from sdk.chain.erc20.transfer",
+    asRawShape(sdkSchemas.Erc20TransferInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc20.transfer(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc20_approve",
+    "Auto-generated from sdk.chain.erc20.approve",
+    asRawShape(sdkSchemas.Erc20ApproveInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc20.approve(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc721_get_balance",
+    "Auto-generated from sdk.chain.erc721.getBalance",
+    asRawShape(sdkSchemas.Erc721GetBalanceInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc721.getBalance(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc721_mint",
+    "Auto-generated from sdk.chain.erc721.mint",
+    asRawShape(sdkSchemas.Erc721MintInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc721.mint(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_erc721_transfer",
+    "Auto-generated from sdk.chain.erc721.transfer",
+    asRawShape(sdkSchemas.Erc721TransferInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.erc721.transfer(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_weth_wrap_eth",
+    "Auto-generated from sdk.chain.weth.wrapEth",
+    asRawShape(sdkSchemas.WethWrapEthInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.weth.wrapEth(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_weth_unwrap_eth",
+    "Auto-generated from sdk.chain.weth.unwrapEth",
+    asRawShape(sdkSchemas.WethUnwrapEthInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.weth.unwrapEth(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_compound_supply",
+    "Auto-generated from sdk.chain.compound.supply",
+    asRawShape(sdkSchemas.CompoundSupplyInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.compound.supply(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_compound_withdraw",
+    "Auto-generated from sdk.chain.compound.withdraw",
+    asRawShape(sdkSchemas.CompoundSupplyInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.compound.withdraw(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_compound_borrow",
+    "Auto-generated from sdk.chain.compound.borrow",
+    asRawShape(sdkSchemas.CompoundSupplyInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.compound.borrow(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_compound_repay",
+    "Auto-generated from sdk.chain.compound.repay",
+    asRawShape(sdkSchemas.CompoundSupplyInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.compound.repay(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_compound_get_portfolio",
+    "Auto-generated from sdk.chain.compound.getPortfolio",
+    asRawShape(sdkSchemas.CompoundGetPortfolioInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.compound.getPortfolio(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_morpho_deposit",
+    "Auto-generated from sdk.chain.morpho.deposit",
+    asRawShape(sdkSchemas.MorphoDepositInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.morpho.deposit(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_morpho_withdraw",
+    "Auto-generated from sdk.chain.morpho.withdraw",
+    asRawShape(sdkSchemas.MorphoDepositInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.morpho.withdraw(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_enso_route",
+    "Auto-generated from sdk.chain.enso.route",
+    asRawShape(sdkSchemas.EnsoRouteInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.enso.route(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_enso_bridge",
+    "Auto-generated from sdk.chain.enso.bridge",
+    asRawShape(sdkSchemas.EnsoBridgeInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.enso.bridge(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_pyth_fetch_price_feed",
+    "Auto-generated from sdk.chain.pyth.fetchPriceFeed",
+    asRawShape(sdkSchemas.PythFetchPriceFeedInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.pyth.fetchPriceFeed(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_pyth_fetch_price",
+    "Auto-generated from sdk.chain.pyth.fetchPrice",
+    asRawShape(sdkSchemas.PythFetchPriceInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.pyth.fetchPrice(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_defillama_find_protocol",
+    "Auto-generated from sdk.chain.defillama.findProtocol",
+    asRawShape(sdkSchemas.DefillamaFindProtocolInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.defillama.findProtocol(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_defillama_get_protocol",
+    "Auto-generated from sdk.chain.defillama.getProtocol",
+    asRawShape(sdkSchemas.DefillamaGetProtocolInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.defillama.getProtocol(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_defillama_get_token_prices",
+    "Auto-generated from sdk.chain.defillama.getTokenPrices",
+    asRawShape(sdkSchemas.DefillamaGetTokenPricesInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.defillama.getTokenPrices(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_x402_make_http_request",
+    "Auto-generated from sdk.chain.x402.makeHttpRequest",
+    asRawShape(sdkSchemas.X402MakeHttpRequestInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.x402.makeHttpRequest(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "chain_x402_discover_services",
+    "Auto-generated from sdk.chain.x402.discoverServices",
+    asRawShape(sdkSchemas.X402DiscoverServicesInput),
+    async (args) => {
+      const result = await Promise.resolve(client.chain.x402.discoverServices(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_search_markets",
+    "Auto-generated from sdk.predict.searchMarkets",
+    asRawShape(sdkSchemas.SearchMarketsInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.searchMarkets(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_search_events",
+    "Auto-generated from sdk.predict.searchEvents",
+    asRawShape(sdkSchemas.SearchEventsInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.searchEvents(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_get_market",
+    "Auto-generated from sdk.predict.getMarket",
+    asRawShape(sdkSchemas.GetMarketInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.getMarket(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_get_orderbook",
+    "Auto-generated from sdk.predict.getOrderbook",
+    asRawShape(sdkSchemas.GetOrderbookInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.getOrderbook(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_strategy_playbook",
+    "Auto-generated from sdk.predict.strategyPlaybook",
+    asRawShape(sdkSchemas.StrategyPlaybookInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.strategyPlaybook(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_create_order",
+    "Auto-generated from sdk.predict.createOrder",
+    asRawShape(sdkSchemas.CreateOrderInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.createOrder(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_cancel_order",
+    "Auto-generated from sdk.predict.cancelOrder",
+    asRawShape(sdkSchemas.CancelOrderInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.cancelOrder(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_positions",
+    "Auto-generated from sdk.predict.positions",
+    asRawShape(sdkSchemas.PositionsInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.positions(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_open_orders",
+    "Auto-generated from sdk.predict.openOrders",
+    asRawShape(sdkSchemas.OpenOrdersInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.openOrders(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_my_trades",
+    "Auto-generated from sdk.predict.myTrades",
+    asRawShape(sdkSchemas.MyTradesInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.myTrades(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "predict_get_order",
+    "Auto-generated from sdk.predict.getOrder",
+    asRawShape(sdkSchemas.GetOrderInput),
+    async (args) => {
+      const result = await Promise.resolve(client.predict.getOrder(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_list",
+    "GET /api/threads \u2192 returns the list of threads for the authed user",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.threads.list());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_search",
+    "GET /api/threads/search?q=",
+    asRawShape(sdkSchemas.SearchInput),
+    async (args) => {
+      const result = await Promise.resolve(client.threads.search(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_get_messages",
+    "GET /api/threads/:id/messages",
+    asRawShape(sdkSchemas.GetMessagesInput),
+    async (args) => {
+      const result = await Promise.resolve(client.threads.getMessages(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_summary",
+    "GET /api/threads/:id/summary \u2014 compact summary for voice agent context",
+    asRawShape(sdkSchemas.SummaryInput),
+    async (args) => {
+      const result = await Promise.resolve(client.threads.summary(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_delete",
+    "DELETE /api/threads/:id",
+    asRawShape(sdkSchemas.DeleteInput),
+    async (args) => {
+      const result = await Promise.resolve(client.threads.delete(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_send_message",
+    "POST /api/messages",
+    asRawShape(sdkSchemas.SendMessageInput),
+    async (args) => {
+      const result = await Promise.resolve(client.threads.sendMessage(args));
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_generate_id",
+    "Pure local UUID v4. Mirrors `noya_generate_thread_id` MCP tool \u2014 useful for generating a stable threadId before sending the first message",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.threads.generateId());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "threads_agent_summary",
+    "GET /api/agents/summarize \u2014 list of agents and their specialties",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.threads.agentSummary());
+      return toMcpResult(result);
+    }
+  );
+  server.tool(
+    "portfolio_get",
+    "GET /api/user/summary \u2014 wraps `noya_get_portfolio` MCP semantics by returning the user's identity + holdings + DCA + polymarket data in one shot. Falls back to the raw response if `data` is missing",
+    {},
+    async () => {
+      const result = await Promise.resolve(client.portfolio.get());
+      return toMcpResult(result);
+    }
+  );
+}
+
+// src/index.ts
+function registerTools(server, getClient) {
+  registerGeneratedTools(server, getClient);
+}
+
+// src/stdio.ts
+async function main() {
+  const apiKey = process.env.NOYA_API_KEY;
+  const bearer = process.env.NOYA_BEARER;
+  if (!apiKey && !bearer) {
+    process.stderr.write(
+      "noya-mcp requires NOYA_API_KEY (or NOYA_BEARER) to authenticate against agent-api.noya.ai\n"
+    );
+    process.exit(1);
+  }
+  const sdk = new import_sdk.NoyaSDK({
+    ...apiKey ? { apiKey } : {},
+    ...bearer ? { bearer } : {},
+    ...process.env.NOYA_AGENT_API_URL ? { noyaAgentApiUrl: process.env.NOYA_AGENT_API_URL } : {},
+    ...process.env.NOYA_DATA_SERVER_URL ? { dataServerUrl: process.env.NOYA_DATA_SERVER_URL } : {},
+    ...process.env.NOYA_SIGNER_URL ? { signer: { url: process.env.NOYA_SIGNER_URL } } : {}
+  });
+  const server = new import_mcp.McpServer({
+    name: "noya-mcp",
+    version: "0.0.0"
+  });
+  registerTools(server, () => sdk);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  process.stderr.write(`noya-mcp failed: ${String(err)}
+`);
+  process.exit(1);
+});