@compass-labs/api-sdk 0.0.27 → 0.0.29

package/bin/mcp-server.js

@@ -34185,9 +34185,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.0.1",
-    sdkVersion: "0.0.27",
-    genVersion: "2.603.1",
-    userAgent: "speakeasy-sdk/typescript 0.0.27 2.603.1 0.0.1 @compass-labs/api-sdk"
+    sdkVersion: "0.0.29",
+    genVersion: "2.604.2",
+    userAgent: "speakeasy-sdk/typescript 0.0.29 2.604.2 0.0.1 @compass-labs/api-sdk"
   };
 });
 
@@ -35510,6 +35510,51 @@ var init_security = __esm(() => {
   };
 });
 
+// src/models/components/aaveavgrateresponse.ts
+var AaveAvgRateResponse$inboundSchema, AaveAvgRateResponse$outboundSchema, AaveAvgRateResponse$;
+var init_aaveavgrateresponse = __esm(() => {
+  init_lib();
+  init_primitives();
+  AaveAvgRateResponse$inboundSchema = objectType({
+    supply_apy_variable_rate: numberType(),
+    supply_apr_variable_rate: numberType(),
+    borrow_apy_variable_rate: numberType(),
+    borrow_apr_variable_rate: numberType(),
+    borrow_apy_fixed_rate: numberType(),
+    borrow_apr_fixed_rate: numberType()
+  }).transform((v2) => {
+    return remap(v2, {
+      supply_apy_variable_rate: "supplyApyVariableRate",
+      supply_apr_variable_rate: "supplyAprVariableRate",
+      borrow_apy_variable_rate: "borrowApyVariableRate",
+      borrow_apr_variable_rate: "borrowAprVariableRate",
+      borrow_apy_fixed_rate: "borrowApyFixedRate",
+      borrow_apr_fixed_rate: "borrowAprFixedRate"
+    });
+  });
+  AaveAvgRateResponse$outboundSchema = objectType({
+    supplyApyVariableRate: numberType(),
+    supplyAprVariableRate: numberType(),
+    borrowApyVariableRate: numberType(),
+    borrowAprVariableRate: numberType(),
+    borrowApyFixedRate: numberType(),
+    borrowAprFixedRate: numberType()
+  }).transform((v2) => {
+    return remap(v2, {
+      supplyApyVariableRate: "supply_apy_variable_rate",
+      supplyAprVariableRate: "supply_apr_variable_rate",
+      borrowApyVariableRate: "borrow_apy_variable_rate",
+      borrowAprVariableRate: "borrow_apr_variable_rate",
+      borrowApyFixedRate: "borrow_apy_fixed_rate",
+      borrowAprFixedRate: "borrow_apr_fixed_rate"
+    });
+  });
+  ((AaveAvgRateResponse$) => {
+    AaveAvgRateResponse$.inboundSchema = AaveAvgRateResponse$inboundSchema;
+    AaveAvgRateResponse$.outboundSchema = AaveAvgRateResponse$outboundSchema;
+  })(AaveAvgRateResponse$ ||= {});
+});
+
 // src/models/components/interestratemode.ts
 var InterestRateMode, InterestRateMode$inboundSchema, InterestRateMode$outboundSchema, InterestRateMode$;
 var init_interestratemode = __esm(() => {
@@ -37722,6 +37767,45 @@ var init_marketstate = __esm(() => {
   })(MarketState$ ||= {});
 });
 
+// src/models/components/morphoborrowparams.ts
+var MorphoBorrowParamsAmount$inboundSchema, MorphoBorrowParamsAmount$outboundSchema, MorphoBorrowParamsAmount$, MorphoBorrowParams$inboundSchema, MorphoBorrowParams$outboundSchema, MorphoBorrowParams$;
+var init_morphoborrowparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  MorphoBorrowParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  MorphoBorrowParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((MorphoBorrowParamsAmount$) => {
+    MorphoBorrowParamsAmount$.inboundSchema = MorphoBorrowParamsAmount$inboundSchema;
+    MorphoBorrowParamsAmount$.outboundSchema = MorphoBorrowParamsAmount$outboundSchema;
+  })(MorphoBorrowParamsAmount$ ||= {});
+  MorphoBorrowParams$inboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    unique_market_key: stringType(),
+    on_behalf_of: nullableType(stringType()).optional(),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      unique_market_key: "uniqueMarketKey",
+      on_behalf_of: "onBehalfOf"
+    });
+  });
+  MorphoBorrowParams$outboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    uniqueMarketKey: stringType(),
+    onBehalfOf: nullableType(stringType()).optional(),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      uniqueMarketKey: "unique_market_key",
+      onBehalfOf: "on_behalf_of"
+    });
+  });
+  ((MorphoBorrowParams$) => {
+    MorphoBorrowParams$.inboundSchema = MorphoBorrowParams$inboundSchema;
+    MorphoBorrowParams$.outboundSchema = MorphoBorrowParams$outboundSchema;
+  })(MorphoBorrowParams$ ||= {});
+});
+
 // src/models/components/morphoborrowrequest.ts
 var MorphoBorrowRequestChain, MorphoBorrowRequestAmount$inboundSchema, MorphoBorrowRequestAmount$outboundSchema, MorphoBorrowRequestAmount$, MorphoBorrowRequestChain$inboundSchema, MorphoBorrowRequestChain$outboundSchema, MorphoBorrowRequestChain$, MorphoBorrowRequest$inboundSchema, MorphoBorrowRequest$outboundSchema, MorphoBorrowRequest$;
 var init_morphoborrowrequest = __esm(() => {
@@ -37843,6 +37927,41 @@ var init_morphocheckvaultpositionresponse = __esm(() => {
   })(MorphoCheckVaultPositionResponse$ ||= {});
 });
 
+// src/models/components/morphodepositparams.ts
+var MorphoDepositParamsAmount$inboundSchema, MorphoDepositParamsAmount$outboundSchema, MorphoDepositParamsAmount$, MorphoDepositParams$inboundSchema, MorphoDepositParams$outboundSchema, MorphoDepositParams$;
+var init_morphodepositparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  MorphoDepositParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  MorphoDepositParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((MorphoDepositParamsAmount$) => {
+    MorphoDepositParamsAmount$.inboundSchema = MorphoDepositParamsAmount$inboundSchema;
+    MorphoDepositParamsAmount$.outboundSchema = MorphoDepositParamsAmount$outboundSchema;
+  })(MorphoDepositParamsAmount$ ||= {});
+  MorphoDepositParams$inboundSchema = objectType({
+    vault_address: stringType(),
+    amount: unionType([numberType(), stringType()]),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      vault_address: "vaultAddress"
+    });
+  });
+  MorphoDepositParams$outboundSchema = objectType({
+    vaultAddress: stringType(),
+    amount: unionType([numberType(), stringType()]),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      vaultAddress: "vault_address"
+    });
+  });
+  ((MorphoDepositParams$) => {
+    MorphoDepositParams$.inboundSchema = MorphoDepositParams$inboundSchema;
+    MorphoDepositParams$.outboundSchema = MorphoDepositParams$outboundSchema;
+  })(MorphoDepositParams$ ||= {});
+});
+
 // src/models/components/morphodepositrequest.ts
 var MorphoDepositRequestChain, MorphoDepositRequestAmount$inboundSchema, MorphoDepositRequestAmount$outboundSchema, MorphoDepositRequestAmount$, MorphoDepositRequestChain$inboundSchema, MorphoDepositRequestChain$outboundSchema, MorphoDepositRequestChain$, MorphoDepositRequest$inboundSchema, MorphoDepositRequest$outboundSchema, MorphoDepositRequest$;
 var init_morphodepositrequest = __esm(() => {
@@ -38046,6 +38165,42 @@ var init_morphogetvaultsresponse = __esm(() => {
   })(MorphoGetVaultsResponse$ ||= {});
 });
 
+// src/models/components/morphorepayparams.ts
+var MorphoRepayParams$inboundSchema, MorphoRepayParams$outboundSchema, MorphoRepayParams$;
+var init_morphorepayparams = __esm(() => {
+  init_lib();
+  init_base64();
+  init_primitives();
+  MorphoRepayParams$inboundSchema = objectType({
+    amount: anyType().optional(),
+    unique_market_key: stringType(),
+    on_behalf_of: nullableType(stringType()).optional(),
+    callback_data: nullableType(zodInbound).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      unique_market_key: "uniqueMarketKey",
+      on_behalf_of: "onBehalfOf",
+      callback_data: "callbackData"
+    });
+  });
+  MorphoRepayParams$outboundSchema = objectType({
+    amount: anyType().optional(),
+    uniqueMarketKey: stringType(),
+    onBehalfOf: nullableType(stringType()).optional(),
+    callbackData: nullableType(zodOutbound).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      uniqueMarketKey: "unique_market_key",
+      onBehalfOf: "on_behalf_of",
+      callbackData: "callback_data"
+    });
+  });
+  ((MorphoRepayParams$) => {
+    MorphoRepayParams$.inboundSchema = MorphoRepayParams$inboundSchema;
+    MorphoRepayParams$.outboundSchema = MorphoRepayParams$outboundSchema;
+  })(MorphoRepayParams$ ||= {});
+});
+
 // src/models/components/morphorepayrequest.ts
 var MorphoRepayRequestChain, MorphoRepayRequestChain$inboundSchema, MorphoRepayRequestChain$outboundSchema, MorphoRepayRequestChain$, MorphoRepayRequest$inboundSchema, MorphoRepayRequest$outboundSchema, MorphoRepayRequest$;
 var init_morphorepayrequest = __esm(() => {
@@ -38096,6 +38251,39 @@ var init_morphorepayrequest = __esm(() => {
   })(MorphoRepayRequest$ ||= {});
 });
 
+// src/models/components/morphosetvaultallowanceparams.ts
+var MorphoSetVaultAllowanceParamsAmount$inboundSchema, MorphoSetVaultAllowanceParamsAmount$outboundSchema, MorphoSetVaultAllowanceParamsAmount$, MorphoSetVaultAllowanceParams$inboundSchema, MorphoSetVaultAllowanceParams$outboundSchema, MorphoSetVaultAllowanceParams$;
+var init_morphosetvaultallowanceparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  MorphoSetVaultAllowanceParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  MorphoSetVaultAllowanceParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((MorphoSetVaultAllowanceParamsAmount$) => {
+    MorphoSetVaultAllowanceParamsAmount$.inboundSchema = MorphoSetVaultAllowanceParamsAmount$inboundSchema;
+    MorphoSetVaultAllowanceParamsAmount$.outboundSchema = MorphoSetVaultAllowanceParamsAmount$outboundSchema;
+  })(MorphoSetVaultAllowanceParamsAmount$ ||= {});
+  MorphoSetVaultAllowanceParams$inboundSchema = objectType({
+    vault_address: stringType(),
+    amount: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      vault_address: "vaultAddress"
+    });
+  });
+  MorphoSetVaultAllowanceParams$outboundSchema = objectType({
+    vaultAddress: stringType(),
+    amount: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      vaultAddress: "vault_address"
+    });
+  });
+  ((MorphoSetVaultAllowanceParams$) => {
+    MorphoSetVaultAllowanceParams$.inboundSchema = MorphoSetVaultAllowanceParams$inboundSchema;
+    MorphoSetVaultAllowanceParams$.outboundSchema = MorphoSetVaultAllowanceParams$outboundSchema;
+  })(MorphoSetVaultAllowanceParams$ ||= {});
+});
+
 // src/models/components/morphosetvaultallowancerequest.ts
 var MorphoSetVaultAllowanceRequestChain, MorphoSetVaultAllowanceRequestAmount$inboundSchema, MorphoSetVaultAllowanceRequestAmount$outboundSchema, MorphoSetVaultAllowanceRequestAmount$, MorphoSetVaultAllowanceRequestChain$inboundSchema, MorphoSetVaultAllowanceRequestChain$outboundSchema, MorphoSetVaultAllowanceRequestChain$, MorphoSetVaultAllowanceRequest$inboundSchema, MorphoSetVaultAllowanceRequest$outboundSchema, MorphoSetVaultAllowanceRequest$;
 var init_morphosetvaultallowancerequest = __esm(() => {
@@ -38143,6 +38331,48 @@ var init_morphosetvaultallowancerequest = __esm(() => {
   })(MorphoSetVaultAllowanceRequest$ ||= {});
 });
 
+// src/models/components/morphosupplycollateralparams.ts
+var MorphoSupplyCollateralParamsAmount$inboundSchema, MorphoSupplyCollateralParamsAmount$outboundSchema, MorphoSupplyCollateralParamsAmount$, MorphoSupplyCollateralParams$inboundSchema, MorphoSupplyCollateralParams$outboundSchema, MorphoSupplyCollateralParams$;
+var init_morphosupplycollateralparams = __esm(() => {
+  init_lib();
+  init_base64();
+  init_primitives();
+  MorphoSupplyCollateralParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  MorphoSupplyCollateralParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((MorphoSupplyCollateralParamsAmount$) => {
+    MorphoSupplyCollateralParamsAmount$.inboundSchema = MorphoSupplyCollateralParamsAmount$inboundSchema;
+    MorphoSupplyCollateralParamsAmount$.outboundSchema = MorphoSupplyCollateralParamsAmount$outboundSchema;
+  })(MorphoSupplyCollateralParamsAmount$ ||= {});
+  MorphoSupplyCollateralParams$inboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    unique_market_key: stringType(),
+    on_behalf_of: nullableType(stringType()).optional(),
+    callback_data: nullableType(zodInbound).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      unique_market_key: "uniqueMarketKey",
+      on_behalf_of: "onBehalfOf",
+      callback_data: "callbackData"
+    });
+  });
+  MorphoSupplyCollateralParams$outboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    uniqueMarketKey: stringType(),
+    onBehalfOf: nullableType(stringType()).optional(),
+    callbackData: nullableType(zodOutbound).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      uniqueMarketKey: "unique_market_key",
+      onBehalfOf: "on_behalf_of",
+      callbackData: "callback_data"
+    });
+  });
+  ((MorphoSupplyCollateralParams$) => {
+    MorphoSupplyCollateralParams$.inboundSchema = MorphoSupplyCollateralParams$inboundSchema;
+    MorphoSupplyCollateralParams$.outboundSchema = MorphoSupplyCollateralParams$outboundSchema;
+  })(MorphoSupplyCollateralParams$ ||= {});
+});
+
 // src/models/components/morphosupplycollateralrequest.ts
 var MorphoSupplyCollateralRequestChain, MorphoSupplyCollateralRequestAmount$inboundSchema, MorphoSupplyCollateralRequestAmount$outboundSchema, MorphoSupplyCollateralRequestAmount$, MorphoSupplyCollateralRequestChain$inboundSchema, MorphoSupplyCollateralRequestChain$outboundSchema, MorphoSupplyCollateralRequestChain$, MorphoSupplyCollateralRequest$inboundSchema, MorphoSupplyCollateralRequest$outboundSchema, MorphoSupplyCollateralRequest$;
 var init_morphosupplycollateralrequest = __esm(() => {
@@ -38199,6 +38429,45 @@ var init_morphosupplycollateralrequest = __esm(() => {
   })(MorphoSupplyCollateralRequest$ ||= {});
 });
 
+// src/models/components/morphowithdrawcollateralparams.ts
+var MorphoWithdrawCollateralParamsAmount$inboundSchema, MorphoWithdrawCollateralParamsAmount$outboundSchema, MorphoWithdrawCollateralParamsAmount$, MorphoWithdrawCollateralParams$inboundSchema, MorphoWithdrawCollateralParams$outboundSchema, MorphoWithdrawCollateralParams$;
+var init_morphowithdrawcollateralparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  MorphoWithdrawCollateralParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  MorphoWithdrawCollateralParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((MorphoWithdrawCollateralParamsAmount$) => {
+    MorphoWithdrawCollateralParamsAmount$.inboundSchema = MorphoWithdrawCollateralParamsAmount$inboundSchema;
+    MorphoWithdrawCollateralParamsAmount$.outboundSchema = MorphoWithdrawCollateralParamsAmount$outboundSchema;
+  })(MorphoWithdrawCollateralParamsAmount$ ||= {});
+  MorphoWithdrawCollateralParams$inboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    unique_market_key: stringType(),
+    on_behalf_of: nullableType(stringType()).optional(),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      unique_market_key: "uniqueMarketKey",
+      on_behalf_of: "onBehalfOf"
+    });
+  });
+  MorphoWithdrawCollateralParams$outboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    uniqueMarketKey: stringType(),
+    onBehalfOf: nullableType(stringType()).optional(),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      uniqueMarketKey: "unique_market_key",
+      onBehalfOf: "on_behalf_of"
+    });
+  });
+  ((MorphoWithdrawCollateralParams$) => {
+    MorphoWithdrawCollateralParams$.inboundSchema = MorphoWithdrawCollateralParams$inboundSchema;
+    MorphoWithdrawCollateralParams$.outboundSchema = MorphoWithdrawCollateralParams$outboundSchema;
+  })(MorphoWithdrawCollateralParams$ ||= {});
+});
+
 // src/models/components/morphowithdrawcollateralrequest.ts
 var MorphoWithdrawCollateralRequestChain, MorphoWithdrawCollateralRequestAmount$inboundSchema, MorphoWithdrawCollateralRequestAmount$outboundSchema, MorphoWithdrawCollateralRequestAmount$, MorphoWithdrawCollateralRequestChain$inboundSchema, MorphoWithdrawCollateralRequestChain$outboundSchema, MorphoWithdrawCollateralRequestChain$, MorphoWithdrawCollateralRequest$inboundSchema, MorphoWithdrawCollateralRequest$outboundSchema, MorphoWithdrawCollateralRequest$;
 var init_morphowithdrawcollateralrequest = __esm(() => {
@@ -38252,6 +38521,35 @@ var init_morphowithdrawcollateralrequest = __esm(() => {
   })(MorphoWithdrawCollateralRequest$ ||= {});
 });
 
+// src/models/components/morphowithdrawparams.ts
+var MorphoWithdrawParams$inboundSchema, MorphoWithdrawParams$outboundSchema, MorphoWithdrawParams$;
+var init_morphowithdrawparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  MorphoWithdrawParams$inboundSchema = objectType({
+    vault_address: stringType(),
+    amount: anyType().optional(),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      vault_address: "vaultAddress"
+    });
+  });
+  MorphoWithdrawParams$outboundSchema = objectType({
+    vaultAddress: stringType(),
+    amount: anyType().optional(),
+    receiver: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      vaultAddress: "vault_address"
+    });
+  });
+  ((MorphoWithdrawParams$) => {
+    MorphoWithdrawParams$.inboundSchema = MorphoWithdrawParams$inboundSchema;
+    MorphoWithdrawParams$.outboundSchema = MorphoWithdrawParams$outboundSchema;
+  })(MorphoWithdrawParams$ ||= {});
+});
+
 // src/models/components/morphowithdrawrequest.ts
 var MorphoWithdrawRequestChain, MorphoWithdrawRequestChain$inboundSchema, MorphoWithdrawRequestChain$outboundSchema, MorphoWithdrawRequestChain$, MorphoWithdrawRequest$inboundSchema, MorphoWithdrawRequest$outboundSchema, MorphoWithdrawRequest$;
 var init_morphowithdrawrequest = __esm(() => {
@@ -38311,6 +38609,17 @@ var init_multicallactiontype = __esm(() => {
     AerodromeSlipstreamWithdrawLiquidity: "AERODROME_SLIPSTREAM_WITHDRAW_LIQUIDITY",
     AllowanceIncrease: "ALLOWANCE_INCREASE",
     AllowanceIncreaseAny: "ALLOWANCE_INCREASE_ANY",
+    MorphoBorrow: "MORPHO_BORROW",
+    MorphoDeposit: "MORPHO_DEPOSIT",
+    MorphoRepay: "MORPHO_REPAY",
+    MorphoSetVaultAllowance: "MORPHO_SET_VAULT_ALLOWANCE",
+    MorphoSupplyCollateral: "MORPHO_SUPPLY_COLLATERAL",
+    MorphoWithdraw: "MORPHO_WITHDRAW",
+    MorphoWithdrawCollateral: "MORPHO_WITHDRAW_COLLATERAL",
+    SkyBuy: "SKY_BUY",
+    SkyDeposit: "SKY_DEPOSIT",
+    SkySell: "SKY_SELL",
+    SkyWithdraw: "SKY_WITHDRAW",
     TransferErc20: "TRANSFER_ERC20",
     UniswapAddLiquidity: "UNISWAP_ADD_LIQUIDITY",
     UniswapBuyExactly: "UNISWAP_BUY_EXACTLY",
@@ -38328,6 +38637,134 @@ var init_multicallactiontype = __esm(() => {
   })(MulticallActionType$ ||= {});
 });
 
+// src/models/components/skybuyparams.ts
+var SkyBuyParamsTokenIn, SkyBuyParamsTokenIn$inboundSchema, SkyBuyParamsTokenIn$outboundSchema, SkyBuyParamsTokenIn$, SkyBuyParamsAmount$inboundSchema, SkyBuyParamsAmount$outboundSchema, SkyBuyParamsAmount$, SkyBuyParams$inboundSchema, SkyBuyParams$outboundSchema, SkyBuyParams$;
+var init_skybuyparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  SkyBuyParamsTokenIn = {
+    Dai: "DAI",
+    Usdc: "USDC"
+  };
+  SkyBuyParamsTokenIn$inboundSchema = nativeEnumType(SkyBuyParamsTokenIn);
+  SkyBuyParamsTokenIn$outboundSchema = SkyBuyParamsTokenIn$inboundSchema;
+  ((SkyBuyParamsTokenIn$) => {
+    SkyBuyParamsTokenIn$.inboundSchema = SkyBuyParamsTokenIn$inboundSchema;
+    SkyBuyParamsTokenIn$.outboundSchema = SkyBuyParamsTokenIn$outboundSchema;
+  })(SkyBuyParamsTokenIn$ ||= {});
+  SkyBuyParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  SkyBuyParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((SkyBuyParamsAmount$) => {
+    SkyBuyParamsAmount$.inboundSchema = SkyBuyParamsAmount$inboundSchema;
+    SkyBuyParamsAmount$.outboundSchema = SkyBuyParamsAmount$outboundSchema;
+  })(SkyBuyParamsAmount$ ||= {});
+  SkyBuyParams$inboundSchema = objectType({
+    token_in: SkyBuyParamsTokenIn$inboundSchema,
+    amount: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      token_in: "tokenIn"
+    });
+  });
+  SkyBuyParams$outboundSchema = objectType({
+    tokenIn: SkyBuyParamsTokenIn$outboundSchema,
+    amount: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      tokenIn: "token_in"
+    });
+  });
+  ((SkyBuyParams$) => {
+    SkyBuyParams$.inboundSchema = SkyBuyParams$inboundSchema;
+    SkyBuyParams$.outboundSchema = SkyBuyParams$outboundSchema;
+  })(SkyBuyParams$ ||= {});
+});
+
+// src/models/components/skydepositparams.ts
+var SkyDepositParamsAmount$inboundSchema, SkyDepositParamsAmount$outboundSchema, SkyDepositParamsAmount$, SkyDepositParams$inboundSchema, SkyDepositParams$outboundSchema, SkyDepositParams$;
+var init_skydepositparams = __esm(() => {
+  init_lib();
+  SkyDepositParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  SkyDepositParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((SkyDepositParamsAmount$) => {
+    SkyDepositParamsAmount$.inboundSchema = SkyDepositParamsAmount$inboundSchema;
+    SkyDepositParamsAmount$.outboundSchema = SkyDepositParamsAmount$outboundSchema;
+  })(SkyDepositParamsAmount$ ||= {});
+  SkyDepositParams$inboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    receiver: nullableType(stringType()).optional()
+  });
+  SkyDepositParams$outboundSchema = objectType({
+    amount: unionType([numberType(), stringType()]),
+    receiver: nullableType(stringType()).optional()
+  });
+  ((SkyDepositParams$) => {
+    SkyDepositParams$.inboundSchema = SkyDepositParams$inboundSchema;
+    SkyDepositParams$.outboundSchema = SkyDepositParams$outboundSchema;
+  })(SkyDepositParams$ ||= {});
+});
+
+// src/models/components/skysellparams.ts
+var SkySellParamsTokenOut, SkySellParamsTokenOut$inboundSchema, SkySellParamsTokenOut$outboundSchema, SkySellParamsTokenOut$, SkySellParamsAmount$inboundSchema, SkySellParamsAmount$outboundSchema, SkySellParamsAmount$, SkySellParams$inboundSchema, SkySellParams$outboundSchema, SkySellParams$;
+var init_skysellparams = __esm(() => {
+  init_lib();
+  init_primitives();
+  SkySellParamsTokenOut = {
+    Dai: "DAI",
+    Usdc: "USDC"
+  };
+  SkySellParamsTokenOut$inboundSchema = nativeEnumType(SkySellParamsTokenOut);
+  SkySellParamsTokenOut$outboundSchema = SkySellParamsTokenOut$inboundSchema;
+  ((SkySellParamsTokenOut$) => {
+    SkySellParamsTokenOut$.inboundSchema = SkySellParamsTokenOut$inboundSchema;
+    SkySellParamsTokenOut$.outboundSchema = SkySellParamsTokenOut$outboundSchema;
+  })(SkySellParamsTokenOut$ ||= {});
+  SkySellParamsAmount$inboundSchema = unionType([numberType(), stringType()]);
+  SkySellParamsAmount$outboundSchema = unionType([numberType(), stringType()]);
+  ((SkySellParamsAmount$) => {
+    SkySellParamsAmount$.inboundSchema = SkySellParamsAmount$inboundSchema;
+    SkySellParamsAmount$.outboundSchema = SkySellParamsAmount$outboundSchema;
+  })(SkySellParamsAmount$ ||= {});
+  SkySellParams$inboundSchema = objectType({
+    token_out: SkySellParamsTokenOut$inboundSchema,
+    amount: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      token_out: "tokenOut"
+    });
+  });
+  SkySellParams$outboundSchema = objectType({
+    tokenOut: SkySellParamsTokenOut$outboundSchema,
+    amount: unionType([numberType(), stringType()])
+  }).transform((v2) => {
+    return remap(v2, {
+      tokenOut: "token_out"
+    });
+  });
+  ((SkySellParams$) => {
+    SkySellParams$.inboundSchema = SkySellParams$inboundSchema;
+    SkySellParams$.outboundSchema = SkySellParams$outboundSchema;
+  })(SkySellParams$ ||= {});
+});
+
+// src/models/components/skywithdrawparams.ts
+var SkyWithdrawParams$inboundSchema, SkyWithdrawParams$outboundSchema, SkyWithdrawParams$;
+var init_skywithdrawparams = __esm(() => {
+  init_lib();
+  SkyWithdrawParams$inboundSchema = objectType({
+    amount: anyType().optional(),
+    receiver: nullableType(stringType()).optional()
+  });
+  SkyWithdrawParams$outboundSchema = objectType({
+    amount: anyType().optional(),
+    receiver: nullableType(stringType()).optional()
+  });
+  ((SkyWithdrawParams$) => {
+    SkyWithdrawParams$.inboundSchema = SkyWithdrawParams$inboundSchema;
+    SkyWithdrawParams$.outboundSchema = SkyWithdrawParams$outboundSchema;
+  })(SkyWithdrawParams$ ||= {});
+});
+
 // src/models/components/tokentransfererc20params.ts
 var TokenTransferErc20ParamsAmount$inboundSchema, TokenTransferErc20ParamsAmount$outboundSchema, TokenTransferErc20ParamsAmount$, TokenTransferErc20Params$inboundSchema, TokenTransferErc20Params$outboundSchema, TokenTransferErc20Params$;
 var init_tokentransfererc20params = __esm(() => {
@@ -38692,7 +39129,18 @@ var init_multicallaction = __esm(() => {
   init_aerodromeslipstreamwithdrawliquidityprovisionparams();
   init_increaseallowanceanyparams();
   init_increaseallowanceparams();
+  init_morphoborrowparams();
+  init_morphodepositparams();
+  init_morphorepayparams();
+  init_morphosetvaultallowanceparams();
+  init_morphosupplycollateralparams();
+  init_morphowithdrawcollateralparams();
+  init_morphowithdrawparams();
   init_multicallactiontype();
+  init_skybuyparams();
+  init_skydepositparams();
+  init_skysellparams();
+  init_skywithdrawparams();
   init_tokentransfererc20params();
   init_uniswapbuyexactlyparams();
   init_uniswapincreaseliquidityprovisionparams();
@@ -38704,15 +39152,26 @@ var init_multicallaction = __esm(() => {
   Body$inboundSchema = unionType([
     UnwrapWethParams$inboundSchema,
     WrapEthParams$inboundSchema,
+    MorphoSetVaultAllowanceParams$inboundSchema,
+    SkyBuyParams$inboundSchema,
+    SkySellParams$inboundSchema,
+    SkyDepositParams$inboundSchema,
+    SkyWithdrawParams$inboundSchema,
     AerodromeSlipstreamWithdrawLiquidityProvisionParams$inboundSchema,
     UniswapWithdrawLiquidityProvisionParams$inboundSchema,
     AaveSupplyParams$inboundSchema,
     AaveWithdrawParams$inboundSchema,
+    MorphoDepositParams$inboundSchema,
+    MorphoWithdrawParams$inboundSchema,
     TokenTransferErc20Params$inboundSchema,
     IncreaseAllowanceParams$inboundSchema,
     IncreaseAllowanceAnyParams$inboundSchema,
     AaveBorrowParams$inboundSchema,
     AaveRepayParams$inboundSchema,
+    MorphoBorrowParams$inboundSchema,
+    MorphoRepayParams$inboundSchema,
+    MorphoSupplyCollateralParams$inboundSchema,
+    MorphoWithdrawCollateralParams$inboundSchema,
     AerodromeSlipstreamIncreaseLiquidityProvisionParams$inboundSchema,
     AerodromeSlipstreamBuyExactlyParams$inboundSchema,
     AerodromeSlipstreamSellExactlyParams$inboundSchema,
@@ -38725,15 +39184,26 @@ var init_multicallaction = __esm(() => {
   Body$outboundSchema = unionType([
     UnwrapWethParams$outboundSchema,
     WrapEthParams$outboundSchema,
+    MorphoSetVaultAllowanceParams$outboundSchema,
+    SkyBuyParams$outboundSchema,
+    SkySellParams$outboundSchema,
+    SkyDepositParams$outboundSchema,
+    SkyWithdrawParams$outboundSchema,
     AerodromeSlipstreamWithdrawLiquidityProvisionParams$outboundSchema,
     UniswapWithdrawLiquidityProvisionParams$outboundSchema,
     AaveSupplyParams$outboundSchema,
     AaveWithdrawParams$outboundSchema,
+    MorphoDepositParams$outboundSchema,
+    MorphoWithdrawParams$outboundSchema,
     TokenTransferErc20Params$outboundSchema,
     IncreaseAllowanceParams$outboundSchema,
     IncreaseAllowanceAnyParams$outboundSchema,
     AaveBorrowParams$outboundSchema,
     AaveRepayParams$outboundSchema,
+    MorphoBorrowParams$outboundSchema,
+    MorphoRepayParams$outboundSchema,
+    MorphoSupplyCollateralParams$outboundSchema,
+    MorphoWithdrawCollateralParams$outboundSchema,
     AerodromeSlipstreamIncreaseLiquidityProvisionParams$outboundSchema,
     AerodromeSlipstreamBuyExactlyParams$outboundSchema,
     AerodromeSlipstreamSellExactlyParams$outboundSchema,
@@ -38752,15 +39222,26 @@ var init_multicallaction = __esm(() => {
     body: unionType([
       UnwrapWethParams$inboundSchema,
       WrapEthParams$inboundSchema,
+      MorphoSetVaultAllowanceParams$inboundSchema,
+      SkyBuyParams$inboundSchema,
+      SkySellParams$inboundSchema,
+      SkyDepositParams$inboundSchema,
+      SkyWithdrawParams$inboundSchema,
       AerodromeSlipstreamWithdrawLiquidityProvisionParams$inboundSchema,
       UniswapWithdrawLiquidityProvisionParams$inboundSchema,
       AaveSupplyParams$inboundSchema,
       AaveWithdrawParams$inboundSchema,
+      MorphoDepositParams$inboundSchema,
+      MorphoWithdrawParams$inboundSchema,
       TokenTransferErc20Params$inboundSchema,
       IncreaseAllowanceParams$inboundSchema,
       IncreaseAllowanceAnyParams$inboundSchema,
       AaveBorrowParams$inboundSchema,
       AaveRepayParams$inboundSchema,
+      MorphoBorrowParams$inboundSchema,
+      MorphoRepayParams$inboundSchema,
+      MorphoSupplyCollateralParams$inboundSchema,
+      MorphoWithdrawCollateralParams$inboundSchema,
       AerodromeSlipstreamIncreaseLiquidityProvisionParams$inboundSchema,
       AerodromeSlipstreamBuyExactlyParams$inboundSchema,
       AerodromeSlipstreamSellExactlyParams$inboundSchema,
@@ -38780,15 +39261,26 @@ var init_multicallaction = __esm(() => {
     body: unionType([
       UnwrapWethParams$outboundSchema,
       WrapEthParams$outboundSchema,
+      MorphoSetVaultAllowanceParams$outboundSchema,
+      SkyBuyParams$outboundSchema,
+      SkySellParams$outboundSchema,
+      SkyDepositParams$outboundSchema,
+      SkyWithdrawParams$outboundSchema,
       AerodromeSlipstreamWithdrawLiquidityProvisionParams$outboundSchema,
       UniswapWithdrawLiquidityProvisionParams$outboundSchema,
       AaveSupplyParams$outboundSchema,
       AaveWithdrawParams$outboundSchema,
+      MorphoDepositParams$outboundSchema,
+      MorphoWithdrawParams$outboundSchema,
       TokenTransferErc20Params$outboundSchema,
       IncreaseAllowanceParams$outboundSchema,
       IncreaseAllowanceAnyParams$outboundSchema,
       AaveBorrowParams$outboundSchema,
       AaveRepayParams$outboundSchema,
+      MorphoBorrowParams$outboundSchema,
+      MorphoRepayParams$outboundSchema,
+      MorphoSupplyCollateralParams$outboundSchema,
+      MorphoWithdrawCollateralParams$outboundSchema,
       AerodromeSlipstreamIncreaseLiquidityProvisionParams$outboundSchema,
       AerodromeSlipstreamBuyExactlyParams$outboundSchema,
       AerodromeSlipstreamSellExactlyParams$outboundSchema,
@@ -38978,20 +39470,20 @@ var init_security2 = __esm(() => {
 });
 
 // src/models/components/skybuyrequest.ts
-var TokenIn, TokenIn$inboundSchema, TokenIn$outboundSchema, TokenIn$, SkyBuyRequestAmount$inboundSchema, SkyBuyRequestAmount$outboundSchema, SkyBuyRequestAmount$, SkyBuyRequest$inboundSchema, SkyBuyRequest$outboundSchema, SkyBuyRequest$;
+var SkyBuyRequestTokenIn, SkyBuyRequestTokenIn$inboundSchema, SkyBuyRequestTokenIn$outboundSchema, SkyBuyRequestTokenIn$, SkyBuyRequestAmount$inboundSchema, SkyBuyRequestAmount$outboundSchema, SkyBuyRequestAmount$, SkyBuyRequest$inboundSchema, SkyBuyRequest$outboundSchema, SkyBuyRequest$;
 var init_skybuyrequest = __esm(() => {
   init_lib();
   init_primitives();
-  TokenIn = {
+  SkyBuyRequestTokenIn = {
     Dai: "DAI",
     Usdc: "USDC"
   };
-  TokenIn$inboundSchema = nativeEnumType(TokenIn);
-  TokenIn$outboundSchema = TokenIn$inboundSchema;
-  ((TokenIn$) => {
-    TokenIn$.inboundSchema = TokenIn$inboundSchema;
-    TokenIn$.outboundSchema = TokenIn$outboundSchema;
-  })(TokenIn$ ||= {});
+  SkyBuyRequestTokenIn$inboundSchema = nativeEnumType(SkyBuyRequestTokenIn);
+  SkyBuyRequestTokenIn$outboundSchema = SkyBuyRequestTokenIn$inboundSchema;
+  ((SkyBuyRequestTokenIn$) => {
+    SkyBuyRequestTokenIn$.inboundSchema = SkyBuyRequestTokenIn$inboundSchema;
+    SkyBuyRequestTokenIn$.outboundSchema = SkyBuyRequestTokenIn$outboundSchema;
+  })(SkyBuyRequestTokenIn$ ||= {});
   SkyBuyRequestAmount$inboundSchema = unionType([numberType(), stringType()]);
   SkyBuyRequestAmount$outboundSchema = unionType([numberType(), stringType()]);
   ((SkyBuyRequestAmount$) => {
@@ -38999,7 +39491,7 @@ var init_skybuyrequest = __esm(() => {
     SkyBuyRequestAmount$.outboundSchema = SkyBuyRequestAmount$outboundSchema;
   })(SkyBuyRequestAmount$ ||= {});
   SkyBuyRequest$inboundSchema = objectType({
-    token_in: TokenIn$inboundSchema,
+    token_in: SkyBuyRequestTokenIn$inboundSchema,
     amount: unionType([numberType(), stringType()]),
     chain: literalType("ethereum:mainnet").default("ethereum:mainnet"),
     sender: stringType()
@@ -39009,7 +39501,7 @@ var init_skybuyrequest = __esm(() => {
     });
   });
   SkyBuyRequest$outboundSchema = objectType({
-    tokenIn: TokenIn$outboundSchema,
+    tokenIn: SkyBuyRequestTokenIn$outboundSchema,
     amount: unionType([numberType(), stringType()]),
     chain: literalType("ethereum:mainnet").default("ethereum:mainnet"),
     sender: stringType()
@@ -39080,20 +39572,20 @@ var init_skydepositrequest = __esm(() => {
 });
 
 // src/models/components/skysellrequest.ts
-var TokenOut, TokenOut$inboundSchema, TokenOut$outboundSchema, TokenOut$, SkySellRequestAmount$inboundSchema, SkySellRequestAmount$outboundSchema, SkySellRequestAmount$, SkySellRequest$inboundSchema, SkySellRequest$outboundSchema, SkySellRequest$;
+var SkySellRequestTokenOut, SkySellRequestTokenOut$inboundSchema, SkySellRequestTokenOut$outboundSchema, SkySellRequestTokenOut$, SkySellRequestAmount$inboundSchema, SkySellRequestAmount$outboundSchema, SkySellRequestAmount$, SkySellRequest$inboundSchema, SkySellRequest$outboundSchema, SkySellRequest$;
 var init_skysellrequest = __esm(() => {
   init_lib();
   init_primitives();
-  TokenOut = {
+  SkySellRequestTokenOut = {
     Dai: "DAI",
     Usdc: "USDC"
   };
-  TokenOut$inboundSchema = nativeEnumType(TokenOut);
-  TokenOut$outboundSchema = TokenOut$inboundSchema;
-  ((TokenOut$) => {
-    TokenOut$.inboundSchema = TokenOut$inboundSchema;
-    TokenOut$.outboundSchema = TokenOut$outboundSchema;
-  })(TokenOut$ ||= {});
+  SkySellRequestTokenOut$inboundSchema = nativeEnumType(SkySellRequestTokenOut);
+  SkySellRequestTokenOut$outboundSchema = SkySellRequestTokenOut$inboundSchema;
+  ((SkySellRequestTokenOut$) => {
+    SkySellRequestTokenOut$.inboundSchema = SkySellRequestTokenOut$inboundSchema;
+    SkySellRequestTokenOut$.outboundSchema = SkySellRequestTokenOut$outboundSchema;
+  })(SkySellRequestTokenOut$ ||= {});
   SkySellRequestAmount$inboundSchema = unionType([numberType(), stringType()]);
   SkySellRequestAmount$outboundSchema = unionType([numberType(), stringType()]);
   ((SkySellRequestAmount$) => {
@@ -39101,7 +39593,7 @@ var init_skysellrequest = __esm(() => {
     SkySellRequestAmount$.outboundSchema = SkySellRequestAmount$outboundSchema;
   })(SkySellRequestAmount$ ||= {});
   SkySellRequest$inboundSchema = objectType({
-    token_out: TokenOut$inboundSchema,
+    token_out: SkySellRequestTokenOut$inboundSchema,
     amount: unionType([numberType(), stringType()]),
     chain: literalType("ethereum:mainnet").default("ethereum:mainnet"),
     sender: stringType()
@@ -39111,7 +39603,7 @@ var init_skysellrequest = __esm(() => {
     });
   });
   SkySellRequest$outboundSchema = objectType({
-    tokenOut: TokenOut$outboundSchema,
+    tokenOut: SkySellRequestTokenOut$outboundSchema,
     amount: unionType([numberType(), stringType()]),
     chain: literalType("ethereum:mainnet").default("ethereum:mainnet"),
     sender: stringType()
@@ -39917,6 +40409,7 @@ var init_wrapethrequest = __esm(() => {
 
 // src/models/components/index.ts
 var init_components = __esm(() => {
+  init_aaveavgrateresponse();
   init_aaveborrowparams();
   init_aaveborrowrequest();
   init_aavehistoricaltransactionsresponse();
@@ -39962,18 +40455,25 @@ var init_components = __esm(() => {
   init_interestratemode();
   init_liquidationcall();
   init_marketstate();
+  init_morphoborrowparams();
   init_morphoborrowrequest();
   init_morphocheckmarketpositionresponse();
   init_morphocheckvaultpositionresponse();
+  init_morphodepositparams();
   init_morphodepositrequest();
   init_morphogetmarketsresponse();
   init_morphogetvaultsresponse();
   init_morphomarket();
+  init_morphorepayparams();
   init_morphorepayrequest();
+  init_morphosetvaultallowanceparams();
   init_morphosetvaultallowancerequest();
+  init_morphosupplycollateralparams();
   init_morphosupplycollateralrequest();
   init_morphovault();
+  init_morphowithdrawcollateralparams();
   init_morphowithdrawcollateralrequest();
+  init_morphowithdrawparams();
   init_morphowithdrawrequest();
   init_multicallaction();
   init_multicallactiontype();
@@ -39986,10 +40486,14 @@ var init_components = __esm(() => {
   init_reserve();
   init_security2();
   init_signedauthorization();
+  init_skybuyparams();
   init_skybuyrequest();
   init_skycheckpositionresponse();
+  init_skydepositparams();
   init_skydepositrequest();
+  init_skysellparams();
   init_skysellrequest();
+  init_skywithdrawparams();
   init_skywithdrawrequest();
   init_supply();
   init_swapborrowrate();
@@ -40068,134 +40572,87 @@ var init_errors = __esm(() => {
   init_sdkvalidationerror();
 });
 
-// src/types/async.ts
-var APIPromise;
-var init_async = __esm(() => {
-  APIPromise = class APIPromise {
-    #promise;
-    #unwrapped;
-    [Symbol.toStringTag] = "APIPromise";
-    constructor(p) {
-      this.#promise = p instanceof Promise ? p : Promise.resolve(p);
-      this.#unwrapped = p instanceof Promise ? this.#promise.then(([value]) => value) : Promise.resolve(p[0]);
-    }
-    then(onfulfilled, onrejected) {
-      return this.#promise.then(onfulfilled ? ([value]) => onfulfilled(value) : undefined, onrejected);
-    }
-    catch(onrejected) {
-      return this.#unwrapped.catch(onrejected);
-    }
-    finally(onfinally) {
-      return this.#unwrapped.finally(onfinally);
-    }
-    $inspect() {
-      return this.#promise;
-    }
+// src/models/operations/aaveavgrate.ts
+var AaveAvgRateChain, AaveAvgRateToken, AaveAvgRateChain$inboundSchema, AaveAvgRateChain$outboundSchema, AaveAvgRateChain$, AaveAvgRateToken$inboundSchema, AaveAvgRateToken$outboundSchema, AaveAvgRateToken$, AaveAvgRateRequest$inboundSchema, AaveAvgRateRequest$outboundSchema, AaveAvgRateRequest$;
+var init_aaveavgrate = __esm(() => {
+  init_lib();
+  AaveAvgRateChain = {
+    BaseMainnet: "base:mainnet",
+    EthereumMainnet: "ethereum:mainnet",
+    ArbitrumMainnet: "arbitrum:mainnet"
   };
-});
-
-// src/funcs/aaveV3Borrow.ts
-function aaveV3Borrow(client, request, options) {
-  return new APIPromise($do(client, request, options));
-}
-async function $do(client, request, options) {
-  const parsed = safeParse(request, (value) => AaveBorrowRequest$outboundSchema.parse(value), "Input validation failed");
-  if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
-  }
-  const payload = parsed.value;
-  const body = encodeJSON("body", payload, { explode: true });
-  const path = pathToFunc("/v0/aave/borrow")();
-  const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
-    Accept: "application/json"
-  }));
-  const secConfig = await extractSecurity(client._options.apiKeyAuth);
-  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
-  const requestSecurity = resolveGlobalSecurity(securityInput);
-  const context = {
-    baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "aave_borrow",
-    oAuth2Scopes: [],
-    resolvedSecurity: requestSecurity,
-    securitySource: client._options.apiKeyAuth,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
-  };
-  const requestRes = client._createRequest(context, {
-    security: requestSecurity,
-    method: "POST",
-    baseURL: options?.serverURL,
-    path,
-    headers,
-    body,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
-  }, options);
-  if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
-  }
-  const req = requestRes.value;
-  const doResult = await client._do(req, {
-    context,
-    errorCodes: ["422", "4XX", "5XX"],
-    retryConfig: context.retryConfig,
-    retryCodes: context.retryCodes
-  });
-  if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
-  }
-  const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, UnsignedTransaction$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
-  if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
-  }
-  return [result, { status: "complete", request: req, response }];
-}
-var init_aaveV3Borrow = __esm(() => {
-  init_encodings();
-  init_matchers();
-  init_primitives();
-  init_schemas();
-  init_security();
-  init_url();
-  init_components();
-  init_errors();
-  init_async();
-});
-
-// src/mcp-server/tools/aaveV3Borrow.ts
-var args, tool$aaveV3Borrow;
-var init_aaveV3Borrow2 = __esm(() => {
-  init_aaveV3Borrow();
-  init_components();
-  init_tools();
-  args = {
-    request: AaveBorrowRequest$inboundSchema
-  };
-  tool$aaveV3Borrow = {
-    name: "aave-v3-borrow",
-    description: `Borrow
-
-You will pay interest for your borrows.
-
-Price changes in the assets may lead to some or all of your collateral being
-liquidated, if the borrow position becomes unhealthy.`,
-    args,
-    tool: async (client, args2, ctx) => {
-      const [result, apiCall] = await aaveV3Borrow(client, args2.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
-      if (!result.ok) {
-        return {
-          content: [{ type: "text", text: result.error.message }],
-          isError: true
-        };
-      }
-      const value = result.value;
-      return formatResult(value, apiCall);
-    }
+  AaveAvgRateToken = {
+    OneINCH: "1INCH",
+    Aave: "AAVE",
+    Bal: "BAL",
+    CbBTC: "cbBTC",
+    CbETH: "cbETH",
+    Crv: "CRV",
+    CrvUSD: "crvUSD",
+    Dai: "DAI",
+    Ens: "ENS",
+    ETHx: "ETHx",
+    Frax: "FRAX",
+    Fxs: "FXS",
+    Gho: "GHO",
+    Knc: "KNC",
+    Ldo: "LDO",
+    Link: "LINK",
+    Lusd: "LUSD",
+    Mkr: "MKR",
+    OsETH: "osETH",
+    Pyusd: "PYUSD",
+    RETH: "rETH",
+    Rpl: "RPL",
+    RsETH: "rsETH",
+    SDAI: "sDAI",
+    Snx: "SNX",
+    Stg: "STG",
+    SUSDe: "sUSDe",
+    TBTC: "tBTC",
+    Uni: "UNI",
+    Usdc: "USDC",
+    USDe: "USDe",
+    Usds: "USDS",
+    Usdt: "USDT",
+    Wbtc: "WBTC",
+    WeETH: "weETH",
+    Weth: "WETH",
+    WstETH: "wstETH",
+    Arb: "ARB",
+    Eurs: "EURS",
+    Mai: "MAI",
+    USDCe: "USDCe",
+    Aero: "AERO",
+    Eur: "EUR",
+    Virtual: "VIRTUAL"
   };
+  AaveAvgRateChain$inboundSchema = nativeEnumType(AaveAvgRateChain);
+  AaveAvgRateChain$outboundSchema = AaveAvgRateChain$inboundSchema;
+  ((AaveAvgRateChain$) => {
+    AaveAvgRateChain$.inboundSchema = AaveAvgRateChain$inboundSchema;
+    AaveAvgRateChain$.outboundSchema = AaveAvgRateChain$outboundSchema;
+  })(AaveAvgRateChain$ ||= {});
+  AaveAvgRateToken$inboundSchema = nativeEnumType(AaveAvgRateToken);
+  AaveAvgRateToken$outboundSchema = AaveAvgRateToken$inboundSchema;
+  ((AaveAvgRateToken$) => {
+    AaveAvgRateToken$.inboundSchema = AaveAvgRateToken$inboundSchema;
+    AaveAvgRateToken$.outboundSchema = AaveAvgRateToken$outboundSchema;
+  })(AaveAvgRateToken$ ||= {});
+  AaveAvgRateRequest$inboundSchema = objectType({
+    chain: AaveAvgRateChain$inboundSchema.default("ethereum:mainnet"),
+    token: AaveAvgRateToken$inboundSchema.default("USDC"),
+    days: numberType().int().default(7)
+  });
+  AaveAvgRateRequest$outboundSchema = objectType({
+    chain: AaveAvgRateChain$outboundSchema.default("ethereum:mainnet"),
+    token: AaveAvgRateToken$outboundSchema.default("USDC"),
+    days: numberType().int().default(7)
+  });
+  ((AaveAvgRateRequest$) => {
+    AaveAvgRateRequest$.inboundSchema = AaveAvgRateRequest$inboundSchema;
+    AaveAvgRateRequest$.outboundSchema = AaveAvgRateRequest$outboundSchema;
+  })(AaveAvgRateRequest$ ||= {});
 });
 
 // src/models/operations/aavehistoricaltransactions.ts
@@ -42061,6 +42518,7 @@ var init_uniswapquotesellexactly = __esm(() => {
 
 // src/models/operations/index.ts
 var init_operations = __esm(() => {
+  init_aaveavgrate();
   init_aavehistoricaltransactions();
   init_aaveliquiditychange();
   init_aaverate();
@@ -42090,11 +42548,248 @@ var init_operations = __esm(() => {
   init_uniswapquotesellexactly();
 });
 
-// src/funcs/aaveV3HistoricalTransactions.ts
-function aaveV3HistoricalTransactions(client, request, options) {
+// src/types/async.ts
+var APIPromise;
+var init_async = __esm(() => {
+  APIPromise = class APIPromise {
+    #promise;
+    #unwrapped;
+    [Symbol.toStringTag] = "APIPromise";
+    constructor(p) {
+      this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+      this.#unwrapped = p instanceof Promise ? this.#promise.then(([value]) => value) : Promise.resolve(p[0]);
+    }
+    then(onfulfilled, onrejected) {
+      return this.#promise.then(onfulfilled ? ([value]) => onfulfilled(value) : undefined, onrejected);
+    }
+    catch(onrejected) {
+      return this.#unwrapped.catch(onrejected);
+    }
+    finally(onfinally) {
+      return this.#unwrapped.finally(onfinally);
+    }
+    $inspect() {
+      return this.#promise;
+    }
+  };
+});
+
+// src/funcs/aaveV3AvgRate.ts
+function aaveV3AvgRate(client, request, options) {
+  return new APIPromise($do(client, request, options));
+}
+async function $do(client, request, options) {
+  const parsed = safeParse(request, (value) => AaveAvgRateRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/v0/aave/avg_rate/get")();
+  const query = encodeFormQuery({
+    chain: payload.chain,
+    days: payload.days,
+    token: payload.token
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "aave_avg_rate",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, AaveAvgRateResponse$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_aaveV3AvgRate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/aaveV3AvgRate.ts
+var args, tool$aaveV3AvgRate;
+var init_aaveV3AvgRate2 = __esm(() => {
+  init_aaveV3AvgRate();
+  init_operations();
+  init_tools();
+  args = {
+    request: AaveAvgRateRequest$inboundSchema
+  };
+  tool$aaveV3AvgRate = {
+    name: "aave-v3-avg-rate",
+    description: `Average interest rates
+
+Returns time averaged Interest Rates for Aave Reserves:`,
+    args,
+    tool: async (client, args2, ctx) => {
+      const [result, apiCall] = await aaveV3AvgRate(client, args2.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/aaveV3Borrow.ts
+function aaveV3Borrow(client, request, options) {
   return new APIPromise($do2(client, request, options));
 }
 async function $do2(client, request, options) {
+  const parsed = safeParse(request, (value) => AaveBorrowRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v0/aave/borrow")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKeyAuth);
+  const securityInput = secConfig == null ? {} : { apiKeyAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "aave_borrow",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKeyAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, UnsignedTransaction$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_aaveV3Borrow = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_async();
+});
+
+// src/mcp-server/tools/aaveV3Borrow.ts
+var args2, tool$aaveV3Borrow;
+var init_aaveV3Borrow2 = __esm(() => {
+  init_aaveV3Borrow();
+  init_components();
+  init_tools();
+  args2 = {
+    request: AaveBorrowRequest$inboundSchema
+  };
+  tool$aaveV3Borrow = {
+    name: "aave-v3-borrow",
+    description: `Borrow
+
+You will pay interest for your borrows.
+
+Price changes in the assets may lead to some or all of your collateral being
+liquidated, if the borrow position becomes unhealthy.`,
+    args: args2,
+    tool: async (client, args3, ctx) => {
+      const [result, apiCall] = await aaveV3Borrow(client, args3.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/aaveV3HistoricalTransactions.ts
+function aaveV3HistoricalTransactions(client, request, options) {
+  return new APIPromise($do3(client, request, options));
+}
+async function $do3(client, request, options) {
   const parsed = safeParse(request, (value) => AaveHistoricalTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42170,12 +42865,12 @@ var init_aaveV3HistoricalTransactions = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3HistoricalTransactions.ts
-var args2, tool$aaveV3HistoricalTransactions;
+var args3, tool$aaveV3HistoricalTransactions;
 var init_aaveV3HistoricalTransactions2 = __esm(() => {
   init_aaveV3HistoricalTransactions();
   init_operations();
   init_tools();
-  args2 = {
+  args3 = {
     request: AaveHistoricalTransactionsRequest$inboundSchema
   };
   tool$aaveV3HistoricalTransactions = {
@@ -42188,9 +42883,9 @@ It returns a list of transactions including deposits, withdrawals, borrows, and
 repayments. Each transaction includes details such as the token, amount, timestamp,
 and transaction type. This provides a comprehensive view of the user's historical
 activity within the AAVE protocol.`,
-    args: args2,
-    tool: async (client, args3, ctx) => {
-      const [result, apiCall] = await aaveV3HistoricalTransactions(client, args3.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args3,
+    tool: async (client, args4, ctx) => {
+      const [result, apiCall] = await aaveV3HistoricalTransactions(client, args4.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42205,9 +42900,9 @@ activity within the AAVE protocol.`,
 
 // src/funcs/aaveV3LiquidityChange.ts
 function aaveV3LiquidityChange(client, request, options) {
-  return new APIPromise($do3(client, request, options));
+  return new APIPromise($do4(client, request, options));
 }
-async function $do3(client, request, options) {
+async function $do4(client, request, options) {
   const parsed = safeParse(request, (value) => AaveLiquidityChangeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42283,12 +42978,12 @@ var init_aaveV3LiquidityChange = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3LiquidityChange.ts
-var args3, tool$aaveV3LiquidityChange;
+var args4, tool$aaveV3LiquidityChange;
 var init_aaveV3LiquidityChange2 = __esm(() => {
   init_aaveV3LiquidityChange();
   init_operations();
   init_tools();
-  args3 = {
+  args4 = {
     request: AaveLiquidityChangeRequest$inboundSchema
   };
   tool$aaveV3LiquidityChange = {
@@ -42306,9 +43001,9 @@ at the start block, a positive liquidity index change will represent accrued
 interest and a profit. If tokens were borrowed at the start block, this debt will
 increase, compound on itself and represent large debt. The reverse in both cases is
 true if the liquidity index is negative.`,
-    args: args3,
-    tool: async (client, args4, ctx) => {
-      const [result, apiCall] = await aaveV3LiquidityChange(client, args4.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args4,
+    tool: async (client, args5, ctx) => {
+      const [result, apiCall] = await aaveV3LiquidityChange(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42323,9 +43018,9 @@ true if the liquidity index is negative.`,
 
 // src/funcs/aaveV3Rate.ts
 function aaveV3Rate(client, request, options) {
-  return new APIPromise($do4(client, request, options));
+  return new APIPromise($do5(client, request, options));
 }
-async function $do4(client, request, options) {
+async function $do5(client, request, options) {
   const parsed = safeParse(request, (value) => AaveRateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42399,12 +43094,12 @@ var init_aaveV3Rate = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3Rate.ts
-var args4, tool$aaveV3Rate;
+var args5, tool$aaveV3Rate;
 var init_aaveV3Rate2 = __esm(() => {
   init_aaveV3Rate();
   init_operations();
   init_tools();
-  args4 = {
+  args5 = {
     request: AaveRateRequest$inboundSchema
   };
   tool$aaveV3Rate = {
@@ -42425,9 +43120,9 @@ blockchain every time this endpoint is called.
 compounding).
 
 For APY/APR on loans Aave offers both stable and fixed rates on certain tokens.`,
-    args: args4,
-    tool: async (client, args5, ctx) => {
-      const [result, apiCall] = await aaveV3Rate(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args5,
+    tool: async (client, args6, ctx) => {
+      const [result, apiCall] = await aaveV3Rate(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42442,9 +43137,9 @@ For APY/APR on loans Aave offers both stable and fixed rates on certain tokens.`
 
 // src/funcs/aaveV3Repay.ts
 function aaveV3Repay(client, request, options) {
-  return new APIPromise($do5(client, request, options));
+  return new APIPromise($do6(client, request, options));
 }
-async function $do5(client, request, options) {
+async function $do6(client, request, options) {
   const parsed = safeParse(request, (value) => AaveRepayRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42513,12 +43208,12 @@ var init_aaveV3Repay = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3Repay.ts
-var args5, tool$aaveV3Repay;
+var args6, tool$aaveV3Repay;
 var init_aaveV3Repay2 = __esm(() => {
   init_aaveV3Repay();
   init_components();
   init_tools();
-  args5 = {
+  args6 = {
     request: AaveRepayRequest$inboundSchema
   };
   tool$aaveV3Repay = {
@@ -42533,9 +43228,9 @@ measure of the safety of their loan position. A higher health factor reduces the
 risk of liquidation, ensuring a more secure borrowing experience. The endpoint
 requires specifying the chain and the details of the repayment transaction,
 including the amount and the asset to be repaid.`,
-    args: args5,
-    tool: async (client, args6, ctx) => {
-      const [result, apiCall] = await aaveV3Repay(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args6,
+    tool: async (client, args7, ctx) => {
+      const [result, apiCall] = await aaveV3Repay(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42550,9 +43245,9 @@ including the amount and the asset to be repaid.`,
 
 // src/funcs/aaveV3ReserveOverview.ts
 function aaveV3ReserveOverview(client, request, options) {
-  return new APIPromise($do6(client, request, options));
+  return new APIPromise($do7(client, request, options));
 }
-async function $do6(client, request, options) {
+async function $do7(client, request, options) {
   const parsed = safeParse(request, (value) => AaveReserveOverviewRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42626,12 +43321,12 @@ var init_aaveV3ReserveOverview = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3ReserveOverview.ts
-var args6, tool$aaveV3ReserveOverview;
+var args7, tool$aaveV3ReserveOverview;
 var init_aaveV3ReserveOverview2 = __esm(() => {
   init_aaveV3ReserveOverview();
   init_operations();
   init_tools();
-  args6 = {
+  args7 = {
     request: AaveReserveOverviewRequest$inboundSchema
   };
   tool$aaveV3ReserveOverview = {
@@ -42644,9 +43339,9 @@ Returns key metrics for Aave Reserves:
 - Utilization Ratio
 
 See below for more info:`,
-    args: args6,
-    tool: async (client, args7, ctx) => {
-      const [result, apiCall] = await aaveV3ReserveOverview(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args7,
+    tool: async (client, args8, ctx) => {
+      const [result, apiCall] = await aaveV3ReserveOverview(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42661,9 +43356,9 @@ See below for more info:`,
 
 // src/funcs/aaveV3Supply.ts
 function aaveV3Supply(client, request, options) {
-  return new APIPromise($do7(client, request, options));
+  return new APIPromise($do8(client, request, options));
 }
-async function $do7(client, request, options) {
+async function $do8(client, request, options) {
   const parsed = safeParse(request, (value) => AaveSupplyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42732,12 +43427,12 @@ var init_aaveV3Supply = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3Supply.ts
-var args7, tool$aaveV3Supply;
+var args8, tool$aaveV3Supply;
 var init_aaveV3Supply2 = __esm(() => {
   init_aaveV3Supply();
   init_components();
   init_tools();
-  args7 = {
+  args8 = {
     request: AaveSupplyRequest$inboundSchema
   };
   tool$aaveV3Supply = {
@@ -42753,9 +43448,9 @@ create leverage.
 Overall, this endpoint is a critical component for users looking to maximize their
 asset utility within the AAVEv3 ecosystem, providing both earning potential and
 borrowing flexibility.`,
-    args: args7,
-    tool: async (client, args8, ctx) => {
-      const [result, apiCall] = await aaveV3Supply(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args8,
+    tool: async (client, args9, ctx) => {
+      const [result, apiCall] = await aaveV3Supply(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42770,9 +43465,9 @@ borrowing flexibility.`,
 
 // src/funcs/aaveV3TokenPrice.ts
 function aaveV3TokenPrice(client, request, options) {
-  return new APIPromise($do8(client, request, options));
+  return new APIPromise($do9(client, request, options));
 }
-async function $do8(client, request, options) {
+async function $do9(client, request, options) {
   const parsed = safeParse(request, (value) => AaveTokenPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42846,12 +43541,12 @@ var init_aaveV3TokenPrice = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3TokenPrice.ts
-var args8, tool$aaveV3TokenPrice;
+var args9, tool$aaveV3TokenPrice;
 var init_aaveV3TokenPrice2 = __esm(() => {
   init_aaveV3TokenPrice();
   init_operations();
   init_tools();
-  args8 = {
+  args9 = {
     request: AaveTokenPriceRequest$inboundSchema
   };
   tool$aaveV3TokenPrice = {
@@ -42866,9 +43561,9 @@ to-date information. The request requires the token identifier and the blockchai
 network (chain) on which the token resides. The response provides the token price in
 a standardized format, converted from Wei to the base currency decimals defined by
 Aave.`,
-    args: args8,
-    tool: async (client, args9, ctx) => {
-      const [result, apiCall] = await aaveV3TokenPrice(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args9,
+    tool: async (client, args10, ctx) => {
+      const [result, apiCall] = await aaveV3TokenPrice(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42883,9 +43578,9 @@ Aave.`,
 
 // src/funcs/aaveV3UserPositionPerToken.ts
 function aaveV3UserPositionPerToken(client, request, options) {
-  return new APIPromise($do9(client, request, options));
+  return new APIPromise($do10(client, request, options));
 }
-async function $do9(client, request, options) {
+async function $do10(client, request, options) {
   const parsed = safeParse(request, (value) => AaveUserPositionPerTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -42960,12 +43655,12 @@ var init_aaveV3UserPositionPerToken = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3UserPositionPerToken.ts
-var args9, tool$aaveV3UserPositionPerToken;
+var args10, tool$aaveV3UserPositionPerToken;
 var init_aaveV3UserPositionPerToken2 = __esm(() => {
   init_aaveV3UserPositionPerToken();
   init_operations();
   init_tools();
-  args9 = {
+  args10 = {
     request: AaveUserPositionPerTokenRequest$inboundSchema
   };
   tool$aaveV3UserPositionPerToken = {
@@ -42981,9 +43676,9 @@ stable borrow rate, stable borrow rate for new loans, variable borrow rate, and
 liquidity rate. These metrics are calculated by aggregating data across all open
 positions held by the user for the specified token, offering a detailed view of
 their financial standing within the AAVE ecosystem.`,
-    args: args9,
-    tool: async (client, args10, ctx) => {
-      const [result, apiCall] = await aaveV3UserPositionPerToken(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args10,
+    tool: async (client, args11, ctx) => {
+      const [result, apiCall] = await aaveV3UserPositionPerToken(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -42998,9 +43693,9 @@ their financial standing within the AAVE ecosystem.`,
 
 // src/funcs/aaveV3UserPositionSummary.ts
 function aaveV3UserPositionSummary(client, request, options) {
-  return new APIPromise($do10(client, request, options));
+  return new APIPromise($do11(client, request, options));
 }
-async function $do10(client, request, options) {
+async function $do11(client, request, options) {
   const parsed = safeParse(request, (value) => AaveUserPositionSummaryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43074,12 +43769,12 @@ var init_aaveV3UserPositionSummary = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3UserPositionSummary.ts
-var args10, tool$aaveV3UserPositionSummary;
+var args11, tool$aaveV3UserPositionSummary;
 var init_aaveV3UserPositionSummary2 = __esm(() => {
   init_aaveV3UserPositionSummary();
   init_operations();
   init_tools();
-  args10 = {
+  args11 = {
     request: AaveUserPositionSummaryRequest$inboundSchema
   };
   tool$aaveV3UserPositionSummary = {
@@ -43094,9 +43789,9 @@ debt accrued, available borrowing capacity, liquidation threshold, maximum loan-
 value ratio, and the health factor of the user's account. These metrics are
 calculated by aggregating data across all open positions held by the user, offering
 a holistic view of their financial standing within the AAVE ecosystem.`,
-    args: args10,
-    tool: async (client, args11, ctx) => {
-      const [result, apiCall] = await aaveV3UserPositionSummary(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args11,
+    tool: async (client, args12, ctx) => {
+      const [result, apiCall] = await aaveV3UserPositionSummary(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43111,9 +43806,9 @@ a holistic view of their financial standing within the AAVE ecosystem.`,
 
 // src/funcs/aaveV3Withdraw.ts
 function aaveV3Withdraw(client, request, options) {
-  return new APIPromise($do11(client, request, options));
+  return new APIPromise($do12(client, request, options));
 }
-async function $do11(client, request, options) {
+async function $do12(client, request, options) {
   const parsed = safeParse(request, (value) => AaveWithdrawRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43182,12 +43877,12 @@ var init_aaveV3Withdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/aaveV3Withdraw.ts
-var args11, tool$aaveV3Withdraw;
+var args12, tool$aaveV3Withdraw;
 var init_aaveV3Withdraw2 = __esm(() => {
   init_aaveV3Withdraw();
   init_components();
   init_tools();
-  args11 = {
+  args12 = {
     request: AaveWithdrawRequest$inboundSchema
   };
   tool$aaveV3Withdraw = {
@@ -43203,9 +43898,9 @@ for users to carefully consider their outstanding debts and the potential impact
 their liquidation threshold before proceeding with a withdrawal. This endpoint is
 designed to provide a seamless and efficient way to manage your collateral within
 the Aave ecosystem.`,
-    args: args11,
-    tool: async (client, args12, ctx) => {
-      const [result, apiCall] = await aaveV3Withdraw(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args12,
+    tool: async (client, args13, ctx) => {
+      const [result, apiCall] = await aaveV3Withdraw(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43220,9 +43915,9 @@ the Aave ecosystem.`,
 
 // src/funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease.ts
 function aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease(client, request, options) {
-  return new APIPromise($do12(client, request, options));
+  return new APIPromise($do13(client, request, options));
 }
-async function $do12(client, request, options) {
+async function $do13(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamIncreaseLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43291,12 +43986,12 @@ var init_aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease = __esm(() => {
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease.ts
-var args12, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease;
+var args13, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease;
 var init_aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease();
   init_components();
   init_tools();
-  args12 = {
+  args13 = {
     request: AerodromeSlipstreamIncreaseLiquidityProvisionRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease = {
@@ -43314,9 +44009,9 @@ users with updated information about their enhanced position. This functionality
 vital for users aiming to optimize their liquidity provision strategy, enabling them
 to adapt to market conditions and maximize their returns in decentralized finance
 (DeFi) markets.`,
-    args: args12,
-    tool: async (client, args13, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args13,
+    tool: async (client, args14, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionIncrease(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43331,9 +44026,9 @@ to adapt to market conditions and maximize their returns in decentralized financ
 
 // src/funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionMint.ts
 function aerodromeSlipstreamSlipstreamLiquidityProvisionMint(client, request, options) {
-  return new APIPromise($do13(client, request, options));
+  return new APIPromise($do14(client, request, options));
 }
-async function $do13(client, request, options) {
+async function $do14(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamMintLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43402,12 +44097,12 @@ var init_aerodromeSlipstreamSlipstreamLiquidityProvisionMint = __esm(() => {
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamLiquidityProvisionMint.ts
-var args13, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionMint;
+var args14, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionMint;
 var init_aerodromeSlipstreamSlipstreamLiquidityProvisionMint2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamLiquidityProvisionMint();
   init_components();
   init_tools();
-  args13 = {
+  args14 = {
     request: AerodromeSlipstreamMintLiquidityProvisionRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamLiquidityProvisionMint = {
@@ -43423,9 +44118,9 @@ confirm the successful creation of the LP position, providing users with the
 necessary information to manage their newly minted position. This functionality is
 crucial for users looking to expand their liquidity provision activities, offering
 them the opportunity to engage in decentralized finance (DeFi) markets effectively.`,
-    args: args13,
-    tool: async (client, args14, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionMint(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args14,
+    tool: async (client, args15, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionMint(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43440,9 +44135,9 @@ them the opportunity to engage in decentralized finance (DeFi) markets effective
 
 // src/funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionPositions.ts
 function aerodromeSlipstreamSlipstreamLiquidityProvisionPositions(client, request, options) {
-  return new APIPromise($do14(client, request, options));
+  return new APIPromise($do15(client, request, options));
 }
-async function $do14(client, request, options) {
+async function $do15(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamLiquidityProvisionPositionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43516,12 +44211,12 @@ var init_aerodromeSlipstreamSlipstreamLiquidityProvisionPositions = __esm(() =>
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamLiquidityProvisionPositions.ts
-var args14, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionPositions;
+var args15, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionPositions;
 var init_aerodromeSlipstreamSlipstreamLiquidityProvisionPositions2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamLiquidityProvisionPositions();
   init_operations();
   init_tools();
-  args14 = {
+  args15 = {
     request: AerodromeSlipstreamLiquidityProvisionPositionsRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamLiquidityProvisionPositions = {
@@ -43537,9 +44232,9 @@ AerodromeLPPositionsInfo, provides a structured representation of the LP positio
 data, ensuring clarity and ease of use. This functionality is essential for users
 managing their liquidity provision activities, enabling them to make informed
 decisions based on their current positions.`,
-    args: args14,
-    tool: async (client, args15, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionPositions(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args15,
+    tool: async (client, args16, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionPositions(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43554,9 +44249,9 @@ decisions based on their current positions.`,
 
 // src/funcs/aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw.ts
 function aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw(client, request, options) {
-  return new APIPromise($do15(client, request, options));
+  return new APIPromise($do16(client, request, options));
 }
-async function $do15(client, request, options) {
+async function $do16(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamWithdrawLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43625,12 +44320,12 @@ var init_aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw.ts
-var args15, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw;
+var args16, tool$aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw;
 var init_aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw();
   init_components();
   init_tools();
-  args15 = {
+  args16 = {
     request: AerodromeSlipstreamWithdrawLiquidityProvisionRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw = {
@@ -43648,9 +44343,9 @@ wish to exit their liquidity provision activities, enabling them to reclaim thei
 assets and potentially reallocate them to other investment opportunities. The
 endpoint ensures a smooth and secure withdrawal process, facilitating users'
 strategic management of their decentralized finance (DeFi) portfolios.`,
-    args: args15,
-    tool: async (client, args16, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamLiquidityProvisionWithdraw(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43665,9 +44360,9 @@ strategic management of their decentralized finance (DeFi) portfolios.`,
 
 // src/funcs/aerodromeSlipstreamSlipstreamPoolPrice.ts
 function aerodromeSlipstreamSlipstreamPoolPrice(client, request, options) {
-  return new APIPromise($do16(client, request, options));
+  return new APIPromise($do17(client, request, options));
 }
-async function $do16(client, request, options) {
+async function $do17(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamPoolPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43743,12 +44438,12 @@ var init_aerodromeSlipstreamSlipstreamPoolPrice = __esm(() => {
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamPoolPrice.ts
-var args16, tool$aerodromeSlipstreamSlipstreamPoolPrice;
+var args17, tool$aerodromeSlipstreamSlipstreamPoolPrice;
 var init_aerodromeSlipstreamSlipstreamPoolPrice2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamPoolPrice();
   init_operations();
   init_tools();
-  args16 = {
+  args17 = {
     request: AerodromeSlipstreamPoolPriceRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamPoolPrice = {
@@ -43761,9 +44456,9 @@ you can purchase for 1 token1.
 Note that this is an instantaneous price and may change during any trade. For a more
 accurate representation of the trade ratios between the two assets, consider using
 the quote endpoint.`,
-    args: args16,
-    tool: async (client, args17, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamPoolPrice(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args17,
+    tool: async (client, args18, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamPoolPrice(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43778,9 +44473,9 @@ the quote endpoint.`,
 
 // src/funcs/aerodromeSlipstreamSlipstreamSwapBuyExactly.ts
 function aerodromeSlipstreamSlipstreamSwapBuyExactly(client, request, options) {
-  return new APIPromise($do17(client, request, options));
+  return new APIPromise($do18(client, request, options));
 }
-async function $do17(client, request, options) {
+async function $do18(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43849,12 +44544,12 @@ var init_aerodromeSlipstreamSlipstreamSwapBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamSwapBuyExactly.ts
-var args17, tool$aerodromeSlipstreamSlipstreamSwapBuyExactly;
+var args18, tool$aerodromeSlipstreamSlipstreamSwapBuyExactly;
 var init_aerodromeSlipstreamSlipstreamSwapBuyExactly2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamSwapBuyExactly();
   init_components();
   init_tools();
-  args17 = {
+  args18 = {
     request: AerodromeSlipstreamBuyExactlyRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamSwapBuyExactly = {
@@ -43871,9 +44566,9 @@ in mind and are willing to provide the corresponding input token amount. The
 transaction is executed with consideration of current market conditions, including
 liquidity and price impact, ensuring that the trade is completed efficiently and
 effectively.`,
-    args: args17,
-    tool: async (client, args18, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamSwapBuyExactly(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args18,
+    tool: async (client, args19, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamSwapBuyExactly(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43888,9 +44583,9 @@ effectively.`,
 
 // src/funcs/aerodromeSlipstreamSlipstreamSwapSellExactly.ts
 function aerodromeSlipstreamSlipstreamSwapSellExactly(client, request, options) {
-  return new APIPromise($do18(client, request, options));
+  return new APIPromise($do19(client, request, options));
 }
-async function $do18(client, request, options) {
+async function $do19(client, request, options) {
   const parsed = safeParse(request, (value) => AerodromeSlipstreamSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -43959,12 +44654,12 @@ var init_aerodromeSlipstreamSlipstreamSwapSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/aerodromeSlipstreamSlipstreamSwapSellExactly.ts
-var args18, tool$aerodromeSlipstreamSlipstreamSwapSellExactly;
+var args19, tool$aerodromeSlipstreamSlipstreamSwapSellExactly;
 var init_aerodromeSlipstreamSlipstreamSwapSellExactly2 = __esm(() => {
   init_aerodromeSlipstreamSlipstreamSwapSellExactly();
   init_components();
   init_tools();
-  args18 = {
+  args19 = {
     request: AerodromeSlipstreamSellExactlyRequest$inboundSchema
   };
   tool$aerodromeSlipstreamSlipstreamSwapSellExactly = {
@@ -43980,9 +44675,9 @@ received. The operation ensures that the trade is conducted within the constrain
 of the current market conditions, taking into account the liquidity and price
 impact. This endpoint is suitable for users who want to sell a precise quantity of a
 token and are willing to accept the resulting amount of the other token.`,
-    args: args18,
-    tool: async (client, args19, ctx) => {
-      const [result, apiCall] = await aerodromeSlipstreamSlipstreamSwapSellExactly(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args19,
+    tool: async (client, args20, ctx) => {
+      const [result, apiCall] = await aerodromeSlipstreamSlipstreamSwapSellExactly(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -43997,9 +44692,9 @@ token and are willing to accept the resulting amount of the other token.`,
 
 // src/funcs/morphoAllowance.ts
 function morphoAllowance(client, request, options) {
-  return new APIPromise($do19(client, request, options));
+  return new APIPromise($do20(client, request, options));
 }
-async function $do19(client, request, options) {
+async function $do20(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoSetVaultAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44068,12 +44763,12 @@ var init_morphoAllowance = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoAllowance.ts
-var args19, tool$morphoAllowance;
+var args20, tool$morphoAllowance;
 var init_morphoAllowance2 = __esm(() => {
   init_morphoAllowance();
   init_components();
   init_tools();
-  args19 = {
+  args20 = {
     request: MorphoSetVaultAllowanceRequest$inboundSchema
   };
   tool$morphoAllowance = {
@@ -44085,9 +44780,9 @@ Set an allowance for a Morpho vault. You must set this for at least the amount y
 Each vault has only one associated token that can be deposited.
 
 Use the 'Get Vaults' endpoint to query a list of vaults you can deposit into.`,
-    args: args19,
-    tool: async (client, args20, ctx) => {
-      const [result, apiCall] = await morphoAllowance(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args20,
+    tool: async (client, args21, ctx) => {
+      const [result, apiCall] = await morphoAllowance(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44102,9 +44797,9 @@ Use the 'Get Vaults' endpoint to query a list of vaults you can deposit into.`,
 
 // src/funcs/morphoBorrow.ts
 function morphoBorrow(client, request, options) {
-  return new APIPromise($do20(client, request, options));
+  return new APIPromise($do21(client, request, options));
 }
-async function $do20(client, request, options) {
+async function $do21(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoBorrowRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44173,12 +44868,12 @@ var init_morphoBorrow = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoBorrow.ts
-var args20, tool$morphoBorrow;
+var args21, tool$morphoBorrow;
 var init_morphoBorrow2 = __esm(() => {
   init_morphoBorrow();
   init_components();
   init_tools();
-  args20 = {
+  args21 = {
     request: MorphoBorrowRequest$inboundSchema
   };
   tool$morphoBorrow = {
@@ -44194,9 +44889,9 @@ A Morpho Market is a primitive lending pool that pairs one collateral asset with
 loan asset. Each market is isolated (meaning risks are contained within each
 individual market), immutable (cannot be changed after deployment), and will persist
 as long as the blockchain it is deployed on is live.`,
-    args: args20,
-    tool: async (client, args21, ctx) => {
-      const [result, apiCall] = await morphoBorrow(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args21,
+    tool: async (client, args22, ctx) => {
+      const [result, apiCall] = await morphoBorrow(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44211,9 +44906,9 @@ as long as the blockchain it is deployed on is live.`,
 
 // src/funcs/morphoDeposit.ts
 function morphoDeposit(client, request, options) {
-  return new APIPromise($do21(client, request, options));
+  return new APIPromise($do22(client, request, options));
 }
-async function $do21(client, request, options) {
+async function $do22(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoDepositRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44282,12 +44977,12 @@ var init_morphoDeposit = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoDeposit.ts
-var args21, tool$morphoDeposit;
+var args22, tool$morphoDeposit;
 var init_morphoDeposit2 = __esm(() => {
   init_morphoDeposit();
   init_components();
   init_tools();
-  args21 = {
+  args22 = {
     request: MorphoDepositRequest$inboundSchema
   };
   tool$morphoDeposit = {
@@ -44305,9 +45000,9 @@ paid by borrowers. Vaults feature automated risk management, actively curating r
 exposure for all deposited assets so users don't need to make these decisions
 themselves. Users maintain full control over their assets, can monitor the vault's
 state at any time, and withdraw their liquidity at their discretion.`,
-    args: args21,
-    tool: async (client, args22, ctx) => {
-      const [result, apiCall] = await morphoDeposit(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args22,
+    tool: async (client, args23, ctx) => {
+      const [result, apiCall] = await morphoDeposit(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44322,9 +45017,9 @@ state at any time, and withdraw their liquidity at their discretion.`,
 
 // src/funcs/morphoMarketPosition.ts
 function morphoMarketPosition(client, request, options) {
-  return new APIPromise($do22(client, request, options));
+  return new APIPromise($do23(client, request, options));
 }
-async function $do22(client, request, options) {
+async function $do23(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoMarketPositionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44399,12 +45094,12 @@ var init_morphoMarketPosition = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoMarketPosition.ts
-var args22, tool$morphoMarketPosition;
+var args23, tool$morphoMarketPosition;
 var init_morphoMarketPosition2 = __esm(() => {
   init_morphoMarketPosition();
   init_operations();
   init_tools();
-  args22 = {
+  args23 = {
     request: MorphoMarketPositionRequest$inboundSchema
   };
   tool$morphoMarketPosition = {
@@ -44413,9 +45108,9 @@ var init_morphoMarketPosition2 = __esm(() => {
 
 Check how many shares you've borrowed and the equivalent token amount of a given
 market.`,
-    args: args22,
-    tool: async (client, args23, ctx) => {
-      const [result, apiCall] = await morphoMarketPosition(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args23,
+    tool: async (client, args24, ctx) => {
+      const [result, apiCall] = await morphoMarketPosition(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44430,9 +45125,9 @@ market.`,
 
 // src/funcs/morphoMarkets.ts
 function morphoMarkets(client, request, options) {
-  return new APIPromise($do23(client, request, options));
+  return new APIPromise($do24(client, request, options));
 }
-async function $do23(client, request, options) {
+async function $do24(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoMarketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44507,12 +45202,12 @@ var init_morphoMarkets = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoMarkets.ts
-var args23, tool$morphoMarkets;
+var args24, tool$morphoMarkets;
 var init_morphoMarkets2 = __esm(() => {
   init_morphoMarkets();
   init_operations();
   init_tools();
-  args23 = {
+  args24 = {
     request: MorphoMarketsRequest$inboundSchema
   };
   tool$morphoMarkets = {
@@ -44523,9 +45218,9 @@ Query a list of markets you can borrow from.
 
 Each market has one unique token that can be borrowed against one unique token that
 can be used as collateral.`,
-    args: args23,
-    tool: async (client, args24, ctx) => {
-      const [result, apiCall] = await morphoMarkets(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args24,
+    tool: async (client, args25, ctx) => {
+      const [result, apiCall] = await morphoMarkets(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44540,9 +45235,9 @@ can be used as collateral.`,
 
 // src/funcs/morphoRepay.ts
 function morphoRepay(client, request, options) {
-  return new APIPromise($do24(client, request, options));
+  return new APIPromise($do25(client, request, options));
 }
-async function $do24(client, request, options) {
+async function $do25(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoRepayRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44611,12 +45306,12 @@ var init_morphoRepay = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoRepay.ts
-var args24, tool$morphoRepay;
+var args25, tool$morphoRepay;
 var init_morphoRepay2 = __esm(() => {
   init_morphoRepay();
   init_components();
   init_tools();
-  args24 = {
+  args25 = {
     request: MorphoRepayRequest$inboundSchema
   };
   tool$morphoRepay = {
@@ -44629,9 +45324,9 @@ A Morpho Market is a primitive lending pool that pairs one collateral asset with
 loan asset. Each market is isolated (meaning risks are contained within each
 individual market), immutable (cannot be changed after deployment), and will persist
 as long as the blockchain it is deployed on is live.`,
-    args: args24,
-    tool: async (client, args25, ctx) => {
-      const [result, apiCall] = await morphoRepay(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args25,
+    tool: async (client, args26, ctx) => {
+      const [result, apiCall] = await morphoRepay(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44646,9 +45341,9 @@ as long as the blockchain it is deployed on is live.`,
 
 // src/funcs/morphoSupplyCollateral.ts
 function morphoSupplyCollateral(client, request, options) {
-  return new APIPromise($do25(client, request, options));
+  return new APIPromise($do26(client, request, options));
 }
-async function $do25(client, request, options) {
+async function $do26(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoSupplyCollateralRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44717,12 +45412,12 @@ var init_morphoSupplyCollateral = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoSupplyCollateral.ts
-var args25, tool$morphoSupplyCollateral;
+var args26, tool$morphoSupplyCollateral;
 var init_morphoSupplyCollateral2 = __esm(() => {
   init_morphoSupplyCollateral();
   init_components();
   init_tools();
-  args25 = {
+  args26 = {
     request: MorphoSupplyCollateralRequest$inboundSchema
   };
   tool$morphoSupplyCollateral = {
@@ -44735,9 +45430,9 @@ A Morpho Market is a primitive lending pool that pairs one collateral asset with
 loan asset. Each market is isolated (meaning risks are contained within each
 individual market), immutable (cannot be changed after deployment), and will persist
 as long as the blockchain it is deployed on is live.`,
-    args: args25,
-    tool: async (client, args26, ctx) => {
-      const [result, apiCall] = await morphoSupplyCollateral(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args26,
+    tool: async (client, args27, ctx) => {
+      const [result, apiCall] = await morphoSupplyCollateral(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44752,9 +45447,9 @@ as long as the blockchain it is deployed on is live.`,
 
 // src/funcs/morphoVaultPosition.ts
 function morphoVaultPosition(client, request, options) {
-  return new APIPromise($do26(client, request, options));
+  return new APIPromise($do27(client, request, options));
 }
-async function $do26(client, request, options) {
+async function $do27(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoVaultPositionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44829,12 +45524,12 @@ var init_morphoVaultPosition = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoVaultPosition.ts
-var args26, tool$morphoVaultPosition;
+var args27, tool$morphoVaultPosition;
 var init_morphoVaultPosition2 = __esm(() => {
   init_morphoVaultPosition();
   init_operations();
   init_tools();
-  args26 = {
+  args27 = {
     request: MorphoVaultPositionRequest$inboundSchema
   };
   tool$morphoVaultPosition = {
@@ -44843,9 +45538,9 @@ var init_morphoVaultPosition2 = __esm(() => {
 
 Check how many shares you own and the equivalent token amount of a given
 vault.`,
-    args: args26,
-    tool: async (client, args27, ctx) => {
-      const [result, apiCall] = await morphoVaultPosition(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args27,
+    tool: async (client, args28, ctx) => {
+      const [result, apiCall] = await morphoVaultPosition(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44860,9 +45555,9 @@ vault.`,
 
 // src/funcs/morphoVaults.ts
 function morphoVaults(client, request, options) {
-  return new APIPromise($do27(client, request, options));
+  return new APIPromise($do28(client, request, options));
 }
-async function $do27(client, request, options) {
+async function $do28(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoVaultsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -44936,12 +45631,12 @@ var init_morphoVaults = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoVaults.ts
-var args27, tool$morphoVaults;
+var args28, tool$morphoVaults;
 var init_morphoVaults2 = __esm(() => {
   init_morphoVaults();
   init_operations();
   init_tools();
-  args27 = {
+  args28 = {
     request: MorphoVaultsRequest$inboundSchema
   };
   tool$morphoVaults = {
@@ -44953,9 +45648,9 @@ Query a list of vaults you can deposit into.
 Each vault has one unique token that can be deposited. In exchange for depositing
 tokens into a vault you receive shares. You earn yield on these shares by their
 exchange value increasing over time.`,
-    args: args27,
-    tool: async (client, args28, ctx) => {
-      const [result, apiCall] = await morphoVaults(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args28,
+    tool: async (client, args29, ctx) => {
+      const [result, apiCall] = await morphoVaults(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -44970,9 +45665,9 @@ exchange value increasing over time.`,
 
 // src/funcs/morphoWithdraw.ts
 function morphoWithdraw(client, request, options) {
-  return new APIPromise($do28(client, request, options));
+  return new APIPromise($do29(client, request, options));
 }
-async function $do28(client, request, options) {
+async function $do29(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoWithdrawRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45041,12 +45736,12 @@ var init_morphoWithdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoWithdraw.ts
-var args28, tool$morphoWithdraw;
+var args29, tool$morphoWithdraw;
 var init_morphoWithdraw2 = __esm(() => {
   init_morphoWithdraw();
   init_components();
   init_tools();
-  args28 = {
+  args29 = {
     request: MorphoWithdrawRequest$inboundSchema
   };
   tool$morphoWithdraw = {
@@ -45064,9 +45759,9 @@ paid by borrowers. Vaults feature automated risk management, actively curating r
 exposure for all deposited assets so users don't need to make these decisions
 themselves. Users maintain full control over their assets, can monitor the vault's
 state at any time, and withdraw their liquidity at their discretion.`,
-    args: args28,
-    tool: async (client, args29, ctx) => {
-      const [result, apiCall] = await morphoWithdraw(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args29,
+    tool: async (client, args30, ctx) => {
+      const [result, apiCall] = await morphoWithdraw(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45081,9 +45776,9 @@ state at any time, and withdraw their liquidity at their discretion.`,
 
 // src/funcs/morphoWithdrawCollateral.ts
 function morphoWithdrawCollateral(client, request, options) {
-  return new APIPromise($do29(client, request, options));
+  return new APIPromise($do30(client, request, options));
 }
-async function $do29(client, request, options) {
+async function $do30(client, request, options) {
   const parsed = safeParse(request, (value) => MorphoWithdrawCollateralRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45152,12 +45847,12 @@ var init_morphoWithdrawCollateral = __esm(() => {
 });
 
 // src/mcp-server/tools/morphoWithdrawCollateral.ts
-var args29, tool$morphoWithdrawCollateral;
+var args30, tool$morphoWithdrawCollateral;
 var init_morphoWithdrawCollateral2 = __esm(() => {
   init_morphoWithdrawCollateral();
   init_components();
   init_tools();
-  args29 = {
+  args30 = {
     request: MorphoWithdrawCollateralRequest$inboundSchema
   };
   tool$morphoWithdrawCollateral = {
@@ -45170,9 +45865,9 @@ A Morpho Market is a primitive lending pool that pairs one collateral asset with
 loan asset. Each market is isolated (meaning risks are contained within each
 individual market), immutable (cannot be changed after deployment), and will persist
 as long as the blockchain it is deployed on is live.`,
-    args: args29,
-    tool: async (client, args30, ctx) => {
-      const [result, apiCall] = await morphoWithdrawCollateral(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args30,
+    tool: async (client, args31, ctx) => {
+      const [result, apiCall] = await morphoWithdrawCollateral(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45187,9 +45882,9 @@ as long as the blockchain it is deployed on is live.`,
 
 // src/funcs/skyBuy.ts
 function skyBuy(client, request, options) {
-  return new APIPromise($do30(client, request, options));
+  return new APIPromise($do31(client, request, options));
 }
-async function $do30(client, request, options) {
+async function $do31(client, request, options) {
   const parsed = safeParse(request, (value) => SkyBuyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45258,12 +45953,12 @@ var init_skyBuy = __esm(() => {
 });
 
 // src/mcp-server/tools/skyBuy.ts
-var args30, tool$skyBuy;
+var args31, tool$skyBuy;
 var init_skyBuy2 = __esm(() => {
   init_skyBuy();
   init_components();
   init_tools();
-  args30 = {
+  args31 = {
     request: SkyBuyRequest$inboundSchema
   };
   tool$skyBuy = {
@@ -45277,9 +45972,9 @@ If buying with DAI, user will need to set an allowance on the DAI contract for t
 
 If buying with USDC, user will need to set an allowance on the USDC contract for the
 'SkyDaiUsdsConverter' contract beforehand.`,
-    args: args30,
-    tool: async (client, args31, ctx) => {
-      const [result, apiCall] = await skyBuy(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args31,
+    tool: async (client, args32, ctx) => {
+      const [result, apiCall] = await skyBuy(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45294,9 +45989,9 @@ If buying with USDC, user will need to set an allowance on the USDC contract for
 
 // src/funcs/skyDeposit.ts
 function skyDeposit(client, request, options) {
-  return new APIPromise($do31(client, request, options));
+  return new APIPromise($do32(client, request, options));
 }
-async function $do31(client, request, options) {
+async function $do32(client, request, options) {
   const parsed = safeParse(request, (value) => SkyDepositRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45365,12 +46060,12 @@ var init_skyDeposit = __esm(() => {
 });
 
 // src/mcp-server/tools/skyDeposit.ts
-var args31, tool$skyDeposit;
+var args32, tool$skyDeposit;
 var init_skyDeposit2 = __esm(() => {
   init_skyDeposit();
   init_components();
   init_tools();
-  args31 = {
+  args32 = {
     request: SkyDepositRequest$inboundSchema
   };
   tool$skyDeposit = {
@@ -45380,9 +46075,9 @@ var init_skyDeposit2 = __esm(() => {
 Deposit USDS for sUSDS to earn yield.
 
 There are no fees.`,
-    args: args31,
-    tool: async (client, args32, ctx) => {
-      const [result, apiCall] = await skyDeposit(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args32,
+    tool: async (client, args33, ctx) => {
+      const [result, apiCall] = await skyDeposit(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45397,9 +46092,9 @@ There are no fees.`,
 
 // src/funcs/skyPosition.ts
 function skyPosition(client, request, options) {
-  return new APIPromise($do32(client, request, options));
+  return new APIPromise($do33(client, request, options));
 }
-async function $do32(client, request, options) {
+async function $do33(client, request, options) {
   const parsed = safeParse(request, (value) => SkyPositionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45473,12 +46168,12 @@ var init_skyPosition = __esm(() => {
 });
 
 // src/mcp-server/tools/skyPosition.ts
-var args32, tool$skyPosition;
+var args33, tool$skyPosition;
 var init_skyPosition2 = __esm(() => {
   init_skyPosition();
   init_operations();
   init_tools();
-  args32 = {
+  args33 = {
     request: SkyPositionRequest$inboundSchema
   };
   tool$skyPosition = {
@@ -45486,9 +46181,9 @@ var init_skyPosition2 = __esm(() => {
     description: `Check USDS Position
 
 Check the USDS overall position.`,
-    args: args32,
-    tool: async (client, args33, ctx) => {
-      const [result, apiCall] = await skyPosition(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args33,
+    tool: async (client, args34, ctx) => {
+      const [result, apiCall] = await skyPosition(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45503,9 +46198,9 @@ Check the USDS overall position.`,
 
 // src/funcs/skySell.ts
 function skySell(client, request, options) {
-  return new APIPromise($do33(client, request, options));
+  return new APIPromise($do34(client, request, options));
 }
-async function $do33(client, request, options) {
+async function $do34(client, request, options) {
   const parsed = safeParse(request, (value) => SkySellRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45574,12 +46269,12 @@ var init_skySell = __esm(() => {
 });
 
 // src/mcp-server/tools/skySell.ts
-var args33, tool$skySell;
+var args34, tool$skySell;
 var init_skySell2 = __esm(() => {
   init_skySell();
   init_components();
   init_tools();
-  args33 = {
+  args34 = {
     request: SkySellRequest$inboundSchema
   };
   tool$skySell = {
@@ -45593,9 +46288,9 @@ If swapping to DAI, user will need to set an allowance on the USDS contract for
 
 If swapping to USDC, user will need to set an allowance on the USDS contract for the
 'SkyUsdcUsdsConverter' contract beforehand.`,
-    args: args33,
-    tool: async (client, args34, ctx) => {
-      const [result, apiCall] = await skySell(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args34,
+    tool: async (client, args35, ctx) => {
+      const [result, apiCall] = await skySell(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45610,9 +46305,9 @@ If swapping to USDC, user will need to set an allowance on the USDS contract for
 
 // src/funcs/skyWithdraw.ts
 function skyWithdraw(client, request, options) {
-  return new APIPromise($do34(client, request, options));
+  return new APIPromise($do35(client, request, options));
 }
-async function $do34(client, request, options) {
+async function $do35(client, request, options) {
   const parsed = safeParse(request, (value) => SkyWithdrawRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45681,12 +46376,12 @@ var init_skyWithdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/skyWithdraw.ts
-var args34, tool$skyWithdraw;
+var args35, tool$skyWithdraw;
 var init_skyWithdraw2 = __esm(() => {
   init_skyWithdraw();
   init_components();
   init_tools();
-  args34 = {
+  args35 = {
     request: SkyWithdrawRequest$inboundSchema
   };
   tool$skyWithdraw = {
@@ -45696,9 +46391,9 @@ var init_skyWithdraw2 = __esm(() => {
 Withdraw USDS for sUSDS to stop earning yield.
 
 There are no fees.`,
-    args: args34,
-    tool: async (client, args35, ctx) => {
-      const [result, apiCall] = await skyWithdraw(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args35,
+    tool: async (client, args36, ctx) => {
+      const [result, apiCall] = await skyWithdraw(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45713,9 +46408,9 @@ There are no fees.`,
 
 // src/funcs/tokenAddress.ts
 function tokenAddress(client, request, options) {
-  return new APIPromise($do35(client, request, options));
+  return new APIPromise($do36(client, request, options));
 }
-async function $do35(client, request, options) {
+async function $do36(client, request, options) {
   const parsed = safeParse(request, (value) => TokenAddressRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45789,12 +46484,12 @@ var init_tokenAddress = __esm(() => {
 });
 
 // src/mcp-server/tools/tokenAddress.ts
-var args35, tool$tokenAddress;
+var args36, tool$tokenAddress;
 var init_tokenAddress2 = __esm(() => {
   init_tokenAddress();
   init_operations();
   init_tools();
-  args35 = {
+  args36 = {
     request: TokenAddressRequest$inboundSchema
   };
   tool$tokenAddress = {
@@ -45802,9 +46497,9 @@ var init_tokenAddress2 = __esm(() => {
     description: `Token Address
 
 This endpoint retrieves the address for a token supported by us.`,
-    args: args35,
-    tool: async (client, args36, ctx) => {
-      const [result, apiCall] = await tokenAddress(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args36,
+    tool: async (client, args37, ctx) => {
+      const [result, apiCall] = await tokenAddress(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45819,9 +46514,9 @@ This endpoint retrieves the address for a token supported by us.`,
 
 // src/funcs/tokenBalance.ts
 function tokenBalance(client, request, options) {
-  return new APIPromise($do36(client, request, options));
+  return new APIPromise($do37(client, request, options));
 }
-async function $do36(client, request, options) {
+async function $do37(client, request, options) {
   const parsed = safeParse(request, (value) => TokenBalanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -45896,12 +46591,12 @@ var init_tokenBalance = __esm(() => {
 });
 
 // src/mcp-server/tools/tokenBalance.ts
-var args36, tool$tokenBalance;
+var args37, tool$tokenBalance;
 var init_tokenBalance2 = __esm(() => {
   init_tokenBalance();
   init_operations();
   init_tools();
-  args36 = {
+  args37 = {
     request: TokenBalanceRequest$inboundSchema
   };
   tool$tokenBalance = {
@@ -45909,9 +46604,9 @@ var init_tokenBalance2 = __esm(() => {
     description: `Token Balance
 
 Returns the balance of a specific ERC20 token for a given user address.`,
-    args: args36,
-    tool: async (client, args37, ctx) => {
-      const [result, apiCall] = await tokenBalance(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args37,
+    tool: async (client, args38, ctx) => {
+      const [result, apiCall] = await tokenBalance(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -45926,9 +46621,9 @@ Returns the balance of a specific ERC20 token for a given user address.`,
 
 // src/funcs/tokenPrice.ts
 function tokenPrice(client, request, options) {
-  return new APIPromise($do37(client, request, options));
+  return new APIPromise($do38(client, request, options));
 }
-async function $do37(client, request, options) {
+async function $do38(client, request, options) {
   const parsed = safeParse(request, (value) => TokenPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46002,12 +46697,12 @@ var init_tokenPrice = __esm(() => {
 });
 
 // src/mcp-server/tools/tokenPrice.ts
-var args37, tool$tokenPrice;
+var args38, tool$tokenPrice;
 var init_tokenPrice2 = __esm(() => {
   init_tokenPrice();
   init_operations();
   init_tools();
-  args37 = {
+  args38 = {
     request: TokenPriceRequest$inboundSchema
   };
   tool$tokenPrice = {
@@ -46019,9 +46714,9 @@ Retrieves the price of a token in USD using Chainlink's on-chain price feeds.
 Chainlink is a decentralized oracle that aggregates price data from off-chain
 sources. This ensures the price is tamper-resistant but the price might be stale
 with the update frequency of the oracle.`,
-    args: args37,
-    tool: async (client, args38, ctx) => {
-      const [result, apiCall] = await tokenPrice(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args38,
+    tool: async (client, args39, ctx) => {
+      const [result, apiCall] = await tokenPrice(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46036,9 +46731,9 @@ with the update frequency of the oracle.`,
 
 // src/funcs/tokenTransfer.ts
 function tokenTransfer(client, request, options) {
-  return new APIPromise($do38(client, request, options));
+  return new APIPromise($do39(client, request, options));
 }
-async function $do38(client, request, options) {
+async function $do39(client, request, options) {
   const parsed = safeParse(request, (value) => TokenTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46107,12 +46802,12 @@ var init_tokenTransfer = __esm(() => {
 });
 
 // src/mcp-server/tools/tokenTransfer.ts
-var args38, tool$tokenTransfer;
+var args39, tool$tokenTransfer;
 var init_tokenTransfer2 = __esm(() => {
   init_tokenTransfer();
   init_components();
   init_tools();
-  args38 = {
+  args39 = {
     request: TokenTransferRequest$inboundSchema
   };
   tool$tokenTransfer = {
@@ -46120,9 +46815,9 @@ var init_tokenTransfer2 = __esm(() => {
     description: `Transfer ETH or ERC20 Tokens
 
 Sends native ETH or ERC20 tokens from the sender's address to another address.`,
-    args: args38,
-    tool: async (client, args39, ctx) => {
-      const [result, apiCall] = await tokenTransfer(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args39,
+    tool: async (client, args40, ctx) => {
+      const [result, apiCall] = await tokenTransfer(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46137,9 +46832,9 @@ Sends native ETH or ERC20 tokens from the sender's address to another address.`,
 
 // src/funcs/transactionBatchingAaveLoop.ts
 function transactionBatchingAaveLoop(client, request, options) {
-  return new APIPromise($do39(client, request, options));
+  return new APIPromise($do40(client, request, options));
 }
-async function $do39(client, request, options) {
+async function $do40(client, request, options) {
   const parsed = safeParse(request, (value) => AaveLoopRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46208,12 +46903,12 @@ var init_transactionBatchingAaveLoop = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionBatchingAaveLoop.ts
-var args39, tool$transactionBatchingAaveLoop;
+var args40, tool$transactionBatchingAaveLoop;
 var init_transactionBatchingAaveLoop2 = __esm(() => {
   init_transactionBatchingAaveLoop();
   init_components();
   init_tools();
-  args39 = {
+  args40 = {
     request: AaveLoopRequest$inboundSchema
   };
   tool$transactionBatchingAaveLoop = {
@@ -46231,9 +46926,9 @@ This endpoint creates a multicall transaction that performs a series of operatio
     - Supplies the swapped tokens
 
 The transaction must be authorized using the /authorization endpoint to prevent replay attacks.`,
-    args: args39,
-    tool: async (client, args40, ctx) => {
-      const [result, apiCall] = await transactionBatchingAaveLoop(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args40,
+    tool: async (client, args41, ctx) => {
+      const [result, apiCall] = await transactionBatchingAaveLoop(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46248,9 +46943,9 @@ The transaction must be authorized using the /authorization endpoint to prevent
 
 // src/funcs/transactionBatchingAuthorization.ts
 function transactionBatchingAuthorization(client, request, options) {
-  return new APIPromise($do40(client, request, options));
+  return new APIPromise($do41(client, request, options));
 }
-async function $do40(client, request, options) {
+async function $do41(client, request, options) {
   const parsed = safeParse(request, (value) => MulticallAuthorizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46319,12 +47014,12 @@ var init_transactionBatchingAuthorization = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionBatchingAuthorization.ts
-var args40, tool$transactionBatchingAuthorization;
+var args41, tool$transactionBatchingAuthorization;
 var init_transactionBatchingAuthorization2 = __esm(() => {
   init_transactionBatchingAuthorization();
   init_components();
   init_tools();
-  args40 = {
+  args41 = {
     request: MulticallAuthorizationRequest$inboundSchema
   };
   tool$transactionBatchingAuthorization = {
@@ -46337,9 +47032,9 @@ This authorization is required to prevent replay attacks and ensure transaction
 ordering when batching multiple actions into a single transaction. The authorization
 includes a nonce and chain ID to guarantee transaction uniqueness and proper network
 targeting.`,
-    args: args40,
-    tool: async (client, args41, ctx) => {
-      const [result, apiCall] = await transactionBatchingAuthorization(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args41,
+    tool: async (client, args42, ctx) => {
+      const [result, apiCall] = await transactionBatchingAuthorization(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46354,9 +47049,9 @@ targeting.`,
 
 // src/funcs/transactionBatchingExecute.ts
 function transactionBatchingExecute(client, request, options) {
-  return new APIPromise($do41(client, request, options));
+  return new APIPromise($do42(client, request, options));
 }
-async function $do41(client, request, options) {
+async function $do42(client, request, options) {
   const parsed = safeParse(request, (value) => MulticallExecuteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46425,12 +47120,12 @@ var init_transactionBatchingExecute = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionBatchingExecute.ts
-var args41, tool$transactionBatchingExecute;
+var args42, tool$transactionBatchingExecute;
 var init_transactionBatchingExecute2 = __esm(() => {
   init_transactionBatchingExecute();
   init_components();
   init_tools();
-  args41 = {
+  args42 = {
     request: MulticallExecuteRequest$inboundSchema
   };
   tool$transactionBatchingExecute = {
@@ -46443,9 +47138,9 @@ This endpoint allows bundling multiple contract calls into a single atomic
 transaction, reducing gas costs and ensuring all operations succeed or fail
 together. The transaction must be authorized using the /authorization endpoint to
 prevent replay attacks.`,
-    args: args41,
-    tool: async (client, args42, ctx) => {
-      const [result, apiCall] = await transactionBatchingExecute(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args42,
+    tool: async (client, args43, ctx) => {
+      const [result, apiCall] = await transactionBatchingExecute(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46460,9 +47155,9 @@ prevent replay attacks.`,
 
 // src/funcs/uniswapV3LiquidityProvisionIncrease.ts
 function uniswapV3LiquidityProvisionIncrease(client, request, options) {
-  return new APIPromise($do42(client, request, options));
+  return new APIPromise($do43(client, request, options));
 }
-async function $do42(client, request, options) {
+async function $do43(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapIncreaseLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46531,12 +47226,12 @@ var init_uniswapV3LiquidityProvisionIncrease = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3LiquidityProvisionIncrease.ts
-var args42, tool$uniswapV3LiquidityProvisionIncrease;
+var args43, tool$uniswapV3LiquidityProvisionIncrease;
 var init_uniswapV3LiquidityProvisionIncrease2 = __esm(() => {
   init_uniswapV3LiquidityProvisionIncrease();
   init_components();
   init_tools();
-  args42 = {
+  args43 = {
     request: UniswapIncreaseLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionIncrease = {
@@ -46552,9 +47247,9 @@ beneficial for users who wish to enhance their potential earnings from trading f
 within the pool. The endpoint requires details such as the token pair, additional
 amount to be added, and any other parameters necessary for the liquidity increase
 process.`,
-    args: args42,
-    tool: async (client, args43, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionIncrease(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args43,
+    tool: async (client, args44, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionIncrease(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46569,9 +47264,9 @@ process.`,
 
 // src/funcs/uniswapV3LiquidityProvisionInRange.ts
 function uniswapV3LiquidityProvisionInRange(client, request, options) {
-  return new APIPromise($do43(client, request, options));
+  return new APIPromise($do44(client, request, options));
 }
-async function $do43(client, request, options) {
+async function $do44(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapLiquidityProvisionInRangeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46645,12 +47340,12 @@ var init_uniswapV3LiquidityProvisionInRange = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3LiquidityProvisionInRange.ts
-var args43, tool$uniswapV3LiquidityProvisionInRange;
+var args44, tool$uniswapV3LiquidityProvisionInRange;
 var init_uniswapV3LiquidityProvisionInRange2 = __esm(() => {
   init_uniswapV3LiquidityProvisionInRange();
   init_operations();
   init_tools();
-  args43 = {
+  args44 = {
     request: UniswapLiquidityProvisionInRangeRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionInRange = {
@@ -46665,9 +47360,9 @@ position is currently within the tick range where trading occurs. this informati
 is essential for users to monitor the status of their lp positions and ensure that
 they are actively participating in the trading activities within the liquidity pool
 and earning trading fees.`,
-    args: args43,
-    tool: async (client, args44, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionInRange(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args44,
+    tool: async (client, args45, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionInRange(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46682,9 +47377,9 @@ and earning trading fees.`,
 
 // src/funcs/uniswapV3LiquidityProvisionMint.ts
 function uniswapV3LiquidityProvisionMint(client, request, options) {
-  return new APIPromise($do44(client, request, options));
+  return new APIPromise($do45(client, request, options));
 }
-async function $do44(client, request, options) {
+async function $do45(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapMintLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46753,12 +47448,12 @@ var init_uniswapV3LiquidityProvisionMint = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3LiquidityProvisionMint.ts
-var args44, tool$uniswapV3LiquidityProvisionMint;
+var args45, tool$uniswapV3LiquidityProvisionMint;
 var init_uniswapV3LiquidityProvisionMint2 = __esm(() => {
   init_uniswapV3LiquidityProvisionMint();
   init_components();
   init_tools();
-  args44 = {
+  args45 = {
     request: UniswapMintLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionMint = {
@@ -46774,9 +47469,9 @@ This operation is essential for users looking to participate in liquidity provis
 enabling them to earn fees from trades that occur within the pool. The endpoint
 requires details such as the token pair, amount, and any additional parameters
 needed for the minting process.`,
-    args: args44,
-    tool: async (client, args45, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionMint(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args45,
+    tool: async (client, args46, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionMint(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46791,9 +47486,9 @@ needed for the minting process.`,
 
 // src/funcs/uniswapV3LiquidityProvisionPositions.ts
 function uniswapV3LiquidityProvisionPositions(client, request, options) {
-  return new APIPromise($do45(client, request, options));
+  return new APIPromise($do46(client, request, options));
 }
-async function $do45(client, request, options) {
+async function $do46(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapLiquidityProvisionPositionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46867,12 +47562,12 @@ var init_uniswapV3LiquidityProvisionPositions = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3LiquidityProvisionPositions.ts
-var args45, tool$uniswapV3LiquidityProvisionPositions;
+var args46, tool$uniswapV3LiquidityProvisionPositions;
 var init_uniswapV3LiquidityProvisionPositions2 = __esm(() => {
   init_uniswapV3LiquidityProvisionPositions();
   init_operations();
   init_tools();
-  args45 = {
+  args46 = {
     request: UniswapLiquidityProvisionPositionsRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionPositions = {
@@ -46886,9 +47581,9 @@ Users can query this endpoint to obtain detailed information about their LP
 positions, including the total number of positions and relevant metadata. This
 information is crucial for users to manage and analyze their liquidity provision
 activities effectively.`,
-    args: args45,
-    tool: async (client, args46, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionPositions(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args46,
+    tool: async (client, args47, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionPositions(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -46903,9 +47598,9 @@ activities effectively.`,
 
 // src/funcs/uniswapV3LiquidityProvisionWithdraw.ts
 function uniswapV3LiquidityProvisionWithdraw(client, request, options) {
-  return new APIPromise($do46(client, request, options));
+  return new APIPromise($do47(client, request, options));
 }
-async function $do46(client, request, options) {
+async function $do47(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapWithdrawLiquidityProvisionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -46974,12 +47669,12 @@ var init_uniswapV3LiquidityProvisionWithdraw = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3LiquidityProvisionWithdraw.ts
-var args46, tool$uniswapV3LiquidityProvisionWithdraw;
+var args47, tool$uniswapV3LiquidityProvisionWithdraw;
 var init_uniswapV3LiquidityProvisionWithdraw2 = __esm(() => {
   init_uniswapV3LiquidityProvisionWithdraw();
   init_components();
   init_tools();
-  args46 = {
+  args47 = {
     request: UniswapWithdrawLiquidityProvisionRequest$inboundSchema
   };
   tool$uniswapV3LiquidityProvisionWithdraw = {
@@ -46996,9 +47691,9 @@ pools or investments. The endpoint requires details such as the token pair, the
 amount to be withdrawn, and any additional parameters needed for the withdrawal
 process. Users should ensure they meet any protocol requirements or conditions
 before initiating a withdrawal to avoid potential issues or penalties.`,
-    args: args46,
-    tool: async (client, args47, ctx) => {
-      const [result, apiCall] = await uniswapV3LiquidityProvisionWithdraw(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args47,
+    tool: async (client, args48, ctx) => {
+      const [result, apiCall] = await uniswapV3LiquidityProvisionWithdraw(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47013,9 +47708,9 @@ before initiating a withdrawal to avoid potential issues or penalties.`,
 
 // src/funcs/uniswapV3PoolPrice.ts
 function uniswapV3PoolPrice(client, request, options) {
-  return new APIPromise($do47(client, request, options));
+  return new APIPromise($do48(client, request, options));
 }
-async function $do47(client, request, options) {
+async function $do48(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapPoolPriceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47091,12 +47786,12 @@ var init_uniswapV3PoolPrice = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3PoolPrice.ts
-var args47, tool$uniswapV3PoolPrice;
+var args48, tool$uniswapV3PoolPrice;
 var init_uniswapV3PoolPrice2 = __esm(() => {
   init_uniswapV3PoolPrice();
   init_operations();
   init_tools();
-  args47 = {
+  args48 = {
     request: UniswapPoolPriceRequest$inboundSchema
   };
   tool$uniswapV3PoolPrice = {
@@ -47106,9 +47801,9 @@ var init_uniswapV3PoolPrice2 = __esm(() => {
 This endpoint calculates the price of a token in a Uniswap pool.
 
 The price is calculated based on the current pool state and the specified fee tier.`,
-    args: args47,
-    tool: async (client, args48, ctx) => {
-      const [result, apiCall] = await uniswapV3PoolPrice(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args48,
+    tool: async (client, args49, ctx) => {
+      const [result, apiCall] = await uniswapV3PoolPrice(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47123,9 +47818,9 @@ The price is calculated based on the current pool state and the specified fee ti
 
 // src/funcs/uniswapV3QuoteBuyExactly.ts
 function uniswapV3QuoteBuyExactly(client, request, options) {
-  return new APIPromise($do48(client, request, options));
+  return new APIPromise($do49(client, request, options));
 }
-async function $do48(client, request, options) {
+async function $do49(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapQuoteBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47202,12 +47897,12 @@ var init_uniswapV3QuoteBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3QuoteBuyExactly.ts
-var args48, tool$uniswapV3QuoteBuyExactly;
+var args49, tool$uniswapV3QuoteBuyExactly;
 var init_uniswapV3QuoteBuyExactly2 = __esm(() => {
   init_uniswapV3QuoteBuyExactly();
   init_operations();
   init_tools();
-  args48 = {
+  args49 = {
     request: UniswapQuoteBuyExactlyRequest$inboundSchema
   };
   tool$uniswapV3QuoteBuyExactly = {
@@ -47219,9 +47914,9 @@ specified amount of output tokens from a Uniswap pool.
 
 It also provides the resulting price after the transaction. The calculation takes
 into account the current pool state and the specified fee tier.`,
-    args: args48,
-    tool: async (client, args49, ctx) => {
-      const [result, apiCall] = await uniswapV3QuoteBuyExactly(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args49,
+    tool: async (client, args50, ctx) => {
+      const [result, apiCall] = await uniswapV3QuoteBuyExactly(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47236,9 +47931,9 @@ into account the current pool state and the specified fee tier.`,
 
 // src/funcs/uniswapV3QuoteSellExactly.ts
 function uniswapV3QuoteSellExactly(client, request, options) {
-  return new APIPromise($do49(client, request, options));
+  return new APIPromise($do50(client, request, options));
 }
-async function $do49(client, request, options) {
+async function $do50(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapQuoteSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47315,12 +48010,12 @@ var init_uniswapV3QuoteSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3QuoteSellExactly.ts
-var args49, tool$uniswapV3QuoteSellExactly;
+var args50, tool$uniswapV3QuoteSellExactly;
 var init_uniswapV3QuoteSellExactly2 = __esm(() => {
   init_uniswapV3QuoteSellExactly();
   init_operations();
   init_tools();
-  args49 = {
+  args50 = {
     request: UniswapQuoteSellExactlyRequest$inboundSchema
   };
   tool$uniswapV3QuoteSellExactly = {
@@ -47332,9 +48027,9 @@ specified amount of output tokens from a Uniswap pool.
 
 It also provides the resulting price after the transaction. The calculation takes
 into account the current pool state and the specified fee tier.`,
-    args: args49,
-    tool: async (client, args50, ctx) => {
-      const [result, apiCall] = await uniswapV3QuoteSellExactly(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args50,
+    tool: async (client, args51, ctx) => {
+      const [result, apiCall] = await uniswapV3QuoteSellExactly(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47349,9 +48044,9 @@ into account the current pool state and the specified fee tier.`,
 
 // src/funcs/uniswapV3SwapBuyExactly.ts
 function uniswapV3SwapBuyExactly(client, request, options) {
-  return new APIPromise($do50(client, request, options));
+  return new APIPromise($do51(client, request, options));
 }
-async function $do50(client, request, options) {
+async function $do51(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapBuyExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47420,12 +48115,12 @@ var init_uniswapV3SwapBuyExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3SwapBuyExactly.ts
-var args50, tool$uniswapV3SwapBuyExactly;
+var args51, tool$uniswapV3SwapBuyExactly;
 var init_uniswapV3SwapBuyExactly2 = __esm(() => {
   init_uniswapV3SwapBuyExactly();
   init_components();
   init_tools();
-  args50 = {
+  args51 = {
     request: UniswapBuyExactlyRequest$inboundSchema
   };
   tool$uniswapV3SwapBuyExactly = {
@@ -47439,9 +48134,9 @@ The transaction is executed on the specified blockchain network, and the user mu
 provide the necessary transaction details, including the token to buy, the token to
 pay with, and the exact amount to receive. If the token being paid with is WETH and
 needs to be wrapped, the appropriate amount will be wrapped automatically.`,
-    args: args50,
-    tool: async (client, args51, ctx) => {
-      const [result, apiCall] = await uniswapV3SwapBuyExactly(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args51,
+    tool: async (client, args52, ctx) => {
+      const [result, apiCall] = await uniswapV3SwapBuyExactly(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47456,9 +48151,9 @@ needs to be wrapped, the appropriate amount will be wrapped automatically.`,
 
 // src/funcs/uniswapV3SwapSellExactly.ts
 function uniswapV3SwapSellExactly(client, request, options) {
-  return new APIPromise($do51(client, request, options));
+  return new APIPromise($do52(client, request, options));
 }
-async function $do51(client, request, options) {
+async function $do52(client, request, options) {
   const parsed = safeParse(request, (value) => UniswapSellExactlyRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47527,12 +48222,12 @@ var init_uniswapV3SwapSellExactly = __esm(() => {
 });
 
 // src/mcp-server/tools/uniswapV3SwapSellExactly.ts
-var args51, tool$uniswapV3SwapSellExactly;
+var args52, tool$uniswapV3SwapSellExactly;
 var init_uniswapV3SwapSellExactly2 = __esm(() => {
   init_uniswapV3SwapSellExactly();
   init_components();
   init_tools();
-  args51 = {
+  args52 = {
     request: UniswapSellExactlyRequest$inboundSchema
   };
   tool$uniswapV3SwapSellExactly = {
@@ -47546,9 +48241,9 @@ The transaction is executed on the specified blockchain network, and the user mu
 provide the necessary transaction details, including the token to sell, the token to
 receive, and the amount to sell. If the token being sold is WETH and needs to be
 wrapped, the appropriate amount will be wrapped automatically.`,
-    args: args51,
-    tool: async (client, args52, ctx) => {
-      const [result, apiCall] = await uniswapV3SwapSellExactly(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args52,
+    tool: async (client, args53, ctx) => {
+      const [result, apiCall] = await uniswapV3SwapSellExactly(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47563,9 +48258,9 @@ wrapped, the appropriate amount will be wrapped automatically.`,
 
 // src/funcs/universalAllowance.ts
 function universalAllowance(client, request, options) {
-  return new APIPromise($do52(client, request, options));
+  return new APIPromise($do53(client, request, options));
 }
-async function $do52(client, request, options) {
+async function $do53(client, request, options) {
   const parsed = safeParse(request, (value) => GenericAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47641,12 +48336,12 @@ var init_universalAllowance = __esm(() => {
 });
 
 // src/mcp-server/tools/universalAllowance.ts
-var args52, tool$universalAllowance;
+var args53, tool$universalAllowance;
 var init_universalAllowance2 = __esm(() => {
   init_universalAllowance();
   init_operations();
   init_tools();
-  args52 = {
+  args53 = {
     request: GenericAllowanceRequest$inboundSchema
   };
   tool$universalAllowance = {
@@ -47660,9 +48355,9 @@ tokens on their behalf.
 This is a crucial step before engaging in any transactions or operations within
 these protocols, ensuring that the protocol has the necessary permissions to manage
 the user's tokens securely and efficiently.`,
-    args: args52,
-    tool: async (client, args53, ctx) => {
-      const [result, apiCall] = await universalAllowance(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args53,
+    tool: async (client, args54, ctx) => {
+      const [result, apiCall] = await universalAllowance(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47677,9 +48372,9 @@ the user's tokens securely and efficiently.`,
 
 // src/funcs/universalAllowanceSet.ts
 function universalAllowanceSet(client, request, options) {
-  return new APIPromise($do53(client, request, options));
+  return new APIPromise($do54(client, request, options));
 }
-async function $do53(client, request, options) {
+async function $do54(client, request, options) {
   const parsed = safeParse(request, (value) => IncreaseAllowanceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47748,12 +48443,12 @@ var init_universalAllowanceSet = __esm(() => {
 });
 
 // src/mcp-server/tools/universalAllowanceSet.ts
-var args53, tool$universalAllowanceSet;
+var args54, tool$universalAllowanceSet;
 var init_universalAllowanceSet2 = __esm(() => {
   init_universalAllowanceSet();
   init_components();
   init_tools();
-  args53 = {
+  args54 = {
     request: IncreaseAllowanceRequest$inboundSchema
   };
   tool$universalAllowanceSet = {
@@ -47767,9 +48462,9 @@ authorize a protocol to spend a specified amount of tokens on behalf of the user
 This operation is crucial for ensuring that the protocol can manage the user's
 tokens securely and efficiently, enabling seamless transactions and operations
 within the DeFi ecosystem.`,
-    args: args53,
-    tool: async (client, args54, ctx) => {
-      const [result, apiCall] = await universalAllowanceSet(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args54,
+    tool: async (client, args55, ctx) => {
+      const [result, apiCall] = await universalAllowanceSet(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47784,9 +48479,9 @@ within the DeFi ecosystem.`,
 
 // src/funcs/universalEns.ts
 function universalEns(client, request, options) {
-  return new APIPromise($do54(client, request, options));
+  return new APIPromise($do55(client, request, options));
 }
-async function $do54(client, request, options) {
+async function $do55(client, request, options) {
   const parsed = safeParse(request, (value) => GenericEnsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47860,12 +48555,12 @@ var init_universalEns = __esm(() => {
 });
 
 // src/mcp-server/tools/universalEns.ts
-var args54, tool$universalEns;
+var args55, tool$universalEns;
 var init_universalEns2 = __esm(() => {
   init_universalEns();
   init_operations();
   init_tools();
-  args54 = {
+  args55 = {
     request: GenericEnsRequest$inboundSchema
   };
   tool$universalEns = {
@@ -47876,9 +48571,9 @@ An ENS name is a string ending in \`.eth\`.
 
 E.g. \`vitalik.eth\`. This endpoint can be used to
 query the actual ethereum wallet address behind the ENS name.`,
-    args: args54,
-    tool: async (client, args55, ctx) => {
-      const [result, apiCall] = await universalEns(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args55,
+    tool: async (client, args56, ctx) => {
+      const [result, apiCall] = await universalEns(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -47893,9 +48588,9 @@ query the actual ethereum wallet address behind the ENS name.`,
 
 // src/funcs/universalPortfolio.ts
 function universalPortfolio(client, request, options) {
-  return new APIPromise($do55(client, request, options));
+  return new APIPromise($do56(client, request, options));
 }
-async function $do55(client, request, options) {
+async function $do56(client, request, options) {
   const parsed = safeParse(request, (value) => GenericPortfolioRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -47969,12 +48664,12 @@ var init_universalPortfolio = __esm(() => {
 });
 
 // src/mcp-server/tools/universalPortfolio.ts
-var args55, tool$universalPortfolio;
+var args56, tool$universalPortfolio;
 var init_universalPortfolio2 = __esm(() => {
   init_universalPortfolio();
   init_operations();
   init_tools();
-  args55 = {
+  args56 = {
     request: GenericPortfolioRequest$inboundSchema
   };
   tool$universalPortfolio = {
@@ -47985,9 +48680,9 @@ Fetch the detailed portfolio of a specific wallet address on a given blockchain.
 
 This includes the total value of the portfolio in USD and a breakdown of token
 balances, including their respective values and quantities.`,
-    args: args55,
-    tool: async (client, args56, ctx) => {
-      const [result, apiCall] = await universalPortfolio(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args56,
+    tool: async (client, args57, ctx) => {
+      const [result, apiCall] = await universalPortfolio(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -48002,9 +48697,9 @@ balances, including their respective values and quantities.`,
 
 // src/funcs/universalSupportedTokens.ts
 function universalSupportedTokens(client, request, options) {
-  return new APIPromise($do56(client, request, options));
+  return new APIPromise($do57(client, request, options));
 }
-async function $do56(client, request, options) {
+async function $do57(client, request, options) {
   const parsed = safeParse(request, (value) => GenericSupportedTokensRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -48077,12 +48772,12 @@ var init_universalSupportedTokens = __esm(() => {
 });
 
 // src/mcp-server/tools/universalSupportedTokens.ts
-var args56, tool$universalSupportedTokens;
+var args57, tool$universalSupportedTokens;
 var init_universalSupportedTokens2 = __esm(() => {
   init_universalSupportedTokens();
   init_operations();
   init_tools();
-  args56 = {
+  args57 = {
     request: GenericSupportedTokensRequest$inboundSchema
   };
   tool$universalSupportedTokens = {
@@ -48090,9 +48785,9 @@ var init_universalSupportedTokens2 = __esm(() => {
     description: `List supported tokens
 
 Get the list of supported tokens on a chain by the Compass API.`,
-    args: args56,
-    tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await universalSupportedTokens(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args57,
+    tool: async (client, args58, ctx) => {
+      const [result, apiCall] = await universalSupportedTokens(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -48107,9 +48802,9 @@ Get the list of supported tokens on a chain by the Compass API.`,
 
 // src/funcs/universalUnwrapWeth.ts
 function universalUnwrapWeth(client, request, options) {
-  return new APIPromise($do57(client, request, options));
+  return new APIPromise($do58(client, request, options));
 }
-async function $do57(client, request, options) {
+async function $do58(client, request, options) {
   const parsed = safeParse(request, (value) => UnwrapWethRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -48178,12 +48873,12 @@ var init_universalUnwrapWeth = __esm(() => {
 });
 
 // src/mcp-server/tools/universalUnwrapWeth.ts
-var args57, tool$universalUnwrapWeth;
+var args58, tool$universalUnwrapWeth;
 var init_universalUnwrapWeth2 = __esm(() => {
   init_universalUnwrapWeth();
   init_components();
   init_tools();
-  args57 = {
+  args58 = {
     request: UnwrapWethRequest$inboundSchema
   };
   tool$universalUnwrapWeth = {
@@ -48192,9 +48887,9 @@ var init_universalUnwrapWeth2 = __esm(() => {
 
 Unwrapping WETH converts the ERC-20 compliant form of ETH back to native ETH that
 can be used for gas and other native purposes.`,
-    args: args57,
-    tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await universalUnwrapWeth(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args58,
+    tool: async (client, args59, ctx) => {
+      const [result, apiCall] = await universalUnwrapWeth(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -48209,9 +48904,9 @@ can be used for gas and other native purposes.`,
 
 // src/funcs/universalVisualizePortfolio.ts
 function universalVisualizePortfolio(client, request, options) {
-  return new APIPromise($do58(client, request, options));
+  return new APIPromise($do59(client, request, options));
 }
-async function $do58(client, request, options) {
+async function $do59(client, request, options) {
   const parsed = safeParse(request, (value) => GenericVisualizePortfolioRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -48285,12 +48980,12 @@ var init_universalVisualizePortfolio = __esm(() => {
 });
 
 // src/mcp-server/tools/universalVisualizePortfolio.ts
-var args58, tool$universalVisualizePortfolio;
+var args59, tool$universalVisualizePortfolio;
 var init_universalVisualizePortfolio2 = __esm(() => {
   init_universalVisualizePortfolio();
   init_operations();
   init_tools();
-  args58 = {
+  args59 = {
     request: GenericVisualizePortfolioRequest$inboundSchema
   };
   tool$universalVisualizePortfolio = {
@@ -48302,9 +48997,9 @@ Generate a visual representation of the token portfolio for a wallet address.
 The response is an SVG image of a pie chart depicting the relative distribution of
 tokens held, colored and labeled with token symbols, percentages and token values in
 USD.`,
-    args: args58,
-    tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await universalVisualizePortfolio(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await universalVisualizePortfolio(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -48319,9 +49014,9 @@ USD.`,
 
 // src/funcs/universalWrapEth.ts
 function universalWrapEth(client, request, options) {
-  return new APIPromise($do59(client, request, options));
+  return new APIPromise($do60(client, request, options));
 }
-async function $do59(client, request, options) {
+async function $do60(client, request, options) {
   const parsed = safeParse(request, (value) => WrapEthRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -48390,12 +49085,12 @@ var init_universalWrapEth = __esm(() => {
 });
 
 // src/mcp-server/tools/universalWrapEth.ts
-var args59, tool$universalWrapEth;
+var args60, tool$universalWrapEth;
 var init_universalWrapEth2 = __esm(() => {
   init_universalWrapEth();
   init_components();
   init_tools();
-  args59 = {
+  args60 = {
     request: WrapEthRequest$inboundSchema
   };
   tool$universalWrapEth = {
@@ -48404,9 +49099,9 @@ var init_universalWrapEth2 = __esm(() => {
 
 Wrapping ETH creates an ERC-20 compliant form of ETH that is typically needed for
 it to be traded on DeFi protocols.`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await universalWrapEth(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await universalWrapEth(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -48423,7 +49118,7 @@ it to be traded on DeFi protocols.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "CompassApiSDK",
-    version: "0.0.27"
+    version: "0.0.29"
   });
   const client = new CompassApiSDKCore({
     apiKeyAuth: deps.apiKeyAuth,
@@ -48437,6 +49132,7 @@ function createMCPServer(deps) {
   const resourceTemplate = createRegisterResourceTemplate(deps.logger, server, client, scopes);
   const prompt = createRegisterPrompt(deps.logger, server, client, scopes);
   const register = { tool, resource, resourceTemplate, prompt };
+  tool(tool$aaveV3AvgRate);
   tool(tool$aaveV3ReserveOverview);
   tool(tool$aaveV3Rate);
   tool(tool$aaveV3TokenPrice);
@@ -48503,6 +49199,7 @@ var init_server2 = __esm(() => {
   init_core();
   init_resources();
   init_tools();
+  init_aaveV3AvgRate2();
   init_aaveV3Borrow2();
   init_aaveV3HistoricalTransactions2();
   init_aaveV3LiquidityChange2();
@@ -49752,7 +50449,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.0.27"
+    currentVersion: "0.0.29"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -49760,5 +50457,5 @@ export {
   app
 };
 
-//# debugId=D1C83EDD5EDEBFF164756E2164756E21
+//# debugId=ED986B8E995A266764756E2164756E21
 //# sourceMappingURL=mcp-server.js.map