@continuumdao/ctm-mpc-defi 0.2.35 → 0.2.36

package/dist/agent/catalog.cjs

@@ -1098,7 +1098,7 @@ var evmMultisignCommonInputSchema = zod.z.object({
   chainDetail: chainDetailSchema.optional().describe("Server-filled gas row from chain registry when keyGenId is set."),
   customGasChainDetails: zod.z.record(zod.z.unknown()).optional().describe("Snapshot written to extraJSON.customGasChainDetails when useCustomGas is true."),
   expiryDate: zod.z.number().int().positive().optional().describe(
-    "Optional Unix seconds (UTC) when the MPC sign request expires. Uniswap V4, GMX, Hyperliquid, Curve DAO, and Aerodrome default to 30 minutes when omitted; other protocols use the node default (7 days)."
+    "Optional Unix seconds (UTC) when the MPC sign request expires. Uniswap V4, GMX, Hyperliquid, Curve DAO, Aerodrome, and Pendle default to 30 minutes when omitted; other protocols use the node default (7 days)."
   )
 });
 function withMultisignKeySourceRefine(schema) {
@@ -3417,6 +3417,193 @@ var mcpEthenaFetchSusdeApyOutputSchema = zod.z.object({
   cooldownDurationSec: zod.z.number().nullable(),
   notes: zod.z.string()
 });
+var mcpPendleFetchMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  query: zod.z.string().trim().min(1).optional().describe("Optional shrink filter on name, PT/YT/underlying symbol or address."),
+  pointsOnly: zod.z.boolean().optional().describe("If true, only markets with point campaigns.")
+});
+var mcpPendleFetchMarketsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, markets[] (address, pt, yt, sy, underlying, expiry, impliedApy, tvlUsd, points), notes }. Live markets only, hard cap 100 TVL-ranked."
+);
+var mcpPendleFetchPricesInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  ids: zod.z.array(zod.z.string().min(1)).optional().describe("Asset ids (chainId-0x\u2026). Omit to price the current live listing."),
+  query: zod.z.string().trim().min(1).optional()
+});
+var mcpPendleFetchPricesOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, prices[] ({ id, usd }), notes }"
+);
+var mcpPendleSearchAssetsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  query: zod.z.string().trim().min(1).describe("Ticker, name, 0x address, or chainId-0x asset id.")
+});
+var mcpPendleSearchAssetsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, results[] (live PT/YT/SY/market + expiry, liquidity, points), notes }"
+);
+var mcpPendleFetchPositionsInputSchema = zod.z.object({
+  user: evmAddressSchema.describe("KeyGen / wallet to list Pendle LP for."),
+  chainId: agentEvmChainIdSchema.optional().describe("If set, only this chain. Omit for all Core chains."),
+  filterUsd: zod.z.number().min(0).optional().describe("Drop holdings below this USD valuation. Omit to keep dust.")
+});
+var mcpPendleFetchPositionsOutputSchema = jsonObjectSchema.describe(
+  "{ user, chainId, lp[] (market, name, expiry, matured, lpAmountHuman, lpUsd), notes }. Includes matured. Not the node token list."
+);
+var mcpPendleFetchMerkleRewardsInputSchema = zod.z.object({
+  user: evmAddressSchema.describe("Wallet to list off-chain airdrop rows for (informational; no claim).")
+});
+var mcpPendleFetchMerkleRewardsOutputSchema = jsonObjectSchema.describe(
+  "{ user, claimableRewards[], claimedRewards[], notes }. List only \u2014 cannot build a claim from these rows."
+);
+var mcpPendleQuoteSwapInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokenIn: zod.z.string().min(1).describe("Underlying, PT, or YT (0xeeee / 0x0 = native)."),
+  tokenOut: zod.z.string().min(1),
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional(),
+  enableAggregator: zod.z.boolean().optional(),
+  tokenInDecimals: zod.z.number().int().min(0).max(18).optional()
+});
+var mcpPendleQuoteOutputSchema = jsonObjectSchema.describe(
+  "Hosted SDK convert quote: action, outputs, priceImpact, impliedApy, requiredApprovals, tx (do not hardcode tx.to)."
+);
+var mcpPendleQuoteMintPyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokenIn: zod.z.string().min(1),
+  pt: evmAddressSchema,
+  yt: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteRedeemPyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  pt: evmAddressSchema,
+  yt: evmAddressSchema,
+  tokenOut: zod.z.string().min(1),
+  amountPtHuman: zod.z.string().min(1),
+  amountYtHuman: zod.z.string().min(1).optional(),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteMintSyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokenIn: zod.z.string().min(1),
+  sy: evmAddressSchema,
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteRedeemSyInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  sy: evmAddressSchema,
+  tokenOut: zod.z.string().min(1),
+  amountHuman: zod.z.string().min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteAddLiquidityInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  tokensIn: zod.z.array(zod.z.object({ token: zod.z.string().min(1), amountHuman: zod.z.string().min(1) })).min(1),
+  market: evmAddressSchema,
+  keepYt: zod.z.boolean().optional(),
+  yt: evmAddressSchema.optional(),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleQuoteRemoveLiquidityInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional(),
+  market: evmAddressSchema,
+  lpAmountHuman: zod.z.string().min(1),
+  tokensOut: zod.z.array(zod.z.string().min(1)).min(1),
+  slippagePercent: zod.z.number().gt(0).lt(100),
+  enableAggregator: zod.z.boolean().optional(),
+  receiver: evmAddressSchema.optional()
+});
+var mcpPendleBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1),
+    tokenOut: zod.z.string().min(1),
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    enableAggregator: zod.z.boolean().optional(),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildMintPyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1),
+    pt: evmAddressSchema,
+    yt: evmAddressSchema,
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRedeemPyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pt: evmAddressSchema,
+    yt: evmAddressSchema,
+    tokenOut: zod.z.string().min(1),
+    amountPtHuman: zod.z.string().min(1),
+    amountYtHuman: zod.z.string().min(1).optional(),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildMintSyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1),
+    sy: evmAddressSchema,
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRedeemSyMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    sy: evmAddressSchema,
+    tokenOut: zod.z.string().min(1),
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildAddLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokensIn: zod.z.array(zod.z.object({ token: zod.z.string().min(1), amountHuman: zod.z.string().min(1) })).min(1),
+    market: evmAddressSchema,
+    keepYt: zod.z.boolean().optional(),
+    yt: evmAddressSchema.optional(),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRemoveLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    market: evmAddressSchema,
+    lpAmountHuman: zod.z.string().min(1),
+    tokensOut: zod.z.array(zod.z.string().min(1)).min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    enableAggregator: zod.z.boolean().optional(),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpPendleBuildRedeemRewardsMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    sys: zod.z.array(evmAddressSchema).optional(),
+    yts: zod.z.array(evmAddressSchema).optional(),
+    markets: zod.z.array(evmAddressSchema).optional(),
+    convertSnapshot: jsonObjectSchema.optional()
+  })
+);
 var mcpCompoundV3FetchMarketsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
@@ -7254,6 +7441,238 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchAccountSummary" },
     inputZod: mcpCompoundV3FetchAccountInputSchema,
     outputZod: mcpCompoundV3FetchAccountOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_markets",
+    actionId: "pendle.fetch-markets",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: live (unexpired) markets on chainId, scanned from Core, TVL-ranked, hard cap 100. Matured YT markets are omitted. Includes points[] campaigns. Use ctm_pendle_search_assets for long-tail or a specific expired market (PT redeem / remove LP). Never Convert. load_defi_protocol pendle activates this pack.",
+    prerequisites: ["chainId in get_chain_registry \u2229 Pendle GET /v1/chains"],
+    followUp: ["ctm_pendle_search_assets", "ctm_pendle_fetch_prices", "ctm_pendle_quote_swap"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchMarketsSummary" },
+    inputZod: mcpPendleFetchMarketsInputSchema,
+    outputZod: mcpPendleFetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_prices",
+    actionId: "pendle.fetch-prices",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: USD prices for listed or searched asset ids (GET /v1/prices/assets). Do not use Convert as a ticker.",
+    prerequisites: ["chainId", "ids from fetch_markets / search_assets (or omit to price the current live listing)"],
+    followUp: ["ctm_pendle_quote_swap"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchPricesSummary" },
+    inputZod: mcpPendleFetchPricesInputSchema,
+    outputZod: mcpPendleFetchPricesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_search_assets",
+    actionId: "pendle.search-assets",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: search live markets by ticker, 0x, or chainId-0x. Prefers unexpired hits; returns a matured market only if nothing live matched or you looked up that address (PT redeem / remove LP). Returns expiry, APY, TVL, points.",
+    prerequisites: ["chainId", "query (ticker, 0x, or chainId-0x)"],
+    followUp: ["ctm_pendle_quote_swap", "ctm_pendle_quote_mint_py", "ctm_pendle_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleSearchAssets" },
+    inputZod: mcpPendleSearchAssetsInputSchema,
+    outputZod: mcpPendleSearchAssetsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_swap",
+    actionId: "pendle.quote-swap",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Hosted SDK Convert quote: token \u2194 PT or YT (this is also how you trade points). Fresh calldata; do not cache as a price ticker.",
+    prerequisites: ["ctm_pendle_fetch_markets or ctm_pendle_search_assets", "activate_tool_group pendle:swap"],
+    followUp: ["ctm_pendle_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteSwap" },
+    inputZod: mcpPendleQuoteSwapInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_mint_py",
+    actionId: "pendle.quote-mint-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: mint PT+YT from an underlying or SY.",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_mint_py_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteMintPy" },
+    inputZod: mcpPendleQuoteMintPyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_redeem_py",
+    actionId: "pendle.quote-redeem-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: redeem PT+YT to underlying or SY. After expiry, pass amountYtHuman 0 (PT only).",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_redeem_py_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteRedeemPy" },
+    inputZod: mcpPendleQuoteRedeemPyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_mint_sy",
+    actionId: "pendle.quote-mint-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: wrap underlying into SY.",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_mint_sy_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteMintSy" },
+    inputZod: mcpPendleQuoteMintSyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_redeem_sy",
+    actionId: "pendle.quote-redeem-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: unwrap SY to underlying.",
+    prerequisites: ["activate_tool_group pendle:mint"],
+    followUp: ["ctm_pendle_build_redeem_sy_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteRedeemSy" },
+    inputZod: mcpPendleQuoteRedeemSyInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_add_liquidity",
+    actionId: "pendle.quote-add-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: add LP. keepYt+yt = zero-price-impact (keep YT in the wallet instead of selling it into the AMM).",
+    prerequisites: ["activate_tool_group pendle:lp"],
+    followUp: ["ctm_pendle_build_add_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteAddLiquidity" },
+    inputZod: mcpPendleQuoteAddLiquidityInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_quote_remove_liquidity",
+    actionId: "pendle.quote-remove-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2 Convert quote: remove LP to tokensOut (use underlying). After expiry still works. Copy market + lpAmountHuman from ctm_pendle_fetch_positions.",
+    prerequisites: ["activate_tool_group pendle:lp", "market + lpAmountHuman from fetch_positions or the user"],
+    followUp: ["ctm_pendle_build_remove_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleQuoteRemoveLiquidity" },
+    inputZod: mcpPendleQuoteRemoveLiquidityInputSchema,
+    outputZod: mcpPendleQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_positions",
+    actionId: "pendle.fetch-positions",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: this wallet\u2019s LP holdings from official Core dashboard (including matured). Not the node token list. Use before remove LP. ~4 CU. Do not treat claimable amounts here as a live redeem quote.",
+    prerequisites: ["activate_tool_group pendle:lp", "user address", "optional chainId"],
+    followUp: ["ctm_pendle_quote_remove_liquidity"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchPositions" },
+    inputZod: mcpPendleFetchPositionsInputSchema,
+    outputZod: mcpPendleFetchPositionsOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_swap_multisign",
+    actionId: "pendle.swap",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: approve Convert tx.to then swap token \u2194 PT/YT. 30-min multiSign expiry unless expiryDate is set. Fresh Convert at build time.",
+    prerequisites: [
+      "ctm_pendle_quote_swap",
+      "get_multi_sign_gas_options + user confirms useCustomGas and 30-minute deadline",
+      "keyGenId + chainId + purposeText + slippagePercent"
+    ],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleSwapBatch" },
+    inputZod: mcpPendleBuildSwapMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_mint_py_multisign",
+    actionId: "pendle.mint-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: mint PT+YT multiSign (approve + Convert). 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_mint_py", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleMintPyBatch" },
+    inputZod: mcpPendleBuildMintPyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_redeem_py_multisign",
+    actionId: "pendle.redeem-py",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: redeem PT+YT multiSign. After expiry, pass amountYtHuman 0 (PT only). 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_redeem_py", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemPyBatch" },
+    inputZod: mcpPendleBuildRedeemPyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_mint_sy_multisign",
+    actionId: "pendle.mint-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: mint SY multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_mint_sy", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleMintSyBatch" },
+    inputZod: mcpPendleBuildMintSyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_redeem_sy_multisign",
+    actionId: "pendle.redeem-sy",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: redeem SY multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_redeem_sy", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemSyBatch" },
+    inputZod: mcpPendleBuildRedeemSyMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_add_liquidity_multisign",
+    actionId: "pendle.add-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: add LP multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_add_liquidity", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleAddLiquidityBatch" },
+    inputZod: mcpPendleBuildAddLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_remove_liquidity_multisign",
+    actionId: "pendle.remove-liquidity",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: remove LP multiSign. 30-min expiry default.",
+    prerequisites: ["ctm_pendle_quote_remove_liquidity", "keyGenId + purposeText + slippagePercent"],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRemoveLiquidityBatch" },
+    inputZod: mcpPendleBuildRemoveLiquidityMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_pendle_fetch_merkle_rewards",
+    actionId: "pendle.fetch-merkle-rewards",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: list off-chain airdrop rows for a wallet (token, amount). Informational only \u2014 Core has no claim proofs. Tell the user to claim airdrops on app.pendle.finance. Do not invent a claim tx. On-chain SY/YT/LP incentives use ctm_pendle_build_redeem_rewards_multisign.",
+    prerequisites: ["activate_tool_group pendle:rewards", "user address"],
+    followUp: [],
+    handler: { importPath: "protocols/evm/pendle", exportName: "pendleFetchMerkleRewards" },
+    inputZod: mcpPendleFetchMerkleRewardsInputSchema,
+    outputZod: mcpPendleFetchMerkleRewardsOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_pendle_build_redeem_rewards_multisign",
+    actionId: "pendle.redeem-rewards",
+    protocolId: "pendle",
+    chainCategory: "evm",
+    description: "Pendle V2: redeem on-chain interest and incentives from SY, YT, and LP (usually PENDLE) via Hosted SDK. Not merkle airdrops. 30-min expiry default.",
+    prerequisites: [
+      "activate_tool_group pendle:rewards",
+      "sys / yts / markets from fetch_markets or search",
+      "keyGenId + purposeText"
+    ],
+    handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemRewardsBatch" },
+    inputZod: mcpPendleBuildRedeemRewardsMultisignInputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -7504,6 +7923,17 @@ registerProtocolModule(ethenaProtocolModule);
 function isMapleSyrupSupportedChain(chainId) {
   return chainId === 1 || chainId === 11155111;
 }
+function matchesAssetFilter(opts) {
+  const f = (opts.filter ?? "").trim();
+  if (!f) return true;
+  const addr = (opts.address ?? "").trim();
+  if (viem.isAddress(f) && viem.isAddress(addr)) {
+    return viem.getAddress(addr) === viem.getAddress(f);
+  }
+  const sym = (opts.symbol ?? "").trim();
+  if (!sym) return false;
+  return sym.toLowerCase() === f.toLowerCase();
+}
 
 // src/protocols/evm/maple/index.ts
 var MAPLE_PROTOCOL_ID = "maple-syrup";
@@ -9802,6 +10232,347 @@ var compoundV3ProtocolModule = {
   ]
 };
 registerProtocolModule(compoundV3ProtocolModule);
+
+// src/protocols/evm/pendle/support.ts
+var PENDLE_PROTOCOL_ID = "pendle";
+var PENDLE_CORE_API_BASE = "https://api-v2.pendle.finance/core";
+var PENDLE_LISTING_CAP = 100;
+var PENDLE_LISTING_MAX_PAGES = 8;
+var PENDLE_ICON_CACHE_MS = 12 * 60 * 1e3;
+var PENDLE_CHAIN_CACHE_MS = 30 * 60 * 1e3;
+function parsePendleAssetId(id) {
+  const raw = (id ?? "").trim();
+  const dash = raw.indexOf("-");
+  if (dash <= 0) return null;
+  const chainId = Number.parseInt(raw.slice(0, dash), 10);
+  const address = raw.slice(dash + 1).trim();
+  if (!Number.isFinite(chainId) || chainId <= 0 || !address) return null;
+  return { chainId, address };
+}
+
+// src/protocols/evm/pendle/api.ts
+var FETCH_TIMEOUT_MS = 12e4;
+var PendleApiError = class extends Error {
+  status;
+  path;
+  constructor(message, status, path) {
+    super(message);
+    this.name = "PendleApiError";
+    this.status = status;
+    this.path = path;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function queryString(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === "") continue;
+    q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+async function pendleCoreFetch(args) {
+  const path = args.path.startsWith("/") ? args.path : `/${args.path}`;
+  const url = `${PENDLE_CORE_API_BASE}${path}${queryString(args.query ?? {})}`;
+  const headers = { Accept: "application/json" };
+  if (args.apiKey?.trim()) headers.Authorization = `Bearer ${args.apiKey.trim()}`;
+  if (args.body !== void 0) headers["Content-Type"] = "application/json";
+  let lastError;
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const res = await fetch(url, {
+        method: args.method ?? "GET",
+        headers,
+        body: args.body === void 0 ? void 0 : JSON.stringify(args.body),
+        signal: ac.signal
+      });
+      if (res.status === 429) {
+        const wait = Math.min(8e3, 500 * 2 ** attempt);
+        await sleep(wait);
+        lastError = new PendleApiError(`Pendle API rate limited (429) on ${path}`, 429, path);
+        continue;
+      }
+      const text = await res.text();
+      if (!res.ok) {
+        throw new PendleApiError(
+          `Pendle API ${res.status} ${path}: ${text.slice(0, 400)}`,
+          res.status,
+          path
+        );
+      }
+      if (!text.trim()) return {};
+      return JSON.parse(text);
+    } catch (err) {
+      lastError = err;
+      if (err instanceof PendleApiError && err.status !== 429) throw err;
+      if (attempt < 3 && (err instanceof PendleApiError || err?.name === "AbortError")) {
+        await sleep(Math.min(8e3, 400 * 2 ** attempt));
+        continue;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+// src/protocols/evm/pendle/discover.ts
+var marketsCacheByChain = /* @__PURE__ */ new Map();
+var chainIdsCache = null;
+function asRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function asNumber(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number.parseFloat(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function asString(v) {
+  if (typeof v === "string" && v.trim()) return v.trim();
+  return null;
+}
+function asExpiry(v) {
+  const s = asString(v);
+  if (s) return s;
+  const n = asNumber(v);
+  if (n == null) return null;
+  const ms = n < 1e12 ? n * 1e3 : n;
+  return new Date(ms).toISOString();
+}
+function pendleMarketExpiryMs(expiry) {
+  const raw = (expiry ?? "").trim();
+  if (!raw) return null;
+  if (/^\d+$/.test(raw)) {
+    const n = Number(raw);
+    return n < 1e12 ? n * 1e3 : n;
+  }
+  const t = Date.parse(raw);
+  return Number.isFinite(t) ? t : null;
+}
+function isPendleMarketExpired(row, nowMs = Date.now()) {
+  const t = pendleMarketExpiryMs(row.expiry);
+  if (t == null) return false;
+  return t <= nowMs;
+}
+function marketMatchesPin(row, address) {
+  const a = address.trim().toLowerCase();
+  if (!a) return false;
+  return [row.address, row.pt, row.yt, row.sy].some((x) => x.toLowerCase() === a);
+}
+function selectPendleListingMarkets(rows, args = {}) {
+  const nowMs = args.nowMs ?? Date.now();
+  const cap = args.cap ?? PENDLE_LISTING_CAP;
+  const pins = (args.includeAddresses ?? []).map((a) => a.trim().toLowerCase()).filter(Boolean);
+  const q = (args.query ?? "").trim();
+  let out = rows.filter((r) => {
+    const pinned = pins.some((p) => marketMatchesPin(r, p));
+    if (!args.includeExpired && !pinned && isPendleMarketExpired(r, nowMs)) return false;
+    if (args.pointsOnly && r.points.length === 0) return false;
+    if (q && !marketMatchesQuery(r, q)) return false;
+    return true;
+  });
+  out.sort(sortPendleMarketsByTvl);
+  return out.slice(0, cap);
+}
+function addressFromAssetIdOrHex(raw, fallbackChainId) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const parsed = parsePendleAssetId(raw);
+  if (parsed) {
+    try {
+      return viem.getAddress(parsed.address);
+    } catch {
+      return parsed.address.toLowerCase();
+    }
+  }
+  if (viem.isAddress(raw)) return viem.getAddress(raw);
+  if (raw.startsWith(`${fallbackChainId}-`)) {
+    const rest = raw.slice(String(fallbackChainId).length + 1);
+    if (viem.isAddress(rest)) return viem.getAddress(rest);
+  }
+  return null;
+}
+function parsePoints(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    const o = asRecord(item);
+    if (!o) continue;
+    const name = asString(o.name) ?? asString(o.key) ?? asString(o.pointName);
+    if (!name) continue;
+    out.push({
+      name,
+      type: asString(o.type),
+      pendleAsset: asString(o.pendleAsset),
+      value: asNumber(o.value)
+    });
+  }
+  return out;
+}
+function marketTvlUsd(row) {
+  return row.tvlUsd ?? row.liquidityUsd ?? 0;
+}
+function sortPendleMarketsByTvl(a, b) {
+  const d = marketTvlUsd(b) - marketTvlUsd(a);
+  if (d !== 0) return d;
+  return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+function parsePendleMarket(raw) {
+  const o = asRecord(raw);
+  if (!o) return null;
+  const chainId = asNumber(o.chainId);
+  const address = addressFromAssetIdOrHex(o.address, chainId ?? 0);
+  if (chainId == null || !address) return null;
+  const details = asRecord(o.details);
+  const tvl = asNumber(o.tvl) ?? asNumber(details?.tvl) ?? asNumber(details?.totalTvl) ?? asNumber(asRecord(details?.liquidity)?.usd);
+  const liquidity = asNumber(o.liquidity) ?? asNumber(details?.liquidity) ?? asNumber(asRecord(details?.liquidity)?.usd);
+  const impliedApy = asNumber(o.impliedApy) ?? asNumber(details?.impliedApy) ?? asNumber(asRecord(o.pt)?.impliedApy);
+  const pt = addressFromAssetIdOrHex(o.pt ?? asRecord(o.pt)?.address ?? asRecord(o.pt)?.id, chainId);
+  const yt = addressFromAssetIdOrHex(o.yt ?? asRecord(o.yt)?.address ?? asRecord(o.yt)?.id, chainId);
+  const sy = addressFromAssetIdOrHex(o.sy ?? asRecord(o.sy)?.address ?? asRecord(o.sy)?.id, chainId);
+  const underlying = addressFromAssetIdOrHex(
+    o.underlyingAsset ?? o.underlying ?? asRecord(o.underlyingAsset)?.address,
+    chainId
+  );
+  if (!pt || !yt || !sy || !underlying) return null;
+  const expired = asExpiry(o.expiry) ?? asExpiry(details?.expiry);
+  return {
+    chainId,
+    name: asString(o.name) ?? asString(o.proSymbol) ?? `${address.slice(0, 8)}\u2026`,
+    address,
+    expiry: expired,
+    pt,
+    yt,
+    sy,
+    underlying,
+    underlyingSymbol: asString(asRecord(o.underlyingAsset)?.symbol) ?? asString(o.underlyingSymbol),
+    ptSymbol: asString(asRecord(o.pt)?.symbol) ?? asString(o.ptSymbol),
+    ytSymbol: asString(asRecord(o.yt)?.symbol) ?? asString(o.ytSymbol),
+    impliedApy,
+    tvlUsd: tvl,
+    liquidityUsd: liquidity,
+    points: parsePoints(o.points ?? details?.points)
+  };
+}
+async function pendleFetchSupportedChainIds() {
+  const now = Date.now();
+  if (chainIdsCache && now - chainIdsCache.at < PENDLE_CHAIN_CACHE_MS) return chainIdsCache.chainIds;
+  const json = await pendleCoreFetch({ path: "/v1/chains" });
+  const ids = Array.isArray(json.chainIds) ? json.chainIds.map((n) => Number(n)).filter((n) => Number.isFinite(n) && n > 0) : [];
+  chainIdsCache = { at: now, chainIds: ids };
+  return ids;
+}
+async function isPendleChainSupported(chainId) {
+  try {
+    const ids = await pendleFetchSupportedChainIds();
+    if (ids.length === 0) return true;
+    return ids.includes(chainId);
+  } catch {
+    return true;
+  }
+}
+async function pendleFetchMarketsPage(args) {
+  const limit = Math.min(PENDLE_LISTING_CAP, Math.max(1, args.limit));
+  const json = await pendleCoreFetch({
+    path: "/v2/markets/all",
+    query: {
+      skip: args.skip ?? 0,
+      limit,
+      ...args.chainId != null ? { chainId: args.chainId } : {}
+    }
+  });
+  const raw = Array.isArray(json.markets) ? json.markets : Array.isArray(json.results) ? json.results : [];
+  const rows = [];
+  for (const item of raw) {
+    const row = parsePendleMarket(item);
+    if (row) rows.push(row);
+  }
+  return rows;
+}
+async function pendleFetchMarketsForChain(chainId) {
+  const now = Date.now();
+  const cached2 = marketsCacheByChain.get(chainId);
+  if (cached2 && now - cached2.at < PENDLE_ICON_CACHE_MS) return cached2.rows;
+  const rows = [];
+  for (let page = 0; page < PENDLE_LISTING_MAX_PAGES; page++) {
+    const batch = await pendleFetchMarketsPage({
+      skip: page * PENDLE_LISTING_CAP,
+      limit: PENDLE_LISTING_CAP,
+      chainId
+    });
+    const onChain = batch.filter((r) => r.chainId === chainId);
+    rows.push(...onChain);
+    if (batch.length < PENDLE_LISTING_CAP || onChain.length === 0) break;
+  }
+  marketsCacheByChain.set(chainId, { at: now, rows });
+  return rows;
+}
+function marketMatchesQuery(row, query) {
+  const q = query.trim();
+  if (!q) return true;
+  if (matchesAssetFilter({ address: row.address, symbol: row.name, filter: q }) || matchesAssetFilter({ address: row.pt, symbol: row.ptSymbol ?? void 0, filter: q }) || matchesAssetFilter({ address: row.yt, symbol: row.ytSymbol ?? void 0, filter: q }) || matchesAssetFilter({ address: row.sy, filter: q }) || matchesAssetFilter({ address: row.underlying, symbol: row.underlyingSymbol ?? void 0, filter: q })) {
+    return true;
+  }
+  const hay = `${row.name} ${row.ptSymbol ?? ""} ${row.ytSymbol ?? ""} ${row.underlyingSymbol ?? ""}`.toLowerCase();
+  return hay.includes(q.toLowerCase());
+}
+async function pendleFetchMarketsSummary(args) {
+  if (!await isPendleChainSupported(args.chainId)) {
+    return {
+      chainId: args.chainId,
+      markets: [],
+      notes: `Pendle Core API does not list chain ${args.chainId}.`
+    };
+  }
+  const scanned = await pendleFetchMarketsForChain(args.chainId);
+  const rows = selectPendleListingMarkets(scanned, {
+    query: args.query,
+    pointsOnly: args.pointsOnly,
+    includeAddresses: args.includeAddresses
+  });
+  const expiredOmitted = scanned.filter((r) => isPendleMarketExpired(r)).length;
+  return {
+    chainId: args.chainId,
+    markets: rows,
+    notes: `Top ${rows.length} active Pendle markets on chain ${args.chainId} by TVL/liquidity (scanned ${scanned.length}, omitted ${expiredOmitted} matured). Use ctm_pendle_search_assets for long-tail or expired markets (PT redeem / remove LP). Do not web-search Pendle APYs.`
+  };
+}
+
+// src/protocols/evm/pendle/index.ts
+var pendleProtocolModule = {
+  id: PENDLE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    if (!Number.isFinite(n)) return false;
+    return isPendleChainSupported(n);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    { id: "pendle.fetch-markets", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "List live Pendle markets (TVL-ranked, cap 100, matured omitted)", commonParams: [], params: {} },
+    { id: "pendle.search-assets", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Search live PT/YT/SY/underlying (matured only if address-pinned)", commonParams: [], params: {} },
+    { id: "pendle.swap", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Swap token \u2194 PT/YT via Hosted SDK convert", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.mint-py", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Mint PT + YT", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.redeem-py", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Redeem PT + YT (PT only after expiry)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.add-liquidity", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Add Pendle AMM liquidity", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.fetch-positions", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "List this wallet\u2019s Pendle LP (including matured)", commonParams: [], params: {} },
+    { id: "pendle.remove-liquidity", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Remove Pendle AMM liquidity", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "pendle.redeem-rewards", protocolId: PENDLE_PROTOCOL_ID, chainCategory: "evm", description: "Redeem on-chain SY/YT/LP interest and incentives (not merkle airdrops)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(pendleProtocolModule);
 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",
@@ -9818,6 +10589,7 @@ var SKILL_PROTOCOL_IDS = [
   "morpho",
   "circle-cctp",
   "aerodrome",
+  "pendle",
   "continuum-dao",
   "compound-v3",
   "yield-compare"
@@ -10298,6 +11070,55 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       return cache.has(normalized);
     }
   }),
+  [PENDLE_PROTOCOL_ID]: advisor(PENDLE_PROTOCOL_ID, "api_underlyings", {
+    async supportedChainIds() {
+      try {
+        return [...await pendleFetchSupportedChainIds()].sort((a, b) => a - b);
+      } catch {
+        return [];
+      }
+    },
+    async supportedTokens(chainId) {
+      if (!await isPendleChainSupported(chainId)) {
+        return { tokens: [], notes: `Pendle Core API does not list chain ${chainId}.` };
+      }
+      const listed = await pendleFetchMarketsSummary({ chainId });
+      const byAddr = /* @__PURE__ */ new Map();
+      const add = (address, symbol, roles) => {
+        const key = address.toLowerCase();
+        const prev = byAddr.get(key);
+        byAddr.set(key, {
+          address,
+          symbol: symbol ?? prev?.symbol,
+          roles: [.../* @__PURE__ */ new Set([...prev?.roles ?? [], ...roles])]
+        });
+      };
+      for (const m of listed.markets) {
+        add(m.underlying, m.underlyingSymbol, ["underlying"]);
+        add(m.pt, m.ptSymbol, ["pt"]);
+        add(m.yt, m.ytSymbol, ["yt"]);
+        add(m.sy, null, ["sy"]);
+        add(m.address, m.name, ["lp", "market"]);
+      }
+      return {
+        tokens: [...byAddr.values()],
+        notes: "Official Pendle live (unexpired) TVL-ranked markets on this chain, cap 100 (PT/YT/SY/LP + underlyings). Use ctm_pendle_search_assets for long-tail or matured markets. Use ctm_pendle_fetch_positions for this wallet\u2019s LP (including matured). Do not hardcode routers."
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      if (!await isPendleChainSupported(chainId)) return false;
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      const listed = await pendleFetchMarketsSummary({ chainId });
+      return listed.markets.some(
+        (m) => m.address.toLowerCase() === normalized || m.pt.toLowerCase() === normalized || m.yt.toLowerCase() === normalized || m.sy.toLowerCase() === normalized || m.underlying.toLowerCase() === normalized
+      );
+    }
+  }),
   arcus: advisor("arcus", "api_underlyings", {
     async supportedChainIds() {
       return [...ARCUS_SUPPORTED_CHAIN_IDS];
@@ -10335,6 +11156,7 @@ registerProtocolModule(veniceProtocolModule);
 registerProtocolModule(aerodromeProtocolModule);
 registerProtocolModule(continuumDaoProtocolModule);
 registerProtocolModule(compoundV3ProtocolModule);
+registerProtocolModule(pendleProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -10360,6 +11182,7 @@ function getAgentCatalog() {
     aerodrome: aerodromeProtocolModule,
     continuumDao: continuumDaoProtocolModule,
     compoundV3: compoundV3ProtocolModule,
+    pendle: pendleProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -10676,6 +11499,32 @@ exports.mcpMorphoVaultWithdrawInputSchema = mcpMorphoVaultWithdrawInputSchema;
 exports.mcpMultisignInput = mcpMultisignInput;
 exports.mcpMultisignOutputSchema = multisignOutputSchema;
 exports.mcpMultisignSubmitOutputSchema = mcpServerSubmitOutputSchema;
+exports.mcpPendleBuildAddLiquidityMultisignInputSchema = mcpPendleBuildAddLiquidityMultisignInputSchema;
+exports.mcpPendleBuildMintPyMultisignInputSchema = mcpPendleBuildMintPyMultisignInputSchema;
+exports.mcpPendleBuildMintSyMultisignInputSchema = mcpPendleBuildMintSyMultisignInputSchema;
+exports.mcpPendleBuildRedeemPyMultisignInputSchema = mcpPendleBuildRedeemPyMultisignInputSchema;
+exports.mcpPendleBuildRedeemRewardsMultisignInputSchema = mcpPendleBuildRedeemRewardsMultisignInputSchema;
+exports.mcpPendleBuildRedeemSyMultisignInputSchema = mcpPendleBuildRedeemSyMultisignInputSchema;
+exports.mcpPendleBuildRemoveLiquidityMultisignInputSchema = mcpPendleBuildRemoveLiquidityMultisignInputSchema;
+exports.mcpPendleBuildSwapMultisignInputSchema = mcpPendleBuildSwapMultisignInputSchema;
+exports.mcpPendleFetchMarketsInputSchema = mcpPendleFetchMarketsInputSchema;
+exports.mcpPendleFetchMarketsOutputSchema = mcpPendleFetchMarketsOutputSchema;
+exports.mcpPendleFetchMerkleRewardsInputSchema = mcpPendleFetchMerkleRewardsInputSchema;
+exports.mcpPendleFetchMerkleRewardsOutputSchema = mcpPendleFetchMerkleRewardsOutputSchema;
+exports.mcpPendleFetchPositionsInputSchema = mcpPendleFetchPositionsInputSchema;
+exports.mcpPendleFetchPositionsOutputSchema = mcpPendleFetchPositionsOutputSchema;
+exports.mcpPendleFetchPricesInputSchema = mcpPendleFetchPricesInputSchema;
+exports.mcpPendleFetchPricesOutputSchema = mcpPendleFetchPricesOutputSchema;
+exports.mcpPendleQuoteAddLiquidityInputSchema = mcpPendleQuoteAddLiquidityInputSchema;
+exports.mcpPendleQuoteMintPyInputSchema = mcpPendleQuoteMintPyInputSchema;
+exports.mcpPendleQuoteMintSyInputSchema = mcpPendleQuoteMintSyInputSchema;
+exports.mcpPendleQuoteOutputSchema = mcpPendleQuoteOutputSchema;
+exports.mcpPendleQuoteRedeemPyInputSchema = mcpPendleQuoteRedeemPyInputSchema;
+exports.mcpPendleQuoteRedeemSyInputSchema = mcpPendleQuoteRedeemSyInputSchema;
+exports.mcpPendleQuoteRemoveLiquidityInputSchema = mcpPendleQuoteRemoveLiquidityInputSchema;
+exports.mcpPendleQuoteSwapInputSchema = mcpPendleQuoteSwapInputSchema;
+exports.mcpPendleSearchAssetsInputSchema = mcpPendleSearchAssetsInputSchema;
+exports.mcpPendleSearchAssetsOutputSchema = mcpPendleSearchAssetsOutputSchema;
 exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;
 exports.mcpServerMultisignInput = mcpServerMultisignInput;
 exports.mcpServerSubmitOutputSchema = mcpServerSubmitOutputSchema;