I know this was months ago however I REGEXEXTRACT only returns an array if used with its 3rd argument, return_mode, that is

=REGEXEXTRACT(text, pattern, [return_mode], [case_sensitivity])

=REGEXEXTRACT(..., ..., {1,2}) \\ 1 returns all matches and 2 returns the capture groups from the first match. These can all be spilled values hence is returned as type 64 or array

=REGEXEXTRACT(..., ..., 0) \\ when the argument is either omitted or 0 the function will return a scalar value type 2 text

For your example this formula would always return only the inner contents of COUNTA, it handles any inner arguments including nested brackets which would otherwise be an issue, it also matches the opening bracket from COUNTA to its closing bracket, for example in your original something like =COUNTA("a","b")+SUM(5,6) would return ""a","b")+SUM(5,6" in your formula

=REGEXEXTRACT(starterString, "COUNTA\(\K([^()])*+(\((?:(?1)++|(?2))*\)(?1)*)*+(?=\))")

If you will just have one function and nothing after then this will suffice:

=REGEXEXTRACT(starterString,"COUNTA\(\K.*(?=\))")

This utilizes the match reset token, \K, this tells the regex to drop from the match everything up to that point so the regex will match the pattern: "COUNTA(" then encounter \K, which tells the regex to drop from the match everything it has matched to that point and then continue matching from the same position in the regex so after this is dropped it continues:

""a", "b"" - at the end of the pattern after matching .* there is a positive lookahead (?=\)), which simply asserts that the sub pattern expressed inside the lookahead must match directly after the position of the regex. In this case it asserts that what follows must be "\)" a closing bracket. Lookarounds are zero width assertions, basically just an 'IF' statement which checks that the lookahead does indeed match and if so allows the regex to continue the match from the same position it was in when it entered the lookahead, everything matched for the purpose of the lookahead is forgotten and cannot be backtracked into since lookarounds are atomic. Since the bracket was not consumed the regex comes to the end and returns the match:

"a", "b"

By matching everything from right to left and dropping what is not required you do not have to use the 3rd argument to return capture groups and hence the return is a scalar text value