diff --git a/nvim-hs.cabal b/nvim-hs.cabal
--- a/nvim-hs.cabal
+++ b/nvim-hs.cabal
@@ -1,6 +1,6 @@
 cabal-version:       3.0
 name:                nvim-hs
-version:             2.3.2.4
+version:             2.3.2.6
 synopsis:            Haskell plugin backend for neovim
 description:
   This package provides a plugin provider for neovim. It allows you to write
diff --git a/src/Neovim/API/Parser.hs b/src/Neovim/API/Parser.hs
--- a/src/Neovim/API/Parser.hs
+++ b/src/Neovim/API/Parser.hs
@@ -12,6 +12,7 @@
 module Neovim.API.Parser (
     NeovimAPI (..),
     NeovimFunction (..),
+    NeovimFunctionParameters (..),
     NeovimType (..),
     parseAPI,
 ) where
@@ -26,7 +27,7 @@
 import qualified Data.ByteString.Lazy as LB
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.MessagePack (Object)
+import Data.MessagePack (Object (..))
 import Data.Serialize (decode)
 import Neovim.Compat.Megaparsec as P (
     MonadParsec (eof, try),
@@ -60,7 +61,7 @@
 data NeovimFunction = NeovimFunction
     { name :: String
     -- ^ function name
-    , parameters :: [(NeovimType, String)]
+    , parameters :: [NeovimFunctionParameters]
     -- ^ A list of type name and variable name.
     , canFail :: Bool
     -- ^ Indicator whether the function can fail/throws exceptions.
@@ -71,6 +72,13 @@
     }
     deriving (Show)
 
+data NeovimFunctionParameters = NeovimFunctionParameters
+    { parameterType :: NeovimType
+    , parameterName :: String
+    , parameterIsOptional :: Bool
+    }
+    deriving (Show)
+
 {- | This data type represents the top-level structure of the @nvim --api-info@
  output.
 -}
@@ -136,16 +144,30 @@
 extractFunctions :: Map String Object -> Either (Doc AnsiStyle) [NeovimFunction]
 extractFunctions objAPI = mapM extractFunction =<< oLookup "functions" objAPI
 
-toParameterlist :: [(String, String)] -> Either (Doc AnsiStyle) [(NeovimType, String)]
-toParameterlist ps = forM ps $ \(t, n) -> do
-    t' <- parseType t
-    return (t', n)
+parseFunctionParameters :: Map String Object -> Either (Doc AnsiStyle) [NeovimFunctionParameters]
+parseFunctionParameters m = case Map.lookup "parameters" m of
+    Just (ObjectArray params) -> mapM parseFunctionParameter params
+    Just o -> throwError $ "Unexpected object for function parameters array: " <> pretty (show o)
+    Nothing -> throwError $ "No entry for: parameters"
 
+parseFunctionParameter :: Object -> Either (Doc AnsiStyle) NeovimFunctionParameters
+parseFunctionParameter o = case o of
+    ObjectArray (typeObj : nameObj : rest) -> do
+        t <- parseType =<< fromObject typeObj
+        n <- fromObject nameObj
+        isOptional <- case rest of
+            [] -> pure False -- for backwards compatibility
+            [ObjectBool b] -> pure b
+            [notBool] -> throwError $ "Expected boolean to indicate optionality: " <> pretty (show notBool)
+            os -> throwError $ "Unexpected remainder of " <> pretty (show os)
+        pure $ NeovimFunctionParameters t n isOptional
+    notArray -> throwError $ "Unexpected object for function parameters" <> pretty (show notArray)
+
 extractFunction :: Map String Object -> Either (Doc AnsiStyle) NeovimFunction
 extractFunction funDefMap =
     NeovimFunction
         <$> oLookup "name" funDefMap
-        <*> (oLookup "parameters" funDefMap >>= toParameterlist)
+        <*> parseFunctionParameters funDefMap
         <*> oLookupDefault True "can_fail" funDefMap
         <*> oLookupDefault False "async" funDefMap
         <*> (oLookup "return_type" funDefMap >>= parseType)
diff --git a/src/Neovim/API/TH.hs b/src/Neovim/API/TH.hs
--- a/src/Neovim/API/TH.hs
+++ b/src/Neovim/API/TH.hs
@@ -199,15 +199,15 @@
     let prefixWithNumber i n = "arg" ++ show i ++ "_" ++ n
         applyPrefixWithNumber =
             zipWith
-                (\i (t, n) -> (t, prefixWithNumber i n))
+                (\i p -> p { parameterName = prefixWithNumber i (parameterName p) })
                 [0 :: Int ..]
                 . parameters
     vars <-
         mapM
-            ( \(t, n) ->
+            ( \NeovimFunctionParameters{parameterType, parameterName} ->
                 (,)
-                    <$> apiTypeToHaskellType typeMap t
-                    <*> newName n
+                    <$> apiTypeToHaskellType typeMap parameterType
+                    <*> newName parameterName
             )
             $ applyPrefixWithNumber nf
 
diff --git a/src/Neovim/Plugin.hs b/src/Neovim/Plugin.hs
--- a/src/Neovim/Plugin.hs
+++ b/src/Neovim/Plugin.hs
@@ -26,7 +26,7 @@
 ) where
 
 import Neovim.API.String
-    ( nvim_err_writeln, nvim_get_api_info, vim_call_function )
+    ( nvim_err_writeln, vim_call_function )
 import Neovim.Classes
     ( (<+>),
       Doc,
@@ -70,14 +70,14 @@
       getDescription,
       getFunction,
       wrapPlugin )
-import Neovim.RPC.FunctionCall ( respond )
+import Neovim.RPC.FunctionCall ( respond, scall' )
 
 import Control.Monad (foldM, void)
 import Data.Foldable (forM_)
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Either (rights)
-import Data.MessagePack ( Object )
+import Data.MessagePack ( Object (ObjectArray) )
 import Data.Text (Text)
 import Data.Traversable (forM)
 import System.Log.Logger ( debugM, errorM )
@@ -202,10 +202,12 @@
         Just p ->
             return p
         Nothing -> do
-            api <- nvim_get_api_info
+            -- The return type of nvim_get_api_info has changed. It is now a 2 element array, which
+            -- generates a tuple of 2 elements. To make this code backwards compatible, we use
+            -- internals here.
+            api <- scall' (F "nvim_get_api_info") []
             case api of
-                [] -> err "empty nvim_get_api_info"
-                (i : _) -> do
+                ObjectArray (i : _) -> do
                     case fromObject i :: Either (Doc AnsiStyle) Int of
                         Left _ ->
                             err $
@@ -214,6 +216,8 @@
                         Right channelId -> do
                             liftIO . atomically . putTMVar mp . Right $ fromIntegral channelId
                             return . Right $ fromIntegral channelId
+                ObjectArray [] -> err "empty nvim_get_api_info"
+                _ -> err $ "Unexpected reutnr type of nvim_get_api_info"
 
 registerFunctionality ::
     FunctionalityDescription ->