@continuumdao/ctm-mpc-defi 0.2.48 → 0.2.50

package/dist/agent/catalog.cjs

@@ -4,6 +4,7 @@ var viem = require('viem');
 var api = require('@morpho-org/midnight-sdk/api');
 var zodToJsonSchema = require('zod-to-json-schema');
 var zod = require('zod');
+require('@msgpack/msgpack');
 var module$1 = require('module');
 var url = require('url');
 var fs = require('fs');
@@ -1302,6 +1303,14 @@ function aliasField(o, target, ...sources) {
   const val = firstDefined(...sources.map((k) => o[k]));
   if (val != null) o[target] = val;
 }
+function normalizeHyperliquidTrailingOffsetType(o) {
+  const raw = String(o.trailingOffsetType ?? "").trim().toLowerCase();
+  if (!raw) return;
+  if (raw === "price" || raw === "px" || raw === "distance") o.trailingOffsetType = "price";
+  else if (raw === "percentage" || raw === "percent" || raw === "pct" || raw === "%") {
+    o.trailingOffsetType = "percentage";
+  }
+}
 function derivePurposeIfMissing(o, build) {
   const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
   if (purposeText) {
@@ -1378,18 +1387,40 @@ function preprocessHyperliquidLimitOrderInput(raw) {
   aliasField(o, "szHuman", "szHuman", "sz", "size");
   aliasField(o, "takeProfitTriggerPxHuman", "takeProfitTriggerPxHuman", "takeProfitPxHuman", "tpTriggerPxHuman", "targetPxHuman");
   aliasField(o, "stopLossTriggerPxHuman", "stopLossTriggerPxHuman", "stopLossPxHuman", "slTriggerPxHuman", "invalidationPxHuman");
+  aliasField(o, "trailingOffsetHuman", "trailingOffsetHuman", "retracement", "trailingOffset");
+  aliasField(o, "trailingOffsetType", "trailingOffsetType", "retracementUnit", "offsetType");
+  aliasField(o, "trailingActivationPxHuman", "trailingActivationPxHuman", "activationPx", "activationPrice");
+  normalizeHyperliquidTrailingOffsetType(o);
   derivePurposeIfMissing(o, (x) => {
     const coin = String(x.coin ?? "").trim();
     const side = x.isBuy === true || x.isBuy === "true" ? "buy" : "sell";
     const sz = String(x.szHuman ?? "").trim();
     const tp = String(x.takeProfitTriggerPxHuman ?? "").trim();
     const sl = String(x.stopLossTriggerPxHuman ?? "").trim();
+    const trail = String(x.trailingOffsetHuman ?? "").trim();
+    if (coin && sz && trail) return `HL trailing ${side} ${coin} ${sz}`;
     if (coin && sz && (tp || sl)) return `HL bracket ${side} ${coin} ${sz}`;
     if (coin && sz) return `HL limit ${side} ${coin} ${sz}`;
     return void 0;
   });
   return o;
 }
+function preprocessHyperliquidTrailingStopInput(raw) {
+  const o = preprocessHyperliquidCoinInput(raw);
+  if (!preprocessObject(o)) return raw;
+  aliasField(o, "szHuman", "szHuman", "sz", "size");
+  aliasField(o, "trailingOffsetHuman", "trailingOffsetHuman", "retracement", "trailingOffset");
+  aliasField(o, "trailingOffsetType", "trailingOffsetType", "retracementUnit", "offsetType");
+  aliasField(o, "trailingActivationPxHuman", "trailingActivationPxHuman", "activationPx", "activationPrice");
+  normalizeHyperliquidTrailingOffsetType(o);
+  derivePurposeIfMissing(o, (x) => {
+    const coin = String(x.coin ?? "").trim();
+    const offset = String(x.trailingOffsetHuman ?? "").trim();
+    if (coin && offset) return `HL trailing stop ${coin} ${offset}`;
+    return void 0;
+  });
+  return o;
+}
 function preprocessHyperliquidCloseInput(raw) {
   const o = preprocessHyperliquidCoinInput(raw);
   if (!preprocessObject(o)) return raw;
@@ -2716,7 +2747,15 @@ var MCP_NON_SUBMIT_TOOL_NAMES = /* @__PURE__ */ new Set([
   "ctm_uniswap_v4_limit_order_quote",
   "ctm_uniswap_v4_fetch_limit_orders",
   "ctm_uniswap_v4_check_permissions",
-  "ctm_uniswap_v4_kyc_apply_link"
+  "ctm_uniswap_v4_kyc_apply_link",
+  "search_prediction_markets",
+  "get_prediction_market",
+  "ctm_trueo_fetch_categories",
+  "ctm_trueo_fetch_trending",
+  "ctm_trueo_search_markets",
+  "ctm_trueo_fetch_market",
+  "ctm_trueo_fetch_chance_series",
+  "ctm_trueo_fetch_orderbook"
 ]);
 
 // src/agent/schemas/protocols.ts
@@ -4572,6 +4611,34 @@ var mcpGmxFetchOhlcvOutputSchema = zod.z.object({
   candleCount: zod.z.number().int().nonnegative(),
   candles: zod.z.array(gmxOhlcvCandleSchema)
 });
+function hyperliquidFloatToWire(value) {
+  const n = typeof value === "number" ? value : Number.parseFloat(String(value).trim());
+  if (!Number.isFinite(n)) throw new Error("Invalid Hyperliquid wire number.");
+  const rounded = n.toFixed(8);
+  if (Math.abs(Number.parseFloat(rounded) - n) >= 1e-12) {
+    throw new Error(`Hyperliquid wire value ${value} has too many decimal places.`);
+  }
+  const normalized = Number(rounded === "-0" ? "0" : rounded);
+  return String(normalized);
+}
+var HYPERLIQUID_TRAILING_ACTIVATION_PX_ERROR = "Invalid trailing activation price.";
+var POSITIVE_DECIMAL_RE = /^\d+(\.\d+)?$/;
+function parseHyperliquidTrailingActivationPx(value) {
+  if (value == null) return null;
+  const raw = String(value).trim().replace(/,/g, "");
+  if (!raw) return null;
+  if (!POSITIVE_DECIMAL_RE.test(raw)) {
+    throw new Error(HYPERLIQUID_TRAILING_ACTIVATION_PX_ERROR);
+  }
+  const px = Number.parseFloat(raw);
+  if (!Number.isFinite(px) || px <= 0) {
+    throw new Error(HYPERLIQUID_TRAILING_ACTIVATION_PX_ERROR);
+  }
+  hyperliquidFloatToWire(raw);
+  return raw;
+}
+
+// src/agent/schemas/hyperliquid.ts
 function mcpHyperliquidMultisignInput(fields, preprocess) {
   const inner = evmMultisignCommonInputSchema.extend(fields);
   const shaped = preprocess ? zod.z.preprocess(preprocess, inner) : inner;
@@ -4719,7 +4786,16 @@ var mcpHyperliquidFetchOpenOrdersOutputSchema = zod.z.object({
       sz: zod.z.string(),
       oid: zod.z.number().describe("Pass to build_cancel_multisign as oid"),
       timestamp: zod.z.number(),
-      reduceOnly: zod.z.boolean().optional()
+      reduceOnly: zod.z.boolean().optional(),
+      isTrigger: zod.z.boolean().optional(),
+      triggerPx: zod.z.string().optional(),
+      triggerCondition: zod.z.string().optional(),
+      orderType: zod.z.string().optional(),
+      trailingStop: zod.z.object({
+        retracement: zod.z.string(),
+        activationPx: zod.z.string().nullable(),
+        bestPx: zod.z.string().nullable()
+      }).nullable().optional()
     })
   )
 });
@@ -4844,6 +4920,16 @@ var mcpHyperliquidFetchDelegationsOutputSchema = zod.z.object({
   )
 });
 var hyperliquidTpslExecModeSchema = zod.z.enum(["limit_at_trigger", "market"]);
+var mcpHyperliquidTrailingActivationPxSchema = zod.z.string().min(1).optional().superRefine((value, ctx) => {
+  try {
+    parseHyperliquidTrailingActivationPx(value);
+  } catch (e) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: e instanceof Error ? e.message : "Invalid trailing activation price."
+    });
+  }
+}).describe("Optional mark price where trailing tracking begins. Omit to start immediately.");
 var mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidMultisignInput(
   {
     coin: zod.z.string().min(1).describe("coin from fetch_markets (name) or search_markets"),
@@ -4855,10 +4941,30 @@ var mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidMultisignInput(
     dex: zod.z.string().optional(),
     takeProfitTriggerPxHuman: zod.z.string().min(1).optional().describe("Take-profit trigger price \u2014 with SL enables L1 normalTpsl bracket (EIP-712, not CoreWriter)."),
     stopLossTriggerPxHuman: zod.z.string().min(1).optional().describe("Stop-loss trigger price \u2014 with TP enables L1 normalTpsl bracket (EIP-712, not CoreWriter)."),
-    tpslExecMode: hyperliquidTpslExecModeSchema.optional().describe("Trigger execution: limit_at_trigger (default) or market.")
+    tpslExecMode: hyperliquidTpslExecModeSchema.optional().describe("Trigger execution: limit_at_trigger (default) or market."),
+    trailingOffsetHuman: zod.z.string().min(1).optional().describe(
+      "Trailing-stop retracement (price distance or percent). Cannot combine with stopLossTriggerPxHuman. Perp only \u2014 EIP-712 /exchange."
+    ),
+    trailingOffsetType: zod.z.enum(["price", "percentage"]).optional().describe("price = fixed distance; percentage = retracement rate (default)."),
+    trailingActivationPxHuman: mcpHyperliquidTrailingActivationPxSchema
   },
   preprocessHyperliquidLimitOrderInput
 );
+var mcpHyperliquidTrailingStopInputSchema = mcpHyperliquidMultisignInput(
+  {
+    coin: zod.z.string().min(1).describe("perp coin from fetch_markets or fetch_positions"),
+    isBuy: agentBooleanSchema().describe(
+      "Execution side: false to close a long / open a short; true to close a short / open a long."
+    ),
+    szHuman: zod.z.string().min(1).describe("Size in coin units (use position size to close)."),
+    reduceOnly: agentBooleanSchema().optional().describe("true (default) closes/reduces; false can open a position."),
+    trailingOffsetHuman: zod.z.string().min(1).describe("Retracement distance or percent (e.g. 2 or 2%)."),
+    trailingOffsetType: zod.z.enum(["price", "percentage"]).optional().describe("price = fixed distance; percentage = retracement rate (default)."),
+    trailingActivationPxHuman: mcpHyperliquidTrailingActivationPxSchema,
+    dex: zod.z.string().optional()
+  },
+  preprocessHyperliquidTrailingStopInput
+);
 var mcpHyperliquidCloseInputSchema = mcpHyperliquidMultisignInput(
   {
     coin: zod.z.string().min(1),
@@ -5190,6 +5296,512 @@ var mcpArcusBuildWithdrawMultisignInputSchema = withMultisignKeySourceRefine(
     product: arcusFundProductSchema
   })
 );
+var mcpTrueoFetchCategoriesInputSchema = zod.z.object({}).passthrough();
+var mcpTrueoFetchCategoriesOutputSchema = zod.z.object({
+  categories: zod.z.array(zod.z.object({ id: zod.z.number(), name: zod.z.string() })),
+  chainId: zod.z.number()
+});
+var mcpTrueoMarketRowSchema = zod.z.object({
+  address: zod.z.string(),
+  question: zod.z.string(),
+  rules: zod.z.string(),
+  source: zod.z.string(),
+  categories: zod.z.array(zod.z.string()),
+  size: zod.z.string(),
+  tvl: zod.z.number().nullable(),
+  yesTokenAddress: zod.z.string(),
+  noTokenAddress: zod.z.string(),
+  yesPoolAddress: zod.z.string(),
+  noPoolAddress: zod.z.string(),
+  paymentTokenAddress: zod.z.string(),
+  paymentTokenSymbol: zod.z.string(),
+  paymentTokenDecimals: zod.z.number(),
+  endOfTrading: zod.z.number(),
+  status: zod.z.number(),
+  outcome: zod.z.number().optional(),
+  statusUpdatedAt: zod.z.string().nullable().optional(),
+  imageUrl: zod.z.string().nullable(),
+  yesPoolTick: zod.z.number().nullable(),
+  noPoolTick: zod.z.number().nullable(),
+  yesPoolSqrtPriceX96: zod.z.string().nullable(),
+  noPoolSqrtPriceX96: zod.z.string().nullable(),
+  yesPrice: zod.z.number().nullable(),
+  noPrice: zod.z.number().nullable(),
+  yesPriceLabel: zod.z.string().nullable(),
+  noPriceLabel: zod.z.string().nullable(),
+  expiresAt: zod.z.string().nullable(),
+  expiresAtLabel: zod.z.string().nullable(),
+  chainId: zod.z.number(),
+  network: zod.z.string()
+});
+var mcpTrueoFetchTrendingInputSchema = zod.z.object({
+  limit: zod.z.number().int().positive().optional(),
+  includeAll: agentOptionalBooleanSchema().describe(
+    "If true, include older closed/resolved markets. Default: live and recently finished (14 days)."
+  )
+});
+var mcpTrueoFetchTrendingOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpTrueoMarketRowSchema),
+  notes: zod.z.string(),
+  hasMore: zod.z.boolean().optional(),
+  nextOffset: zod.z.number().int().nonnegative().optional()
+});
+var mcpTrueoSearchMarketsInputSchema = zod.z.object({
+  query: zod.z.string().optional().describe("Search haystack: question, rules, categories, address"),
+  category: zod.z.string().optional().describe("Category name from fetch_categories, e.g. Politics"),
+  limit: zod.z.number().int().positive().optional(),
+  offset: zod.z.number().int().nonnegative().optional(),
+  includeAll: agentOptionalBooleanSchema().describe(
+    "If true, include older closed/resolved markets. Default: live and recently finished (14 days)."
+  ),
+  excludeAddresses: zod.z.array(zod.z.string()).optional().describe("Skip these market addresses (after trending, pass the listed addresses).")
+});
+var mcpTrueoSearchMarketsOutputSchema = mcpTrueoFetchTrendingOutputSchema;
+var mcpTrueoFetchMarketInputSchema = zod.z.object({
+  marketAddress: evmAddressSchema.describe("Trueo market address")
+});
+var mcpTrueoFetchMarketOutputSchema = mcpTrueoMarketRowSchema;
+var mcpTrueoFetchChanceSeriesInputSchema = zod.z.object({
+  poolId: zod.z.string().min(1).describe("Yes or No pool id from fetch_market"),
+  from: zod.z.number().optional(),
+  to: zod.z.number().optional(),
+  resolution: zod.z.string().optional().describe("Sample step in seconds (3600 = hourly). 1H/1D/1W/All coerce to hourly \u2014 Trueo rejects calendar 1D/1W."),
+  lookbackDays: zod.z.number().optional()
+});
+var mcpTrueoFetchChanceSeriesOutputSchema = zod.z.object({
+  poolId: zod.z.string(),
+  bars: zod.z.array(
+    zod.z.object({
+      timestamp: zod.z.number(),
+      open: zod.z.number(),
+      high: zod.z.number(),
+      low: zod.z.number(),
+      close: zod.z.number()
+    })
+  ),
+  from: zod.z.number(),
+  to: zod.z.number(),
+  resolution: zod.z.string(),
+  notes: zod.z.string().optional()
+});
+var mcpTrueoFetchOrderbookInputSchema = zod.z.object({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]).optional(),
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpTrueoFetchOrderbookOutputSchema = zod.z.object({
+  marketAddress: zod.z.string(),
+  side: zod.z.enum(["yes", "no"]),
+  poolId: zod.z.string(),
+  currentTick: zod.z.number().nullable(),
+  impliedPrice: zod.z.number().nullable(),
+  impliedPriceLabel: zod.z.string().nullable(),
+  levels: zod.z.array(zod.z.record(zod.z.unknown())),
+  recentTrades: zod.z.array(zod.z.record(zod.z.unknown())),
+  notes: zod.z.string()
+});
+var mcpSearchPredictionMarketsInputSchema = zod.z.object({
+  query: zod.z.string().optional().describe(
+    "Pass the operator topic verbatim (case-insensitive title substring). Do not substitute a category name. Empty lists trending."
+  ),
+  category: zod.z.string().optional().describe("Venue category, e.g. Politics"),
+  venues: zod.z.array(zod.z.string()).optional().describe("Optional venue filter. v1: trueo"),
+  trending: agentOptionalBooleanSchema().describe(
+    "Trending board only when query and category are empty. Ignored when query is set."
+  ),
+  includeAll: agentOptionalBooleanSchema().describe(
+    "If true, include older closed/resolved markets. Default: live and recently finished (14 days)."
+  ),
+  limit: zod.z.number().int().positive().optional().describe("Page size. Default 10 (trending API max)."),
+  offset: zod.z.number().int().nonnegative().optional().describe("Search offset for the next page. Trending is page 1 only."),
+  indexBase: zod.z.number().int().nonnegative().optional().describe("Start #N at indexBase+1 so pages continue 11, 12, \u2026"),
+  excludeAddresses: zod.z.array(zod.z.string()).optional().describe("Skip these venueMarketIds (after trending, pass the listed ids).")
+});
+var mcpPredictionMarketRowSchema = zod.z.object({
+  venue: zod.z.string(),
+  venueMarketId: zod.z.string(),
+  question: zod.z.string(),
+  categories: zod.z.array(zod.z.string()),
+  yesPrice: zod.z.number().nullable(),
+  noPrice: zod.z.number().nullable(),
+  yesPriceLabel: zod.z.string().nullable(),
+  noPriceLabel: zod.z.string().nullable(),
+  volume: zod.z.string(),
+  tvl: zod.z.number().nullable(),
+  expiresAt: zod.z.string().nullable(),
+  expiresAtLabel: zod.z.string().nullable(),
+  tradingEndsLabel: zod.z.string().optional(),
+  endOfTrading: zod.z.number().optional(),
+  status: zod.z.string(),
+  outcome: zod.z.number().optional(),
+  statusUpdatedAt: zod.z.string().nullable().optional(),
+  resolutionLabel: zod.z.string().nullable().optional(),
+  chainId: zod.z.number(),
+  paymentSymbol: zod.z.string(),
+  tradable: zod.z.boolean(),
+  index: zod.z.number().int().positive().optional(),
+  rules: zod.z.string().optional(),
+  source: zod.z.string().optional(),
+  imageUrl: zod.z.string().nullable().optional(),
+  ohlc: zod.z.array(
+    zod.z.object({
+      timestamp: zod.z.number(),
+      open: zod.z.number(),
+      high: zod.z.number(),
+      low: zod.z.number(),
+      close: zod.z.number()
+    })
+  ).optional().describe("Hourly Yes-chance samples for the Mini App graph (get_prediction_market).")
+});
+var mcpSearchPredictionMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpPredictionMarketRowSchema),
+  notes: zod.z.string(),
+  hasMore: zod.z.boolean().optional(),
+  nextOffset: zod.z.number().int().nonnegative().optional(),
+  nextIndexBase: zod.z.number().int().nonnegative().optional(),
+  includeAll: zod.z.boolean().optional()
+});
+var mcpListMyPredictionMarketsInputSchema = zod.z.object({
+  tokenAddresses: zod.z.array(zod.z.string()).optional().describe("YES/NO token addresses from get_token_registry (or added after a bet)."),
+  marketAddresses: zod.z.array(zod.z.string()).optional().describe("Trueo market addresses from prior bets.")
+});
+var mcpListMyPredictionMarketsOutputSchema = mcpSearchPredictionMarketsOutputSchema;
+var mcpGetPredictionMarketInputSchema = zod.z.object({
+  venue: zod.z.string().optional().describe("Default trueo"),
+  venueMarketId: zod.z.string().min(1).describe("Venue id (Trueo: market address)")
+});
+var mcpGetPredictionMarketOutputSchema = mcpPredictionMarketRowSchema.passthrough();
+var mcpTrueoWrapTydInputSchema = mcpMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("USDC amount to deposit into the TYD vault")
+});
+var mcpTrueoUnwrapTydInputSchema = mcpMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("TYD share amount to redeem for USDC")
+});
+var mcpTrueoMintInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  amountHuman: zod.z.string().min(1).describe("TYD (or USDC when paymentKind=usdc) amount"),
+  paymentKind: zod.z.enum(["tyd", "usdc"]).optional()
+});
+var mcpTrueoBurnInputSchema = mcpTrueoMintInputSchema;
+var mcpTrueoRedeemInputSchema = mcpTrueoMintInputSchema;
+var mcpTrueoSwapInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]),
+  amountHuman: zod.z.string().min(1).describe("TYD amount in"),
+  amountOutMinimumHuman: zod.z.string().optional()
+});
+var mcpTrueoCreateOrderInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]),
+  amountHuman: zod.z.string().min(1),
+  tickLower: zod.z.number().int(),
+  tickUpper: zod.z.number().int(),
+  enablePartialFill: agentOptionalBooleanSchema()
+});
+var mcpTrueoCancelOrderInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]),
+  orderId: zod.z.number().int().nonnegative()
+});
+function mcpDeriveMultisignInput(fields) {
+  return withMultisignKeySourceRefine(evmMultisignCommonInputSchema.extend(fields));
+}
+var deriveAuthSchema = zod.z.object({
+  wallet: zod.z.string().min(1),
+  timestamp: zod.z.string().min(1),
+  signature: zod.z.string().min(1)
+}).optional().describe("Server-filled EIP-191 login (X-DeriveWallet / Timestamp / Signature). Agents must not pass auth.");
+var deriveNetworkSchema = zod.z.enum(["mainnet", "testnet"]).optional();
+var deriveFetchBaseSchema = zod.z.object({
+  chainId: zod.z.coerce.number().int().positive().optional().describe("Asset-row chain (dialog context). Trading is always Derive API."),
+  network: deriveNetworkSchema
+});
+var deriveWalletSchema = deriveFetchBaseSchema.extend({
+  wallet: evmAddressSchema.optional(),
+  executorAddress: evmAddressSchema.optional().describe("MPC executor \u2014 same address is the Derive owner on every chain."),
+  auth: deriveAuthSchema
+});
+var deriveOhlcvIntervalSchema = zod.z.enum(["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w"]);
+var deriveOhlcvCandleSchema = zod.z.object({
+  timestampMs: zod.z.number(),
+  open: zod.z.string(),
+  high: zod.z.string(),
+  low: zod.z.string(),
+  close: zod.z.string(),
+  volume: zod.z.string()
+});
+var mcpDeriveFetchCurrenciesInputSchema = deriveFetchBaseSchema;
+var mcpDeriveFetchCurrenciesOutputSchema = zod.z.object({
+  currencies: zod.z.array(zod.z.object({ currency: zod.z.string() })),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchOptionChainInputSchema = deriveFetchBaseSchema.extend({
+  currency: zod.z.string().min(1).describe("Underlying currency e.g. ETH"),
+  expired: zod.z.boolean().optional()
+});
+var mcpDeriveFetchOptionChainOutputSchema = zod.z.object({
+  currency: zod.z.string(),
+  instrumentCount: zod.z.number(),
+  callCount: zod.z.number(),
+  putCount: zod.z.number(),
+  expiries: zod.z.array(
+    zod.z.object({
+      expiryYmd: zod.z.string(),
+      expiryUnix: zod.z.number().nullable(),
+      callCount: zod.z.number(),
+      putCount: zod.z.number(),
+      minStrike: zod.z.string().nullable(),
+      maxStrike: zod.z.string().nullable()
+    })
+  ),
+  notes: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchTickersInputSchema = deriveFetchBaseSchema.extend({
+  currency: zod.z.string().min(1).describe("Underlying e.g. ETH"),
+  expiryDate: zod.z.union([zod.z.string().min(1), zod.z.number().int().positive()]).describe("YYYYMMDD from fetch_option_chain. String or number (20260925). 2026-09-25 is ok."),
+  optionType: zod.z.enum(["C", "P"]).optional().describe("Calls only or puts only. Omit for both."),
+  ladder: zod.z.enum(["atm", "all"]).optional().describe("Default atm (~9 strikes around index). Use all only when the operator wants every strike.")
+});
+var mcpDeriveFetchTickersOutputSchema = zod.z.object({
+  currency: zod.z.string(),
+  expiryDate: zod.z.string(),
+  optionType: zod.z.enum(["C", "P"]).nullable().optional(),
+  ladder: zod.z.enum(["atm", "all"]).optional(),
+  indexPx: zod.z.string().nullable().optional(),
+  listedCount: zod.z.number().optional(),
+  tickerCount: zod.z.number().optional(),
+  callCount: zod.z.number().optional(),
+  putCount: zod.z.number().optional(),
+  tickers: zod.z.array(
+    zod.z.object({
+      instrumentName: zod.z.string(),
+      bidPx: zod.z.string().nullable(),
+      askPx: zod.z.string().nullable(),
+      markPx: zod.z.string().nullable(),
+      indexPx: zod.z.string().nullable(),
+      strike: zod.z.string().nullable(),
+      expiry: zod.z.number().nullable(),
+      expiryYmd: zod.z.string().nullable(),
+      optionType: zod.z.enum(["C", "P"]).nullable(),
+      greeks: zod.z.unknown().nullable()
+    })
+  ),
+  notes: zod.z.string().optional(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveSearchInstrumentsInputSchema = deriveFetchBaseSchema.extend({
+  currency: zod.z.string().min(1),
+  query: zod.z.string().min(1).describe("Instrument name fragment e.g. 3000-C or 20260626"),
+  limit: zod.z.coerce.number().int().positive().max(50).optional()
+});
+var mcpDeriveSearchInstrumentsOutputSchema = zod.z.object({
+  instruments: zod.z.array(zod.z.object({ instrumentName: zod.z.string() })),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchMarketSnapshotInputSchema = deriveFetchBaseSchema.extend({
+  instrumentName: zod.z.string().min(1).describe("e.g. ETH-20260626-3000-C")
+});
+var mcpDeriveFetchMarketSnapshotOutputSchema = zod.z.object({
+  snapshot: zod.z.object({
+    instrumentName: zod.z.string(),
+    livePrice: zod.z.object({
+      markPx: zod.z.string().nullable(),
+      indexPx: zod.z.string().nullable(),
+      bidPx: zod.z.string().nullable(),
+      askPx: zod.z.string().nullable(),
+      midUsd: zod.z.string(),
+      source: zod.z.string()
+    }),
+    greeks: zod.z.unknown().nullable(),
+    fetchedAtMs: zod.z.number()
+  }),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchOhlcvInputSchema = deriveFetchBaseSchema.extend({
+  instrumentName: zod.z.string().optional().describe("Required for option candles"),
+  currency: zod.z.string().optional().describe("Required for index candles (underlying spot)"),
+  marketKind: zod.z.enum(["option", "index"]).optional(),
+  interval: deriveOhlcvIntervalSchema.optional(),
+  lookbackDays: zod.z.coerce.number().positive().optional(),
+  lookbackHours: zod.z.coerce.number().positive().optional(),
+  startTimeMs: zod.z.coerce.number().int().positive().optional(),
+  endTimeMs: zod.z.coerce.number().int().positive().optional()
+});
+var mcpDeriveFetchOhlcvOutputSchema = zod.z.object({
+  ohlcv: zod.z.object({
+    market: zod.z.string(),
+    coin: zod.z.string(),
+    interval: zod.z.string(),
+    marketKind: zod.z.enum(["option", "index"]),
+    startTimeMs: zod.z.number(),
+    endTimeMs: zod.z.number(),
+    expectedBars: zod.z.number(),
+    candleCount: zod.z.number(),
+    latestCandle: deriveOhlcvCandleSchema.nullable(),
+    candles: zod.z.array(deriveOhlcvCandleSchema),
+    fetchedAtMs: zod.z.number(),
+    dataSource: zod.z.literal("derive")
+  }),
+  dataSource: zod.z.literal("derive"),
+  network: zod.z.string().optional()
+});
+var mcpDeriveOrderQuoteInputSchema = deriveFetchBaseSchema.extend({
+  instrumentName: zod.z.string().min(1),
+  direction: zod.z.enum(["buy", "sell"]),
+  amount: zod.z.string().min(1),
+  limitPrice: zod.z.string().min(1),
+  subaccountId: agentCoercedIntSchema(zod.z.number().int().positive()).optional().describe("Required by v3 public/order_quote. From ctm_derive_fetch_subaccounts. Never 0.")
+});
+var mcpDeriveOrderQuoteOutputSchema = zod.z.object({
+  quote: jsonObjectSchema,
+  instrumentName: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchRiskUniversesInputSchema = deriveFetchBaseSchema;
+var mcpDeriveFetchRiskUniversesOutputSchema = zod.z.object({
+  universes: zod.z.array(zod.z.unknown()),
+  notes: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchPendingDepositsInputSchema = deriveWalletSchema;
+var mcpDeriveFetchPendingDepositsOutputSchema = zod.z.object({
+  pending: zod.z.array(zod.z.unknown()),
+  credited: zod.z.boolean(),
+  notes: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchSubaccountsInputSchema = deriveWalletSchema;
+var mcpDeriveFetchSubaccountsOutputSchema = zod.z.object({
+  wallet: zod.z.string(),
+  subaccounts: zod.z.array(zod.z.number()),
+  funded: zod.z.boolean(),
+  notes: zod.z.string(),
+  next: zod.z.array(zod.z.string()),
+  network: zod.z.string().optional()
+});
+var deriveSubaccountInput = deriveWalletSchema.extend({
+  subaccountId: agentCoercedIntSchema(zod.z.number().int().positive()).describe(
+    "subaccountId from ctm_derive_fetch_subaccounts. Never 0. If that list is empty, deposit on Ethereum L1 first."
+  )
+});
+var mcpDeriveFetchPortfolioInputSchema = deriveSubaccountInput;
+var mcpDeriveFetchPortfolioOutputSchema = zod.z.object({
+  portfolio: zod.z.unknown(),
+  subaccountId: zod.z.number(),
+  wallet: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchPositionsInputSchema = deriveSubaccountInput;
+var mcpDeriveFetchPositionsOutputSchema = zod.z.object({
+  positions: zod.z.array(zod.z.unknown()),
+  subaccountId: zod.z.number(),
+  wallet: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchOpenOrdersInputSchema = deriveSubaccountInput;
+var mcpDeriveFetchOpenOrdersOutputSchema = zod.z.object({
+  orders: zod.z.array(zod.z.unknown()),
+  subaccountId: zod.z.number(),
+  wallet: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var deriveSubaccountIdField = agentCoercedIntSchema(zod.z.number().int().positive()).describe(
+  "subaccountId from ctm_derive_fetch_subaccounts. Collateral lives on Ethereum L1; EIP-712 orders do not move the current-chain token. If none exist, deposit first."
+);
+var mcpDeriveDepositNewSubaccountInputSchema = mcpDeriveMultisignInput({
+  protocolAsset: evmAddressSchema.describe("collaterals[].address from ctm_derive_fetch_risk_universes"),
+  underlyingErc20: evmAddressSchema.describe("collaterals[].erc20.underlying_erc20 on Ethereum L1 (usually USDC)"),
+  amountHuman: zod.z.string().min(1).describe("Deposit amount in underlying token units"),
+  managerId: agentCoercedIntSchema(zod.z.number().int().positive()).describe("Risk-universe manager_id"),
+  actionManager: evmAddressSchema.optional().describe("Override ACTION_MANAGER (required on mainnet until published)")
+});
+var mcpDeriveRegisterDepositAddressInputSchema = deriveFetchBaseSchema.extend({
+  wallet: evmAddressSchema,
+  managerId: agentCoercedIntSchema(zod.z.number().int().positive()).optional(),
+  subaccountId: agentCoercedIntSchema(zod.z.number().int().nonnegative()).optional()
+});
+var mcpDeriveRegisterDepositAddressOutputSchema = zod.z.object({
+  depositAddress: evmAddressSchema,
+  wallet: evmAddressSchema,
+  managerId: zod.z.number().int().nullable(),
+  subaccountId: zod.z.number().int().nullable(),
+  network: zod.z.string(),
+  notes: zod.z.string()
+});
+var mcpDeriveDepositAddressTransferInputSchema = mcpDeriveMultisignInput({
+  underlyingErc20: evmAddressSchema.describe("Ethereum L1 token to send (usually USDC)"),
+  amountHuman: zod.z.string().min(1),
+  depositAddress: evmAddressSchema.describe("From ctm_derive_register_deposit_address")
+});
+var mcpDeriveSocketDepositInputSchema = mcpDeriveMultisignInput({
+  token: evmAddressSchema.describe("USDC / WETH / WBTC on this chain, or native 0x0 to wrap WETH"),
+  amountHuman: zod.z.string().min(1),
+  receiver: evmAddressSchema.optional().describe("Derive Chain receiver; defaults to executor")
+});
+var mcpDeriveHypeVaultDepositInputSchema = mcpDeriveMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("HYPE amount"),
+  token: evmAddressSchema.optional().describe("Native 0x0 or WHYPE 0x555\u20265"),
+  vault: evmAddressSchema.optional()
+});
+var mcpDerivePlaceOrderInputSchema = mcpDeriveMultisignInput({
+  instrumentName: zod.z.string().min(1).describe("e.g. ETH-20260626-3000-C"),
+  direction: zod.z.enum(["buy", "sell"]),
+  amount: zod.z.string().min(1),
+  limitPrice: zod.z.string().min(1),
+  maxFee: zod.z.string().min(1),
+  subaccountId: deriveSubaccountIdField,
+  orderType: zod.z.enum(["limit", "market"]).optional(),
+  timeInForce: zod.z.enum(["gtc", "ioc", "fok", "post_only"]).optional(),
+  reduceOnly: zod.z.boolean().optional(),
+  label: zod.z.string().optional(),
+  ticketKind: zod.z.enum(["limit", "stop_limit", "twap"]).optional(),
+  triggerPrice: zod.z.string().optional().describe("Required for stop_limit"),
+  triggerType: zod.z.enum(["stoploss", "takeprofit"]).optional(),
+  triggerPriceType: zod.z.enum(["mark", "index"]).optional(),
+  algoDurationSec: agentCoercedIntSchema(zod.z.number().int().min(60)).optional().describe("Required for twap"),
+  algoNumSlices: agentCoercedIntSchema(zod.z.number().int().min(2)).optional().describe("Required for twap")
+});
+var mcpDeriveReplaceOrderInputSchema = mcpDeriveMultisignInput({
+  instrumentName: zod.z.string().min(1),
+  direction: zod.z.enum(["buy", "sell"]),
+  amount: zod.z.string().min(1),
+  limitPrice: zod.z.string().min(1),
+  maxFee: zod.z.string().min(1),
+  subaccountId: deriveSubaccountIdField,
+  orderType: zod.z.enum(["limit", "market"]).optional(),
+  timeInForce: zod.z.enum(["gtc", "ioc", "fok", "post_only"]).optional(),
+  reduceOnly: zod.z.boolean().optional(),
+  label: zod.z.string().optional(),
+  ticketKind: zod.z.enum(["limit", "stop_limit", "twap"]).optional(),
+  triggerPrice: zod.z.string().optional(),
+  triggerType: zod.z.enum(["stoploss", "takeprofit"]).optional(),
+  triggerPriceType: zod.z.enum(["mark", "index"]).optional(),
+  algoDurationSec: agentCoercedIntSchema(zod.z.number().int().min(60)).optional(),
+  algoNumSlices: agentCoercedIntSchema(zod.z.number().int().min(2)).optional(),
+  orderIdToCancel: zod.z.string().min(1).optional(),
+  nonceToCancel: zod.z.string().min(1).optional()
+}).refine((d) => Boolean(d.orderIdToCancel) !== Boolean(d.nonceToCancel), {
+  message: "Replace requires exactly one of orderIdToCancel or nonceToCancel."
+});
+var mcpDeriveCancelInputSchema = mcpDeriveMultisignInput({
+  instrumentName: zod.z.string().min(1),
+  orderId: zod.z.string().min(1).describe("order_id from ctm_derive_fetch_open_orders"),
+  subaccountId: deriveSubaccountIdField
+});
+var mcpDeriveTransferSpotInputSchema = mcpDeriveMultisignInput({
+  fromSubaccountId: deriveSubaccountIdField,
+  toSubaccountId: agentCoercedIntSchema(zod.z.number().int().nonnegative()).describe(
+    "Existing destination, or 0 to create an extra subaccount (requires newSubaccountManager)."
+  ),
+  newSubaccountManager: agentCoercedIntSchema(zod.z.number().int().nonnegative()).describe(
+    "Required when toSubaccountId is 0. Extra subaccounts only \u2014 first account is L1 deposit."
+  ),
+  asset: evmAddressSchema.describe("Protocol asset address"),
+  amount: zod.z.string().min(1),
+  maxFeeUsd: zod.z.string().optional(),
+  subId: agentCoercedIntSchema(zod.z.number().int().nonnegative()).optional()
+});
 var mcpCctpFeeFieldsSchema = zod.z.object({
   feeTierUsed: zod.z.enum(["low", "med", "high"]),
   maxFee: zod.z.string().describe("Selected tier max fee in USDC base units (6 decimals)"),
@@ -5900,11 +6512,21 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     actionId: "hyperliquid.limitOrder",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid limit/IoC order. Plain limit: CoreWriter (useCustomGas). When takeProfitTriggerPxHuman and/or stopLossTriggerPxHuman are set: one L1 EIP-712 normalTpsl bracket (entry + TP/SL) to /exchange \u2014 no useCustomGas.",
+    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid limit/IoC order. Plain limit: CoreWriter (useCustomGas). When takeProfitTriggerPxHuman, stopLossTriggerPxHuman, and/or trailingOffsetHuman are set: L1 EIP-712 to /exchange (normalTpsl for TP/SL; trailingStop is a second signed action) \u2014 no useCustomGas. Trailing cannot combine with a fixed SL. Perp only for trailing.",
     prerequisites: ["keyGenId", "chainId 999 or 998", "coin", "limitPxHuman", "szHuman"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidLimitOrderBatch" },
     inputZod: mcpHyperliquidLimitOrderInputSchema
   }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_trailing_stop_multisign",
+    actionId: "hyperliquid.trailingStop",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid perp trailing stop (EIP-712 L1 trailingStop action to /exchange \u2014 no useCustomGas). Retracement is a price distance or percentage; optional activation price delays tracking. Typically reduce-only to close a position. isBuy false closes a long / opens a short.",
+    prerequisites: ["keyGenId", "chainId 999 or 998", "coin", "szHuman", "trailingOffsetHuman"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildHyperliquidTrailingStopMultisign" },
+    inputZod: mcpHyperliquidTrailingStopInputSchema
+  }),
   defineProtocolMcpTool({
     name: "ctm_hyperliquid_build_close_multisign",
     actionId: "hyperliquid.close",
@@ -6446,6 +7068,188 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     prerequisites: ["keyGenId", "chainId", "comet", "steps"],
     handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Bulker" },
     inputZod: mcpCompoundV3BulkerInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_deposit_new_subaccount_multisign",
+    actionId: "derive.depositNewSubaccount",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Ethereum L1 only (chainId 1 / 11155111): approve the underlying ERC-20 to ACTION_MANAGER, then depositToNewSubaccount. First credit creates the trading + fallback (manager 0) subaccounts. Arb/OP/Base: ctm_derive_build_socket_deposit_multisign. HyperEVM HYPE: ctm_derive_build_hype_vault_deposit_multisign. useCustomGas.",
+    prerequisites: [
+      "chainId 1 or 11155111",
+      "managerId + protocolAsset + underlyingErc20 from ctm_derive_fetch_risk_universes",
+      "Ethereum L1 collateral (usually USDC)"
+    ],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveDepositNewSubaccountMultisign" },
+    inputZod: mcpDeriveDepositNewSubaccountInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_deposit_address_transfer_multisign",
+    actionId: "derive.depositAddressTransfer",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Ethereum L1 ERC-20 transfer to a registered Derive deposit address (standard / keeper sweep). Call ctm_derive_register_deposit_address first. useCustomGas.",
+    prerequisites: ["chainId 1 or 11155111", "depositAddress from ctm_derive_register_deposit_address"],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveDepositAddressTransferMultisign" },
+    inputZod: mcpDeriveDepositAddressTransferInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_socket_deposit_multisign",
+    actionId: "derive.socketDeposit",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Socket FAST deposit of USDC/WETH/WBTC on Ethereum, Optimism, Base, or Arbitrum. Native 0x0 wraps to WETH. Pays a small native bridge fee. useCustomGas.",
+    prerequisites: ["chainId 1 / 10 / 8453 / 42161", "token + amountHuman"],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveSocketDepositMultisign" },
+    inputZod: mcpDeriveSocketDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_hype_vault_deposit_multisign",
+    actionId: "derive.hypeVaultDeposit",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "HyperEVM (999) HYPE vault: wrap native HYPE to WHYPE if needed, approve, deposit. First credit creates a Standard Margin subaccount. useCustomGas.",
+    prerequisites: ["chainId 999", "amountHuman"],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveHypeVaultDepositMultisign" },
+    inputZod: mcpDeriveHypeVaultDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_place_order_multisign",
+    actionId: "derive.placeOrder",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "EIP-712 Derive options order (delivery derive_exchange). Requires subaccountId from ctm_derive_fetch_subaccounts. Does not move the current-chain token unless that row funded the account. No useCustomGas.",
+    prerequisites: [
+      "subaccountId from ctm_derive_fetch_subaccounts",
+      "funded Derive collateral (L1 / Socket / HYPE vault)",
+      "instrumentName, direction, amount, limitPrice, maxFee"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDerivePlaceOrderMultisign" },
+    inputZod: mcpDerivePlaceOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_replace_order_multisign",
+    actionId: "derive.replaceOrder",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "EIP-712 replace of a Derive open order. Requires subaccountId from ctm_derive_fetch_subaccounts and exactly one of orderIdToCancel or nonceToCancel. EIP-712 orders do not move the current-chain token.",
+    prerequisites: [
+      "subaccountId from ctm_derive_fetch_subaccounts",
+      "funded Derive collateral (L1 / Socket / HYPE vault)",
+      "orderIdToCancel or nonceToCancel"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveReplaceOrderMultisign" },
+    inputZod: mcpDeriveReplaceOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_cancel_multisign",
+    actionId: "derive.cancel",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Cancel a Derive open order (v3 private/cancel via EIP-191 login delivery). Requires subaccountId from ctm_derive_fetch_subaccounts. Does not move the current-chain token.",
+    prerequisites: [
+      "subaccountId from ctm_derive_fetch_subaccounts",
+      "orderId from ctm_derive_fetch_open_orders"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveCancelMultisign" },
+    inputZod: mcpDeriveCancelInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_transfer_spot_multisign",
+    actionId: "derive.transferSpot",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "EIP-712 transfer_spot. Use toSubaccountId 0 + newSubaccountManager to create an extra subaccount after the first funded one. First account is a deposit (L1 / Socket / HYPE), not this tool.",
+    prerequisites: [
+      "fromSubaccountId from ctm_derive_fetch_subaccounts",
+      "funded Derive collateral (L1 / Socket / HYPE vault)"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveTransferSpotMultisign" },
+    inputZod: mcpDeriveTransferSpotInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_wrap_tyd_multisign",
+    actionId: "trueo.wrap-tyd",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Mint TYD by depositing Base USDC into the Yearn ERC-4626 vault. Not a market bet. No marketAddress. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "amountHuman (USDC)"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoWrapTyd" },
+    inputZod: mcpTrueoWrapTydInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_unwrap_tyd_multisign",
+    actionId: "trueo.unwrap-tyd",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Redeem TYD shares back to Base USDC via the Yearn ERC-4626 vault. Not a market bet. No marketAddress. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "amountHuman (TYD)"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoUnwrapTyd" },
+    inputZod: mcpTrueoUnwrapTydInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_mint_multisign",
+    actionId: "trueo.mint",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Mint YES+NO from TYD (default) or USDC via TruthMarketAdapter. Base 8453. Not a bet \u2014 allowed near market close. 30-minute multiSign expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress from ctm_trueo_fetch_market", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoMint" },
+    inputZod: mcpTrueoMintInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_burn_multisign",
+    actionId: "trueo.burn",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Burn equal YES+NO back to TYD (or USDC via adapter). Not a bet. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoBurn" },
+    inputZod: mcpTrueoBurnInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_redeem_multisign",
+    actionId: "trueo.redeem",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Redeem winning outcome tokens after resolution. Not a bet. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoRedeem" },
+    inputZod: mcpTrueoRedeemInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_swap_multisign",
+    actionId: "trueo.swap",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Buy Yes or No with TYD via UniversalRouterAdapter V4 swap. Refuses if the market closes within 5 minutes. extraJSON stores endOfTrading for Get Sig/Execute. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "side", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoSwap" },
+    inputZod: mcpTrueoSwapInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_create_order_multisign",
+    actionId: "trueo.create-order",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Create an OrderManager limit order (Yes or No). Refuses if the market closes within 5 minutes. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "side", "amountHuman", "tickLower", "tickUpper"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoCreateOrder" },
+    inputZod: mcpTrueoCreateOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_cancel_order_multisign",
+    actionId: "trueo.cancel-order",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Cancel an OrderManager order. Not a bet \u2014 allowed after close. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "side", "orderId"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoCancelOrder" },
+    inputZod: mcpTrueoCancelOrderInputSchema
   })
 ];
 
@@ -8726,6 +9530,310 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     ],
     handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemRewardsBatch" },
     inputZod: mcpPendleBuildRedeemRewardsMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_currencies",
+    actionId: "derive.fetch-currencies",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "List Derive currencies from public/get_all_currencies. Used to map asset-row symbols (ETH, USDC, BTC, \u2026). load_defi_protocol derive activates defi:derive:market-data.",
+    prerequisites: ["load_defi_protocol derive"],
+    followUp: ["ctm_derive_fetch_option_chain", "ctm_derive_fetch_tickers", "ctm_derive_search_instruments"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchCurrenciesSummary" },
+    inputZod: mcpDeriveFetchCurrenciesInputSchema,
+    outputZod: mcpDeriveFetchCurrenciesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_option_chain",
+    actionId: "derive.fetch-option-chain",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Compact Derive expiry ladder for a currency (counts + min/max strike per YYYYMMDD). Does not dump every instrument. Then ctm_derive_fetch_tickers for that expiry.",
+    prerequisites: ["currency e.g. ETH"],
+    followUp: ["ctm_derive_fetch_tickers", "ctm_derive_search_instruments", "ctm_derive_fetch_market_snapshot"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOptionChainAgentSummary" },
+    inputZod: mcpDeriveFetchOptionChainInputSchema,
+    outputZod: mcpDeriveFetchOptionChainOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_tickers",
+    actionId: "derive.fetch-tickers",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: 'ATM strike/premium ladder for one Derive expiry (bid/ask/mark). expiryDate is YYYYMMDD \u2014 string or number. Default ~9 strikes around index; pass ladder:"all" for every strike.',
+    prerequisites: ["currency", "expiryDate YYYYMMDD (string or number)"],
+    followUp: ["ctm_derive_fetch_market_snapshot", "ctm_derive_order_quote", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchTickersSummary" },
+    inputZod: mcpDeriveFetchTickersInputSchema,
+    outputZod: mcpDeriveFetchTickersOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_search_instruments",
+    actionId: "derive.search-instruments",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Search Derive option instrument names by strike, expiry, or C/P suffix.",
+    prerequisites: ["currency", "query"],
+    followUp: ["ctm_derive_fetch_market_snapshot", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveSearchInstrumentsSummary" },
+    inputZod: mcpDeriveSearchInstrumentsInputSchema,
+    outputZod: mcpDeriveSearchInstrumentsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_market_snapshot",
+    actionId: "derive.fetch-market-snapshot",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Live Derive ticker: mark, index, bid/ask, greeks. Throws if no live price.",
+    prerequisites: ["instrumentName from fetch_option_chain"],
+    followUp: ["ctm_derive_fetch_ohlcv", "ctm_derive_order_quote", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchMarketSnapshotSummary" },
+    inputZod: mcpDeriveFetchMarketSnapshotInputSchema,
+    outputZod: mcpDeriveFetchMarketSnapshotOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_ohlcv",
+    actionId: "derive.fetch-ohlcv",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: 'OHLCV for a Derive option (instrumentName) or underlying index (currency + marketKind index). Default is ~96 bars for the interval (not a 14-day dump). Envelope { ohlcv, dataSource: "derive" }. Then continuum__prepare_chart_from_rows if the user wants a chart.',
+    prerequisites: ["instrumentName or currency"],
+    followUp: ["continuum__prepare_chart_from_rows", "ctm_derive_fetch_market_snapshot"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOhlcvSummary" },
+    inputZod: mcpDeriveFetchOhlcvInputSchema,
+    outputZod: mcpDeriveFetchOhlcvOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_order_quote",
+    actionId: "derive.order-quote",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Dry-run Derive fill / margin preview (public/order_quote).",
+    prerequisites: ["instrumentName", "direction", "amount", "limitPrice"],
+    followUp: ["ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveOrderQuoteSummary" },
+    inputZod: mcpDeriveOrderQuoteInputSchema,
+    outputZod: mcpDeriveOrderQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_risk_universes",
+    actionId: "derive.fetch-risk-universes",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "List Derive risk universes (manager_id + collaterals). Required before the first deposit. Pick a manager that lists ETH options and USDC (or the row currency).",
+    prerequisites: ["activate_tool_group defi:derive:options"],
+    followUp: [
+      "ctm_derive_build_deposit_new_subaccount_multisign",
+      "ctm_derive_register_deposit_address",
+      "ctm_derive_build_socket_deposit_multisign",
+      "ctm_derive_build_hype_vault_deposit_multisign"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchRiskUniversesSummary" },
+    inputZod: mcpDeriveFetchRiskUniversesInputSchema,
+    outputZod: mcpDeriveFetchRiskUniversesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_pending_deposits",
+    actionId: "derive.fetch-pending-deposits",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Poll public/get_pending_deposits for the KeyGen wallet. credited:false means wait; then call fetch_subaccounts. First deposit is L1, Socket (ETH/OP/Base/Arb), or HyperEVM HYPE.",
+    prerequisites: ["wallet / executorAddress"],
+    followUp: ["ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchPendingDepositsSummary" },
+    inputZod: mcpDeriveFetchPendingDepositsInputSchema,
+    outputZod: mcpDeriveFetchPendingDepositsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_register_deposit_address",
+    actionId: "derive.register-deposit-address",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "public/register_deposit_address \u2014 deterministic Ethereum L1 deposit address for this wallet. Then transfer the token with ctm_derive_build_deposit_address_transfer_multisign. Do not send from Base/Arb to this address.",
+    prerequisites: ["wallet", "managerId (new subaccount) or subaccountId (existing)"],
+    followUp: ["ctm_derive_build_deposit_address_transfer_multisign", "ctm_derive_fetch_pending_deposits"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveRegisterDepositAddress" },
+    inputZod: mcpDeriveRegisterDepositAddressInputSchema,
+    outputZod: mcpDeriveRegisterDepositAddressOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_subaccounts",
+    actionId: "derive.fetch-subaccounts",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "List Derive subaccount ids for the KeyGen executor. Empty list returns funded:false and notes to deposit from a fundable logo row (L1 / Socket / HYPE vault). Two ids after first credit is normal (trading + fallback manager 0).",
+    prerequisites: ["wallet / executorAddress", "node-cached EIP-191 login"],
+    followUp: ["ctm_derive_fetch_portfolio", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchSubaccountsSummary" },
+    inputZod: mcpDeriveFetchSubaccountsInputSchema,
+    outputZod: mcpDeriveFetchSubaccountsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_portfolio",
+    actionId: "derive.fetch-portfolio",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Derive private/get_subaccount portfolio for a funded subaccountId.",
+    prerequisites: ["subaccountId from ctm_derive_fetch_subaccounts"],
+    followUp: ["ctm_derive_fetch_positions", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchPortfolioSummary" },
+    inputZod: mcpDeriveFetchPortfolioInputSchema,
+    outputZod: mcpDeriveFetchPortfolioOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_positions",
+    actionId: "derive.fetch-positions",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Open Derive option positions for a subaccountId from fetch_subaccounts.",
+    prerequisites: ["subaccountId from ctm_derive_fetch_subaccounts"],
+    followUp: ["ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchPositionsSummary" },
+    inputZod: mcpDeriveFetchPositionsInputSchema,
+    outputZod: mcpDeriveFetchPositionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_open_orders",
+    actionId: "derive.fetch-open-orders",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Open Derive orders for a subaccountId. Follow with cancel/replace.",
+    prerequisites: ["subaccountId from ctm_derive_fetch_subaccounts"],
+    followUp: ["ctm_derive_build_cancel_multisign", "ctm_derive_build_replace_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOpenOrdersSummary" },
+    inputZod: mcpDeriveFetchOpenOrdersInputSchema,
+    outputZod: mcpDeriveFetchOpenOrdersOutputSchema
+  }),
+  defineMcpTool({
+    name: "search_prediction_markets",
+    actionId: "prediction-markets.search",
+    protocolId: "prediction-markets",
+    chainCategory: "evm",
+    description: 'Venue-agnostic prediction market search for MPA chat. v1 adapter is Trueo on Base. Pass the operator topic verbatim as query (case-insensitive title substring). Do not substitute a category or synonym. Do not set trending when query is set. Empty query lists trending (max 10; cannot page). If hasMore, call again with offset/nextOffset, trending=false, indexBase=nextIndexBase, excludeAddresses of listed venueMarketIds. Default: live and recently finished (14 days) \u2014 do not pass includeAll unless the operator asked for closed or historical markets. If the live board is empty, say so. After a pick, get_prediction_market. Writes (mint / limit / burn / redeem / Yes-No swap) are not in the opening catalog \u2014 load_defi_protocol({ protocolId: "trueo" }) then get_defi_protocol_skill or search_continuum_tools for ctm_trueo_build_*.',
+    prerequisites: [],
+    followUp: ["get_prediction_market", "load_defi_protocol", "get_defi_protocol_skill"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "searchPredictionMarketsSummary" },
+    inputZod: mcpSearchPredictionMarketsInputSchema,
+    outputZod: mcpSearchPredictionMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "get_prediction_market",
+    actionId: "prediction-markets.get",
+    protocolId: "prediction-markets",
+    chainCategory: "evm",
+    description: 'Full selected prediction market (rules, Yes/No, volume, TVL, expiry). Use after search_prediction_markets pick #N. Does not require load_defi_protocol. Writes stay behind load_defi_protocol({ protocolId: "trueo" }): ctm_trueo_build_wrap_tyd_multisign, ctm_trueo_build_unwrap_tyd_multisign, ctm_trueo_build_mint_multisign, ctm_trueo_build_create_order_multisign, ctm_trueo_build_burn_multisign, ctm_trueo_build_redeem_multisign, ctm_trueo_build_swap_multisign. Discover via get_defi_protocol_skill or search_continuum_tools \u2014 they are not on the opening chat catalog.',
+    prerequisites: ["venueMarketId from search_prediction_markets"],
+    followUp: [
+      "load_defi_protocol",
+      "get_defi_protocol_skill",
+      "ctm_trueo_build_wrap_tyd_multisign",
+      "ctm_trueo_build_mint_multisign",
+      "ctm_trueo_build_create_order_multisign",
+      "ctm_trueo_build_swap_multisign",
+      "ctm_trueo_build_burn_multisign",
+      "ctm_trueo_build_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/trueo", exportName: "getPredictionMarketSummary" },
+    inputZod: mcpGetPredictionMarketInputSchema,
+    outputZod: mcpGetPredictionMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "list_my_prediction_markets",
+    actionId: "prediction-markets.my-holdings",
+    protocolId: "prediction-markets",
+    chainCategory: "evm",
+    description: "Live Yes/No, trading window, and resolution for markets the user has bet on. Pass YES/NO tokenAddresses from get_token_registry and/or marketAddresses from prior bets. Does not require load_defi_protocol. After a bet, add_to_token_registry for the YES or NO token so it shows here. Exit: load_defi_protocol trueo then ctm_trueo_build_burn_multisign or ctm_trueo_build_redeem_multisign.",
+    prerequisites: [],
+    followUp: [
+      "get_prediction_market",
+      "add_to_token_registry",
+      "load_defi_protocol",
+      "ctm_trueo_build_burn_multisign",
+      "ctm_trueo_build_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/trueo", exportName: "listMyPredictionMarketsSummary" },
+    inputZod: mcpListMyPredictionMarketsInputSchema,
+    outputZod: mcpListMyPredictionMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_categories",
+    actionId: "trueo.fetch-categories",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Trueo category chips (Politics, Crypto, Sports, \u2026). Use as category on search.",
+    prerequisites: ["load_defi_protocol trueo"],
+    followUp: ["ctm_trueo_search_markets", "ctm_trueo_fetch_trending"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchCategoriesSummary" },
+    inputZod: mcpTrueoFetchCategoriesInputSchema,
+    outputZod: mcpTrueoFetchCategoriesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_trending",
+    actionId: "trueo.fetch-trending",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Trueo trending on Base (max 10; API does not page). More markets: ctm_trueo_search_markets with offset=0. Default: live and recently finished (14 days).",
+    prerequisites: ["load_defi_protocol trueo"],
+    followUp: ["ctm_trueo_fetch_market"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchTrendingSummary" },
+    inputZod: mcpTrueoFetchTrendingInputSchema,
+    outputZod: mcpTrueoFetchTrendingOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_search_markets",
+    actionId: "trueo.search-markets",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Trueo-only search (query + category), pages of 10. Same rows as search_prediction_markets. If hasMore, pass nextOffset and excludeAddresses of listed addresses. Default: live and recently finished (14 days).",
+    prerequisites: ["load_defi_protocol trueo"],
+    followUp: ["ctm_trueo_fetch_market"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoSearchMarketsSummary" },
+    inputZod: mcpTrueoSearchMarketsInputSchema,
+    outputZod: mcpTrueoSearchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_market",
+    actionId: "trueo.fetch-market",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Selected Trueo market: rules, source, Yes/No %, TVL, size, tokens, pools, endOfTrading. Copy address for build_*. Writes: ctm_trueo_build_mint_multisign, ctm_trueo_build_create_order_multisign, ctm_trueo_build_swap_multisign, ctm_trueo_build_burn_multisign, ctm_trueo_build_redeem_multisign (after load_defi_protocol trueo).",
+    prerequisites: ["marketAddress from search or trending"],
+    followUp: [
+      "ctm_trueo_fetch_chance_series",
+      "ctm_trueo_fetch_orderbook",
+      "ctm_trueo_build_mint_multisign",
+      "ctm_trueo_build_create_order_multisign",
+      "ctm_trueo_build_swap_multisign",
+      "ctm_trueo_build_burn_multisign",
+      "ctm_trueo_build_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchMarketSummary" },
+    inputZod: mcpTrueoFetchMarketInputSchema,
+    outputZod: mcpTrueoFetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_chance_series",
+    actionId: "trueo.fetch-chance-series",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Yes/No chance samples for a pool id from fetch_market. Not candlesticks. Default hourly (3600s) over 14 days. 1H/1D/1W/All coerce to hourly.",
+    prerequisites: ["poolId from ctm_trueo_fetch_market"],
+    followUp: ["ctm_trueo_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchChanceSeriesSummary" },
+    inputZod: mcpTrueoFetchChanceSeriesInputSchema,
+    outputZod: mcpTrueoFetchChanceSeriesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_orderbook",
+    actionId: "trueo.fetch-orderbook",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Yes/No depth: live tick, implied price, OrderManager pending rows when rpcUrl is set, recent trades.",
+    prerequisites: ["marketAddress from ctm_trueo_fetch_market"],
+    followUp: ["ctm_trueo_build_swap_multisign", "ctm_trueo_build_create_order_multisign"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchOrderbookSummary" },
+    inputZod: mcpTrueoFetchOrderbookInputSchema,
+    outputZod: mcpTrueoFetchOrderbookOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -9619,7 +10727,26 @@ var hyperliquidProtocolModule = {
         dex: { type: "string", required: false, description: "HIP-3 dex name when applicable" },
         takeProfitTriggerPxHuman: { type: "string", required: false, description: "TP trigger \u2014 enables L1 bracket with SL" },
         stopLossTriggerPxHuman: { type: "string", required: false, description: "SL trigger \u2014 enables L1 bracket with TP" },
-        tpslExecMode: { type: "string", required: false, description: "limit_at_trigger (default) or market" }
+        tpslExecMode: { type: "string", required: false, description: "limit_at_trigger (default) or market" },
+        trailingOffsetHuman: { type: "string", required: false, description: "Trailing retracement \u2014 EIP-712 trailingStop (cannot combine with SL)" },
+        trailingOffsetType: { type: "string", required: false, description: "price or percentage" },
+        trailingActivationPxHuman: { type: "string", required: false, description: "Optional activation mark price" }
+      }
+    },
+    {
+      id: "hyperliquid.trailingStop",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place a Hyperliquid perp trailing stop via L1 trailingStop action (EIP-712 /exchange)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        coin: { type: "string", required: true, description: "Perp coin" },
+        isBuy: { type: "boolean", required: true, description: "false closes a long / opens a short" },
+        szHuman: { type: "string", required: true, description: "Size in coin units" },
+        trailingOffsetHuman: { type: "string", required: true, description: "Retracement distance or percent" },
+        trailingOffsetType: { type: "string", required: false, description: "price or percentage (default)" },
+        trailingActivationPxHuman: { type: "string", required: false, description: "Optional activation mark price" },
+        reduceOnly: { type: "boolean", required: false, description: "true (default) reduces a position" }
       }
     },
     {
@@ -11616,6 +12743,400 @@ var pendleProtocolModule = {
   ]
 };
 registerProtocolModule(pendleProtocolModule);
+
+// src/protocols/evm/derive/constants.ts
+var DERIVE_PROTOCOL_ID = "derive";
+var DERIVE_MAINNET_API = "https://api.derive.xyz/v3";
+var DERIVE_TESTNET_API = "https://testnet.api.derive.xyz/v3";
+var DERIVE_MAINNET_API_V2 = "https://api.lyra.finance";
+var DERIVE_TESTNET_API_V2 = "https://api-demo.lyra.finance";
+function deriveNetworkFromChainId(chainId) {
+  return chainId === 11155111 ? "testnet" : "mainnet";
+}
+function deriveApiBaseUrl(network = "mainnet") {
+  return network === "testnet" ? DERIVE_TESTNET_API : DERIVE_MAINNET_API;
+}
+function deriveApiFallbackBaseUrl(network = "mainnet") {
+  return network === "testnet" ? DERIVE_TESTNET_API_V2 : DERIVE_MAINNET_API_V2;
+}
+var DERIVE_ASSET_ROW_CHAIN_IDS = [1, 10, 8453, 42161, 999, 11155111];
+function isDeriveAssetRowChainId(chainId) {
+  return DERIVE_ASSET_ROW_CHAIN_IDS.includes(chainId);
+}
+function isDeriveChainSupported(chainId) {
+  return isDeriveAssetRowChainId(chainId);
+}
+var NATIVE_ZERO = "0x0000000000000000000000000000000000000000";
+var USDC = {
+  1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  10: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  11155111: "0x73Efab09362052D26FB93A730Be4F8a5EdC833af"
+};
+var WETH = {
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  10: "0x4200000000000000000000000000000000000006",
+  8453: "0x4200000000000000000000000000000000000006",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"
+};
+var WBTC = {
+  1: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+  10: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
+  42161: "0x2f2a2543B76A4166549B7eCDcE5542a773Aa44fB"
+};
+var WHYPE = "0x5555555555555555555555555555555555555555";
+function deriveMappedTokensForChain(chainId) {
+  const tokens = [];
+  const add = (address, symbol, decimals, roles) => {
+    if (!address) return;
+    tokens.push({ address: viem.getAddress(address), symbol, decimals, roles });
+  };
+  if ([1, 10, 8453, 42161].includes(chainId)) {
+    add(NATIVE_ZERO, "ETH", 18, ["native", "underlying"]);
+    add(WETH[chainId], "WETH", 18, ["native_wrapped", "underlying"]);
+  }
+  if (chainId === 999) {
+    add(NATIVE_ZERO, "HYPE", 18, ["native", "collateral"]);
+    add(WHYPE, "WHYPE", 18, ["native_wrapped", "collateral"]);
+  }
+  add(USDC[chainId], "USDC", 6, ["collateral", "quote"]);
+  add(WBTC[chainId], "WBTC", 8, ["underlying", "collateral"]);
+  return tokens;
+}
+function deriveNativeWrappedForChain(chainId) {
+  if (chainId === 999) return WHYPE;
+  return WETH[chainId];
+}
+function deriveAdvisorNotes() {
+  return "Fund from Ethereum USDC/WETH/WBTC (L1 ACTION_MANAGER or deposit address), Socket USDC/WETH/WBTC on Optimism/Base/Arbitrum, or HyperEVM HYPE (vault). Derive Chain 957 is not a Continuum Assets chain. After credit, EIP-712 options use Derive collateral.";
+}
+
+// src/protocols/evm/derive/api.ts
+function methodName(method) {
+  return method.replace(/^\//, "");
+}
+function isDerivePublicMethod(method) {
+  return methodName(method).startsWith("public/");
+}
+function isEmptyDerivePublicResult(method, result) {
+  const m = methodName(method);
+  if (result == null) return true;
+  if (m === "public/get_all_currencies" && Array.isArray(result) && result.length === 0) return true;
+  if (m === "public/get_tickers" && result && typeof result === "object") {
+    const tickers = result.tickers;
+    if (Array.isArray(tickers) && tickers.length === 0) return true;
+    if (tickers && typeof tickers === "object" && !Array.isArray(tickers) && Object.keys(tickers).length === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function isDeriveRecoverablePublicError(err) {
+  const name = err instanceof Error ? err.name : "";
+  const msg = err instanceof Error ? err.message : String(err);
+  return name === "TimeoutError" || name === "AbortError" || /Internal error|HTTP 404|Not Found|returned empty|empty catalog|Ticker not found|aborted due to timeout|The operation was aborted/i.test(
+    msg
+  );
+}
+function unwrapResult(json, method) {
+  if (json && typeof json === "object") {
+    const rec = json;
+    if (rec.error) {
+      const err = rec.error;
+      const detail = err.data != null && String(err.data).trim() ? ` (${String(err.data).slice(0, 160)})` : "";
+      throw new Error(`Derive ${method} failed: ${err.message ?? JSON.stringify(rec.error)}${detail}`);
+    }
+    if ("result" in rec) return rec.result;
+  }
+  return json;
+}
+async function deriveRpcPost(args) {
+  const method = methodName(args.method);
+  const headers = { "Content-Type": "application/json" };
+  if (args.auth) {
+    headers["X-DeriveWallet"] = args.auth.wallet;
+    headers["X-DeriveTimestamp"] = args.auth.timestamp;
+    headers["X-DeriveSignature"] = args.auth.signature;
+  }
+  const res = await fetch(`${args.base}/${method}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(args.params ?? {}),
+    cache: "no-store",
+    signal: AbortSignal.timeout(15e3)
+  });
+  const text = await res.text().catch(() => "");
+  if (!res.ok || !text.trim() || text.trim() === "Not Found") {
+    throw new Error(`Derive ${method} HTTP ${res.status}: ${text.slice(0, 240) || "empty body"}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Derive ${method} returned non-JSON: ${text.slice(0, 160)}`);
+  }
+  const result = unwrapResult(json, method);
+  if (isEmptyDerivePublicResult(method, result)) {
+    throw new Error(`Derive ${method} returned empty catalog`);
+  }
+  return result;
+}
+async function deriveRpc(args) {
+  const network = args.network ?? "mainnet";
+  const method = methodName(args.method);
+  const primary = deriveApiBaseUrl(network);
+  try {
+    return await deriveRpcPost({
+      base: primary,
+      method,
+      params: args.params,
+      auth: args.auth
+    });
+  } catch (err) {
+    const fallback = deriveApiFallbackBaseUrl(network);
+    if (!isDerivePublicMethod(method) || fallback === primary || !isDeriveRecoverablePublicError(err)) {
+      throw err;
+    }
+    return await deriveRpcPost({
+      base: fallback,
+      method,
+      params: args.params,
+      auth: args.auth
+    });
+  }
+}
+
+// src/protocols/evm/derive/assets.ts
+async function deriveFetchCurrenciesRaw(args) {
+  const result = await deriveRpc({
+    method: "public/get_all_currencies",
+    network: args?.network
+  });
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.currencies)) {
+    return result.currencies;
+  }
+  return [];
+}
+
+// src/protocols/evm/derive/index.ts
+var deriveProtocolModule = {
+  id: DERIVE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const chainId = typeof ctx.chainId === "number" ? ctx.chainId : Number(ctx.chainId);
+    return Number.isFinite(chainId) && isDeriveChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "erc20" || token.kind === "native";
+  },
+  actions: [
+    {
+      id: "derive.depositNewSubaccount",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Ethereum L1 approve + ACTION_MANAGER.depositToNewSubaccount. First credit creates the trading + fallback subaccounts. chainId 1 / 11155111. Arb/OP/Base use derive.socketDeposit; HyperEVM HYPE uses derive.hypeVaultDeposit.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        protocolAsset: { type: "string", required: true, description: "Risk-universe collateral protocol asset" },
+        underlyingErc20: { type: "string", required: true, description: "L1 ERC-20 to approve (usually USDC)" },
+        amountHuman: { type: "string", required: true, description: "Deposit amount in underlying decimals" },
+        managerId: { type: "number", required: true, description: "Risk-universe manager_id" }
+      }
+    },
+    {
+      id: "derive.depositAddressTransfer",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Ethereum L1 ERC-20 transfer to a registered Derive deposit address (standard / keeper sweep). Call register_deposit_address first.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        underlyingErc20: { type: "string", required: true, description: "L1 ERC-20 to send (usually USDC)" },
+        amountHuman: { type: "string", required: true, description: "Transfer amount in token units" },
+        depositAddress: { type: "string", required: true, description: "From register_deposit_address" }
+      }
+    },
+    {
+      id: "derive.socketDeposit",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Socket FAST deposit of USDC/WETH/WBTC on Ethereum, Optimism, Base, or Arbitrum into Derive Chain. Native ETH wraps to WETH first. useCustomGas.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        token: { type: "string", required: true, description: "Row ERC-20 or native 0x0 (wraps to WETH)" },
+        amountHuman: { type: "string", required: true, description: "Deposit amount in token units" }
+      }
+    },
+    {
+      id: "derive.hypeVaultDeposit",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "HyperEVM (999): wrap native HYPE to WHYPE if needed, approve Derive vault, deposit.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        amountHuman: { type: "string", required: true, description: "HYPE amount" },
+        token: { type: "string", required: false, description: "Native 0x0 or WHYPE" }
+      }
+    },
+    {
+      id: "derive.placeOrder",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place a Derive options limit order via EIP-712 Action (delivery derive_exchange). Does not spend the current-chain token.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        instrumentName: { type: "string", required: true, description: "e.g. ETH-20260626-3000-C" },
+        direction: { type: "string", required: true, description: "buy or sell" },
+        amount: { type: "string", required: true, description: "Contract size" },
+        limitPrice: { type: "string", required: true, description: "Limit price" },
+        maxFee: { type: "string", required: true, description: "Max fee (e18-scaled, \u226412 decimals)" },
+        subaccountId: { type: "number", required: true, description: "From fetch_subaccounts \u2014 never 0" }
+      }
+    },
+    {
+      id: "derive.replaceOrder",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Replace a Derive open order (EIP-712 Action + orderIdToCancel or nonceToCancel).",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        instrumentName: { type: "string", required: true, description: "Instrument of the replacement order" },
+        direction: { type: "string", required: true, description: "buy or sell" },
+        amount: { type: "string", required: true, description: "Contract size" },
+        limitPrice: { type: "string", required: true, description: "Limit price" },
+        maxFee: { type: "string", required: true, description: "Max fee" },
+        subaccountId: { type: "number", required: true, description: "From fetch_subaccounts" },
+        orderIdToCancel: { type: "string", required: false, description: "Existing order id (xor nonceToCancel)" },
+        nonceToCancel: { type: "string", required: false, description: "Existing order nonce (xor orderIdToCancel)" }
+      }
+    },
+    {
+      id: "derive.cancel",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel a Derive open order. v3 cancel is session-auth; this signs EIP-191 login for private/cancel delivery.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        instrumentName: { type: "string", required: true, description: "Instrument of the open order" },
+        orderId: { type: "string", required: true, description: "order_id from fetch_open_orders" },
+        subaccountId: { type: "number", required: true, description: "From fetch_subaccounts" }
+      }
+    },
+    {
+      id: "derive.transferSpot",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "EIP-712 transfer_spot. Use toSubaccountId 0 + newSubaccountManager to create an extra subaccount after the first funded one.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        fromSubaccountId: { type: "number", required: true, description: "Funded source subaccount" },
+        toSubaccountId: { type: "number", required: true, description: "0 to create an extra subaccount" },
+        newSubaccountManager: { type: "number", required: true, description: "Required when toSubaccountId is 0" },
+        asset: { type: "string", required: true, description: "Protocol asset address" },
+        amount: { type: "string", required: true, description: "Transfer amount" }
+      }
+    }
+  ]
+};
+registerProtocolModule(deriveProtocolModule);
+var TRUEO_PROTOCOL_ID = "trueo";
+var TRUEO_BASE_CHAIN_ID = 8453;
+var TRUEO_CHAIN_IDS = [TRUEO_BASE_CHAIN_ID];
+var TRUEO_TYD = viem.getAddress("0xb13CF163d916917d9cD6E836905cA5f12a1dEF4B");
+var TRUEO_TRUE = viem.getAddress("0x21CFCFc3d8F98fC728f48341D10Ad8283F6EB7AB");
+var TRUEO_USDC = viem.getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
+viem.getAddress("0x61A98Bef11867c69489B91f340fE545eEfc695d7");
+viem.getAddress("0x1cdB1C43eB64e99780EA9d3C7162C23432C59a1A");
+viem.getAddress("0x0A1AFc2121B4441127a02DEF72928F61f564034a");
+viem.getAddress("0x6E08d24AEf78F6d1a97503F64E84fDF65f8125E1");
+viem.getAddress("0x3E83479B2276EcFb7C7181F67b5d092d3511e0C4");
+viem.getAddress("0x000000000022D473030F116dDEE9F6B43aC78BA3");
+function isTrueoChainSupported(chainId) {
+  return TRUEO_CHAIN_IDS.includes(chainId);
+}
+
+// src/protocols/evm/trueo/index.ts
+var trueoProtocolModule = {
+  id: TRUEO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    const id = typeof ctx.chainId === "string" ? Number(ctx.chainId) : ctx.chainId;
+    return ctx.chainCategory === "evm" && isTrueoChainSupported(id);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "erc20" || token.kind === "ctmerc20");
+  },
+  actions: [
+    {
+      id: "trueo.wrap-tyd",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint TYD by depositing Base USDC into the Yearn ERC-4626 vault",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.unwrap-tyd",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Redeem TYD shares back to Base USDC",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.mint",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint YES+NO from TYD (or USDC via adapter)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.burn",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Burn equal YES+NO back to TYD",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.redeem",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Redeem winning outcome tokens after resolution",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.swap",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Buy Yes or No with TYD via UniversalRouterAdapter V4 swap",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.create-order",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Create an on-chain OrderManager limit order",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.cancel-order",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel an on-chain OrderManager order",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(trueoProtocolModule);
 var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('catalog.cjs', document.baseURI).href)))), "skills");
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
@@ -11635,6 +13156,8 @@ var SKILL_PROTOCOL_IDS = [
   "pendle",
   "continuum-dao",
   "compound-v3",
+  "derive",
+  "trueo",
   "yield-compare"
 ];
 function getToolsForProtocol(protocolId) {
@@ -12174,6 +13697,72 @@ var PROTOCOL_SUPPORT_ADVISORS = {
         notes: "Arcus on Robinhood Chain (4663): perps via fetch_markets; spot Stock Tokens via spot_fetch_markets. Custody is secp256k1 on 4663; API signing uses paired ed25519 KeyGen (same GroupId)."
       };
     }
+  }),
+  [DERIVE_PROTOCOL_ID]: advisor(DERIVE_PROTOCOL_ID, "api_underlyings", {
+    async supportedChainIds() {
+      return [...DERIVE_ASSET_ROW_CHAIN_IDS];
+    },
+    async supportedTokens(chainId) {
+      if (!isDeriveChainSupported(chainId)) {
+        return { tokens: [], notes: "Derive logo rows are fundable chains only: Ethereum, OP, Base, Arbitrum, HyperEVM, Sepolia." };
+      }
+      const mapped = deriveMappedTokensForChain(chainId);
+      let tokens = mapped;
+      try {
+        const currencies = await deriveFetchCurrenciesRaw({ network: deriveNetworkFromChainId(chainId) });
+        const symbols = new Set(
+          currencies.map((c) => String(c.currency ?? "").toUpperCase()).filter(Boolean)
+        );
+        if (symbols.size > 0) {
+          tokens = mapped.filter((t) => {
+            const s = t.symbol.toUpperCase();
+            return symbols.has(s) || s === "WETH" && symbols.has("ETH") || s === "WBTC" && symbols.has("BTC") || s === "HYPE" || s === "WHYPE";
+          });
+        }
+      } catch {
+      }
+      return {
+        tokens,
+        nativeWrapped: deriveNativeWrappedForChain(chainId),
+        notes: deriveAdvisorNotes()
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      if (!isDeriveChainSupported(chainId)) return false;
+      try {
+        const normalized = viem.getAddress(address).toLowerCase();
+        return deriveMappedTokensForChain(chainId).some((t) => t.address.toLowerCase() === normalized);
+      } catch {
+        return false;
+      }
+    }
+  }),
+  [TRUEO_PROTOCOL_ID]: advisor(TRUEO_PROTOCOL_ID, "fixed_addresses", {
+    async supportedChainIds() {
+      return [TRUEO_BASE_CHAIN_ID];
+    },
+    async supportedTokens(chainId) {
+      if (chainId !== TRUEO_BASE_CHAIN_ID) {
+        return { tokens: [], notes: "Trueo is Base-only (chainId 8453)." };
+      }
+      return {
+        tokens: [
+          { address: TRUEO_TYD, symbol: "TYD", decimals: 6, roles: ["payment"] },
+          { address: TRUEO_TRUE, symbol: "TRUE", decimals: 18, roles: ["governance"] },
+          { address: TRUEO_USDC, symbol: "USDC", decimals: 6, roles: ["adapter_asset"] }
+        ],
+        notes: "Trueo prediction markets on Base. Payment is TYD. Outcome YES/NO tokens are per-market \u2014 use ctm_trueo_search_markets / fetch_market. Chat search: search_prediction_markets (no load required; default live/recent, includeAll for closed)."
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      if (chainId !== TRUEO_BASE_CHAIN_ID) return false;
+      try {
+        const n = viem.getAddress(address).toLowerCase();
+        return n === TRUEO_TYD.toLowerCase() || n === TRUEO_TRUE.toLowerCase() || n === TRUEO_USDC.toLowerCase();
+      } catch {
+        return false;
+      }
+    }
   })
 };
 function getProtocolSupportAdvisor(protocolId) {
@@ -12202,6 +13791,8 @@ registerProtocolModule(aerodromeProtocolModule);
 registerProtocolModule(continuumDaoProtocolModule);
 registerProtocolModule(compoundV3ProtocolModule);
 registerProtocolModule(pendleProtocolModule);
+registerProtocolModule(deriveProtocolModule);
+registerProtocolModule(trueoProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -12228,6 +13819,8 @@ function getAgentCatalog() {
     continuumDao: continuumDaoProtocolModule,
     compoundV3: compoundV3ProtocolModule,
     pendle: pendleProtocolModule,
+    derive: deriveProtocolModule,
+    trueo: trueoProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -12242,6 +13835,7 @@ exports.MCP_TOOL_OUTPUT_SCHEMAS = MCP_TOOL_OUTPUT_SCHEMAS;
 exports.MULTISIGN_OUTPUT_DOC = MULTISIGN_OUTPUT_DOC;
 exports.MULTISIGN_SUBMIT_OUTPUT_DOC = MULTISIGN_SUBMIT_OUTPUT_DOC;
 exports.PROTOCOL_SUPPORT_ADVISORS = PROTOCOL_SUPPORT_ADVISORS;
+exports.agentEvmChainIdSchema = agentEvmChainIdSchema;
 exports.chainDetailSchema = chainDetailSchema;
 exports.evmAddressSchema = evmAddressSchema;
 exports.evmMultisignCommonInputSchema = evmMultisignCommonInputSchema;
@@ -12445,6 +14039,42 @@ exports.mcpCurveDaoQuoteInputSchema = mcpCurveDaoQuoteInputSchema;
 exports.mcpCurveDaoQuoteOutputSchema = mcpCurveDaoQuoteOutputSchema;
 exports.mcpCurveDaoQuoteRemoveLiquidityInputSchema = mcpCurveDaoQuoteRemoveLiquidityInputSchema;
 exports.mcpCurveDaoQuoteRemoveLiquidityOutputSchema = mcpCurveDaoQuoteRemoveLiquidityOutputSchema;
+exports.mcpDeriveCancelInputSchema = mcpDeriveCancelInputSchema;
+exports.mcpDeriveDepositAddressTransferInputSchema = mcpDeriveDepositAddressTransferInputSchema;
+exports.mcpDeriveDepositNewSubaccountInputSchema = mcpDeriveDepositNewSubaccountInputSchema;
+exports.mcpDeriveFetchCurrenciesInputSchema = mcpDeriveFetchCurrenciesInputSchema;
+exports.mcpDeriveFetchCurrenciesOutputSchema = mcpDeriveFetchCurrenciesOutputSchema;
+exports.mcpDeriveFetchMarketSnapshotInputSchema = mcpDeriveFetchMarketSnapshotInputSchema;
+exports.mcpDeriveFetchMarketSnapshotOutputSchema = mcpDeriveFetchMarketSnapshotOutputSchema;
+exports.mcpDeriveFetchOhlcvInputSchema = mcpDeriveFetchOhlcvInputSchema;
+exports.mcpDeriveFetchOhlcvOutputSchema = mcpDeriveFetchOhlcvOutputSchema;
+exports.mcpDeriveFetchOpenOrdersInputSchema = mcpDeriveFetchOpenOrdersInputSchema;
+exports.mcpDeriveFetchOpenOrdersOutputSchema = mcpDeriveFetchOpenOrdersOutputSchema;
+exports.mcpDeriveFetchOptionChainInputSchema = mcpDeriveFetchOptionChainInputSchema;
+exports.mcpDeriveFetchOptionChainOutputSchema = mcpDeriveFetchOptionChainOutputSchema;
+exports.mcpDeriveFetchPendingDepositsInputSchema = mcpDeriveFetchPendingDepositsInputSchema;
+exports.mcpDeriveFetchPendingDepositsOutputSchema = mcpDeriveFetchPendingDepositsOutputSchema;
+exports.mcpDeriveFetchPortfolioInputSchema = mcpDeriveFetchPortfolioInputSchema;
+exports.mcpDeriveFetchPortfolioOutputSchema = mcpDeriveFetchPortfolioOutputSchema;
+exports.mcpDeriveFetchPositionsInputSchema = mcpDeriveFetchPositionsInputSchema;
+exports.mcpDeriveFetchPositionsOutputSchema = mcpDeriveFetchPositionsOutputSchema;
+exports.mcpDeriveFetchRiskUniversesInputSchema = mcpDeriveFetchRiskUniversesInputSchema;
+exports.mcpDeriveFetchRiskUniversesOutputSchema = mcpDeriveFetchRiskUniversesOutputSchema;
+exports.mcpDeriveFetchSubaccountsInputSchema = mcpDeriveFetchSubaccountsInputSchema;
+exports.mcpDeriveFetchSubaccountsOutputSchema = mcpDeriveFetchSubaccountsOutputSchema;
+exports.mcpDeriveFetchTickersInputSchema = mcpDeriveFetchTickersInputSchema;
+exports.mcpDeriveFetchTickersOutputSchema = mcpDeriveFetchTickersOutputSchema;
+exports.mcpDeriveHypeVaultDepositInputSchema = mcpDeriveHypeVaultDepositInputSchema;
+exports.mcpDeriveOrderQuoteInputSchema = mcpDeriveOrderQuoteInputSchema;
+exports.mcpDeriveOrderQuoteOutputSchema = mcpDeriveOrderQuoteOutputSchema;
+exports.mcpDerivePlaceOrderInputSchema = mcpDerivePlaceOrderInputSchema;
+exports.mcpDeriveRegisterDepositAddressInputSchema = mcpDeriveRegisterDepositAddressInputSchema;
+exports.mcpDeriveRegisterDepositAddressOutputSchema = mcpDeriveRegisterDepositAddressOutputSchema;
+exports.mcpDeriveReplaceOrderInputSchema = mcpDeriveReplaceOrderInputSchema;
+exports.mcpDeriveSearchInstrumentsInputSchema = mcpDeriveSearchInstrumentsInputSchema;
+exports.mcpDeriveSearchInstrumentsOutputSchema = mcpDeriveSearchInstrumentsOutputSchema;
+exports.mcpDeriveSocketDepositInputSchema = mcpDeriveSocketDepositInputSchema;
+exports.mcpDeriveTransferSpotInputSchema = mcpDeriveTransferSpotInputSchema;
 exports.mcpEthenaClaimInputSchema = mcpEthenaClaimInputSchema;
 exports.mcpEthenaCooldownInputSchema = mcpEthenaCooldownInputSchema;
 exports.mcpEthenaFetchSusdeApyInputSchema = mcpEthenaFetchSusdeApyInputSchema;
@@ -12462,6 +14092,8 @@ exports.mcpEulerV2IsolatedBorrowInputSchema = mcpEulerV2IsolatedBorrowInputSchem
 exports.mcpEulerV2IsolatedLendInputSchema = mcpEulerV2IsolatedLendInputSchema;
 exports.mcpEulerV2MerklClaimInputSchema = mcpEulerV2MerklClaimInputSchema;
 exports.mcpEulerV2VaultWithdrawInputSchema = mcpEulerV2VaultWithdrawInputSchema;
+exports.mcpGetPredictionMarketInputSchema = mcpGetPredictionMarketInputSchema;
+exports.mcpGetPredictionMarketOutputSchema = mcpGetPredictionMarketOutputSchema;
 exports.mcpGmxCancelInputSchema = mcpGmxCancelInputSchema;
 exports.mcpGmxDecreaseInputSchema = mcpGmxDecreaseInputSchema;
 exports.mcpGmxFetchGmApyInputSchema = mcpGmxFetchGmApyInputSchema;
@@ -12526,6 +14158,7 @@ exports.mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidLimitOrderInputSchem
 exports.mcpHyperliquidSearchMarketsInputSchema = mcpHyperliquidSearchMarketsInputSchema;
 exports.mcpHyperliquidSearchMarketsOutputSchema = mcpHyperliquidSearchMarketsOutputSchema;
 exports.mcpHyperliquidStakeInputSchema = mcpHyperliquidStakeInputSchema;
+exports.mcpHyperliquidTrailingStopInputSchema = mcpHyperliquidTrailingStopInputSchema;
 exports.mcpHyperliquidUndelegateInputSchema = mcpHyperliquidUndelegateInputSchema;
 exports.mcpHyperliquidUnstakeInputSchema = mcpHyperliquidUnstakeInputSchema;
 exports.mcpHyperliquidUpdateLeverageInputSchema = mcpHyperliquidUpdateLeverageInputSchema;
@@ -12539,6 +14172,8 @@ exports.mcpLidoRequestWithdrawalsInputSchema = mcpLidoRequestWithdrawalsInputSch
 exports.mcpLidoSubmitInputSchema = mcpLidoSubmitInputSchema;
 exports.mcpLidoUnwrapWstEthInputSchema = mcpLidoUnwrapWstEthInputSchema;
 exports.mcpLidoWrapStEthInputSchema = mcpLidoWrapStEthInputSchema;
+exports.mcpListMyPredictionMarketsInputSchema = mcpListMyPredictionMarketsInputSchema;
+exports.mcpListMyPredictionMarketsOutputSchema = mcpListMyPredictionMarketsOutputSchema;
 exports.mcpMapleDepositInputSchema = mcpMapleDepositInputSchema;
 exports.mcpMapleFetchMarketInputSchema = mcpMapleFetchMarketInputSchema;
 exports.mcpMapleFetchMarketOutputSchema = mcpMapleFetchMarketOutputSchema;
@@ -12606,6 +14241,9 @@ exports.mcpPendleQuoteRemoveLiquidityInputSchema = mcpPendleQuoteRemoveLiquidity
 exports.mcpPendleQuoteSwapInputSchema = mcpPendleQuoteSwapInputSchema;
 exports.mcpPendleSearchAssetsInputSchema = mcpPendleSearchAssetsInputSchema;
 exports.mcpPendleSearchAssetsOutputSchema = mcpPendleSearchAssetsOutputSchema;
+exports.mcpPredictionMarketRowSchema = mcpPredictionMarketRowSchema;
+exports.mcpSearchPredictionMarketsInputSchema = mcpSearchPredictionMarketsInputSchema;
+exports.mcpSearchPredictionMarketsOutputSchema = mcpSearchPredictionMarketsOutputSchema;
 exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;
 exports.mcpServerMultisignInput = mcpServerMultisignInput;
 exports.mcpServerSubmitOutputSchema = mcpServerSubmitOutputSchema;
@@ -12618,6 +14256,27 @@ exports.mcpSkyLockstakeStakeInputSchema = mcpSkyLockstakeStakeInputSchema;
 exports.mcpSkyLockstakeWipeInputSchema = mcpSkyLockstakeWipeInputSchema;
 exports.mcpSkySusdsDepositInputSchema = mcpSkySusdsDepositInputSchema;
 exports.mcpSkySusdsRedeemInputSchema = mcpSkySusdsRedeemInputSchema;
+exports.mcpTrueoBurnInputSchema = mcpTrueoBurnInputSchema;
+exports.mcpTrueoCancelOrderInputSchema = mcpTrueoCancelOrderInputSchema;
+exports.mcpTrueoCreateOrderInputSchema = mcpTrueoCreateOrderInputSchema;
+exports.mcpTrueoFetchCategoriesInputSchema = mcpTrueoFetchCategoriesInputSchema;
+exports.mcpTrueoFetchCategoriesOutputSchema = mcpTrueoFetchCategoriesOutputSchema;
+exports.mcpTrueoFetchChanceSeriesInputSchema = mcpTrueoFetchChanceSeriesInputSchema;
+exports.mcpTrueoFetchChanceSeriesOutputSchema = mcpTrueoFetchChanceSeriesOutputSchema;
+exports.mcpTrueoFetchMarketInputSchema = mcpTrueoFetchMarketInputSchema;
+exports.mcpTrueoFetchMarketOutputSchema = mcpTrueoFetchMarketOutputSchema;
+exports.mcpTrueoFetchOrderbookInputSchema = mcpTrueoFetchOrderbookInputSchema;
+exports.mcpTrueoFetchOrderbookOutputSchema = mcpTrueoFetchOrderbookOutputSchema;
+exports.mcpTrueoFetchTrendingInputSchema = mcpTrueoFetchTrendingInputSchema;
+exports.mcpTrueoFetchTrendingOutputSchema = mcpTrueoFetchTrendingOutputSchema;
+exports.mcpTrueoMarketRowSchema = mcpTrueoMarketRowSchema;
+exports.mcpTrueoMintInputSchema = mcpTrueoMintInputSchema;
+exports.mcpTrueoRedeemInputSchema = mcpTrueoRedeemInputSchema;
+exports.mcpTrueoSearchMarketsInputSchema = mcpTrueoSearchMarketsInputSchema;
+exports.mcpTrueoSearchMarketsOutputSchema = mcpTrueoSearchMarketsOutputSchema;
+exports.mcpTrueoSwapInputSchema = mcpTrueoSwapInputSchema;
+exports.mcpTrueoUnwrapTydInputSchema = mcpTrueoUnwrapTydInputSchema;
+exports.mcpTrueoWrapTydInputSchema = mcpTrueoWrapTydInputSchema;
 exports.mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema = mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema;
 exports.mcpUniswapV4BuildCollectFeesMultisignInputSchema = mcpUniswapV4BuildCollectFeesMultisignInputSchema;
 exports.mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema = mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema;