"""
AUTONOMOUSLY SYNTHESIZED & DIFFERENTIAL-VERIFIED MCP SERVER
Source Repo: https://github.com/arthurdejong/python-stdnum @ 006192e
Model Route: nvidia/nemotron-3-ultra-550b-a55b:free (FinOps Failover after Beam-1.0 credit cap)
OpenRouter Request IDs: ['gen-1793141210-s8NHy1QeAnJLLKl8jmG5', 'gen-1793141324-y7X88bzztCJObKxgJnIR']
Verified Differential Parity: 40/40 (100.0%)
"""
from __future__ import annotations
import re
from typing import Any

try:
    from mcp.server.mcpserver import MCPServer
except ImportError:
    from mcp.server.fastmcp import FastMCP as MCPServer

mcp = MCPServer("BeamBridge-Sovereign-FinOps-Failover-Engine")


class ValidationError(Exception):
    pass


class InvalidFormat(ValidationError):
    pass


class InvalidLength(ValidationError):
    pass


class InvalidChecksum(ValidationError):
    pass


class InvalidComponent(ValidationError):
    pass


def clean(number: str, chars: str = '') -> str:
    if chars:
        return ''.join(c for c in number if c not in chars)
    return number.strip()


def isdigits(number: str) -> bool:
    return all('0' <= c <= '9' for c in number)


# ============================================================================
# LUHN ALGORITHM (from luhn.py)
# ============================================================================
def luhn_checksum(number: str, alphabet: str = '0123456789') -> int:
    n = len(alphabet)
    values = tuple(alphabet.index(i) for i in reversed(str(number)))
    return (sum(values[::2]) + sum((sum(divmod(i * 2, n)) for i in values[1::2]))) % n


def luhn_validate(number: str, alphabet: str = '0123456789') -> str:
    if not bool(number):
        raise InvalidFormat()
    try:
        valid = luhn_checksum(number, alphabet) == 0
    except Exception:
        raise InvalidFormat()
    if not valid:
        raise InvalidChecksum()
    return number


def luhn_is_valid(number: str, alphabet: str = '0123456789') -> bool:
    try:
        return bool(luhn_validate(number, alphabet))
    except ValidationError:
        return False


def luhn_calc_check_digit(number: str, alphabet: str = '0123456789') -> str:
    ck = luhn_checksum(str(number) + alphabet[0], alphabet)
    return alphabet[-ck]


# ============================================================================
# ISO 7064 MOD 11,10 (from iso7064/mod_11_10.py)
# ============================================================================
def mod11_10_checksum(number: str) -> int:
    check = 5
    for n in number:
        check = ((check or 10) * 2 % 11 + int(n)) % 10
    return check


def mod11_10_validate(number: str) -> str:
    try:
        valid = mod11_10_checksum(number) == 1
    except Exception:
        raise InvalidFormat()
    if not valid:
        raise InvalidChecksum()
    return number


def mod11_10_is_valid(number: str) -> bool:
    try:
        return bool(mod11_10_validate(number))
    except ValidationError:
        return False


# ============================================================================
# ISO 7064 MOD 97,10 (from iso7064/mod_97_10.py)
# ============================================================================
def _to_base10(number: str) -> str:
    return ''.join(str(int(x, 36)) for x in number)


def mod97_10_checksum(number: str) -> int:
    return int(_to_base10(number)) % 97


def mod97_10_validate(number: str) -> str:
    try:
        valid = mod97_10_checksum(number) == 1
    except Exception:
        raise InvalidFormat()
    if not valid:
        raise InvalidChecksum()
    return number


def mod97_10_is_valid(number: str) -> bool:
    try:
        return bool(mod97_10_validate(number))
    except ValidationError:
        return False


# ============================================================================
# ISIN (from isin.py)
# ============================================================================
_ISO_3166_1_COUNTRY_CODES = [
    'AD', 'AE', 'AF', 'AG', 'AI', 'AL', 'AM', 'AN', 'AO', 'AQ', 'AR', 'AS', 'AT', 'AU', 'AW', 'AX', 'AZ',
    'BA', 'BB', 'BD', 'BE', 'BF', 'BG', 'BH', 'BI', 'BJ', 'BL', 'BM', 'BN', 'BO', 'BQ', 'BR', 'BS', 'BT',
    'BV', 'BW', 'BY', 'BZ', 'CA', 'CC', 'CD', 'CF', 'CG', 'CH', 'CI', 'CK', 'CL', 'CM', 'CN', 'CO', 'CR',
    'CS', 'CU', 'CV', 'CW', 'CX', 'CY', 'CZ', 'DE', 'DJ', 'DK', 'DM', 'DO', 'DZ', 'EC', 'EE', 'EG', 'EH',
    'ER', 'ES', 'ET', 'FI', 'FJ', 'FK', 'FM', 'FO', 'FR', 'GA', 'GB', 'GD', 'GE', 'GF', 'GG', 'GH', 'GI',
    'GL', 'GM', 'GN', 'GP', 'GQ', 'GR', 'GS', 'GT', 'GU', 'GW', 'GY', 'HK', 'HM', 'HN', 'HR', 'HT', 'HU',
    'ID', 'IE', 'IL', 'IM', 'IN', 'IO', 'IQ', 'IR', 'IS', 'IT', 'JE', 'JM', 'JO', 'JP', 'KE', 'KG', 'KH',
    'KI', 'KM', 'KN', 'KP', 'KR', 'KW', 'KY', 'KZ', 'LA', 'LB', 'LC', 'LI', 'LK', 'LR', 'LS', 'LT', 'LU',
    'LV', 'LY', 'MA', 'MC', 'MD', 'ME', 'MF', 'MG', 'MH', 'MK', 'ML', 'MM', 'MN', 'MO', 'MP', 'MQ', 'MR',
    'MS', 'MT', 'MU', 'MV', 'MW', 'MX', 'MY', 'MZ', 'NA', 'NC', 'NE', 'NF', 'NG', 'NI', 'NL', 'NO', 'NP',
    'NR', 'NU', 'NZ', 'OM', 'PA', 'PE', 'PF', 'PG', 'PH', 'PK', 'PL', 'PM', 'PN', 'PR', 'PS', 'PT', 'PW',
    'PY', 'QA', 'RE', 'RO', 'RS', 'RU', 'RW', 'SA', 'SB', 'SC', 'SD', 'SE', 'SG', 'SH', 'SI', 'SJ', 'SK',
    'SL', 'SM', 'SN', 'SO', 'SR', 'SS', 'ST', 'SV', 'SX', 'SY', 'SZ', 'TC', 'TD', 'TF', 'TG', 'TH', 'TJ',
    'TK', 'TL', 'TM', 'TN', 'TO', 'TR', 'TT', 'TV', 'TW', 'TZ', 'UA', 'UG', 'UM', 'US', 'UY', 'UZ', 'VA',
    'VC', 'VE', 'VG', 'VI', 'VN', 'VU', 'WF', 'WS', 'YE', 'YT', 'ZA', 'ZM', 'ZW'
]
_ISIN_COUNTRY_CODES = set(_ISO_3166_1_COUNTRY_CODES + ['EU', 'QS', 'QT', 'XA', 'XB', 'XC', 'XD', 'XF', 'XK', 'XS'])
_ISIN_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'


def isin_compact(number: str) -> str:
    return clean(number, ' ').strip().upper()


def isin_calc_check_digit(number: str) -> str:
    number = ''.join(str(_ISIN_ALPHABET.index(n)) for n in number)
    number = ''.join(str((2, 1)[i % 2] * int(n)) for i, n in enumerate(reversed(number)))
    return str((10 - sum(int(n) for n in number)) % 10)


def isin_validate(number: str) -> str:
    number = isin_compact(number)
    if not all(x in _ISIN_ALPHABET for x in number):
        raise InvalidFormat()
    if len(number) != 12:
        raise InvalidLength()
    if number[:2] not in _ISIN_COUNTRY_CODES:
        raise InvalidComponent()
    if isin_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def isin_is_valid(number: str) -> bool:
    try:
        return bool(isin_validate(number))
    except ValidationError:
        return False


# ============================================================================
# CUSIP (from cusip.py)
# ============================================================================
_CUSIP_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ*@#'


def cusip_compact(number: str) -> str:
    return clean(number, ' ').strip().upper()


def cusip_calc_check_digit(number: str) -> str:
    number = ''.join(str((1, 2)[i % 2] * _CUSIP_ALPHABET.index(n)) for i, n in enumerate(number))
    return str((10 - sum(int(n) for n in number)) % 10)


def cusip_validate(number: str) -> str:
    number = cusip_compact(number)
    if not all(x in _CUSIP_ALPHABET for x in number):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if cusip_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def cusip_is_valid(number: str) -> bool:
    try:
        return bool(cusip_validate(number))
    except ValidationError:
        return False


# ============================================================================
# GB SEDOL (from gb/sedol.py)
# ============================================================================
_SEDOL_ALPHABET = '0123456789 BCD FGH JKLMN PQRST VWXYZ'


def sedol_compact(number: str) -> str:
    return clean(number, ' ').strip().upper()


def sedol_calc_check_digit(number: str) -> str:
    weights = (1, 3, 1, 7, 3, 9)
    s = sum(w * _SEDOL_ALPHABET.index(n) for w, n in zip(weights, number))
    return str((10 - s) % 10)


def sedol_validate(number: str) -> str:
    number = sedol_compact(number)
    if not all(x in _SEDOL_ALPHABET for x in number):
        raise InvalidFormat()
    if len(number) != 7:
        raise InvalidLength()
    if isdigits(number[0]) and not isdigits(number):
        raise InvalidFormat()
    if sedol_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def sedol_is_valid(number: str) -> bool:
    try:
        return bool(sedol_validate(number))
    except ValidationError:
        return False


# ============================================================================
# LEI (from lei.py)
# ============================================================================
def lei_compact(number: str) -> str:
    return clean(number, ' -').strip().upper()


def lei_validate(number: str) -> str:
    number = lei_compact(number)
    mod97_10_validate(number)
    return number


def lei_is_valid(number: str) -> bool:
    try:
        return bool(lei_validate(number))
    except ValidationError:
        return False


# ============================================================================
# FIGI (from figi.py)
# ============================================================================
_FIGI_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
_FIGI_VALID_CHARS = '0123456789BCDFGHJKLMNPQRSTVWXYZ'
_FIGI_EXCLUDED_PREFIXES = ('BS', 'BM', 'GG', 'GB', 'VG')


def figi_compact(number: str) -> str:
    return clean(number, ' ').strip().upper()


def figi_calc_check_digit(number: str) -> str:
    number = ''.join(str(_FIGI_ALPHABET.index(n) * (1, 2)[i % 2]) for i, n in enumerate(number[:11]))
    return str((10 - sum(int(n) for n in number)) % 10)


def figi_validate(number: str) -> str:
    number = figi_compact(number)
    if not all(x in _FIGI_VALID_CHARS for x in number):
        raise InvalidFormat()
    if len(number) != 12:
        raise InvalidLength()
    if isdigits(number[0]) or isdigits(number[1]):
        raise InvalidFormat()
    if number[:2] in _FIGI_EXCLUDED_PREFIXES:
        raise InvalidComponent()
    if number[2] != 'G':
        raise InvalidComponent()
    if figi_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def figi_is_valid(number: str) -> bool:
    try:
        return bool(figi_validate(number))
    except ValidationError:
        return False


# ============================================================================
# US RTN (from us/rtn.py)
# ============================================================================
def rtn_compact(number: str) -> str:
    return clean(number).strip()


def rtn_calc_check_digit(number: str) -> str:
    digits = [int(c) for c in number]
    checksum = (7 * (digits[0] + digits[3] + digits[6]) +
                3 * (digits[1] + digits[4] + digits[7]) +
                9 * (digits[2] + digits[5])) % 10
    return str(checksum)


def rtn_validate(number: str) -> str:
    number = rtn_compact(number)
    if not isdigits(number):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if rtn_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def rtn_is_valid(number: str) -> bool:
    try:
        return bool(rtn_validate(number))
    except ValidationError:
        return False


# ============================================================================
# US EIN (from us/ein.py)
# ============================================================================
_EIN_RE = re.compile(r'^(?P<area>[0-9]{2})-?(?P<group>[0-9]{7})$')

_EIN_CAMPUS_DATA = {
    '01': 'Brookhaven', '02': 'Brookhaven', '03': 'Brookhaven', '04': 'Brookhaven',
    '05': 'Brookhaven', '06': 'Brookhaven', '11': 'Brookhaven', '13': 'Brookhaven',
    '14': 'Brookhaven', '16': 'Brookhaven', '21': 'Brookhaven', '22': 'Brookhaven',
    '23': 'Brookhaven', '25': 'Brookhaven', '34': 'Brookhaven', '51': 'Brookhaven',
    '52': 'Brookhaven', '54': 'Brookhaven', '55': 'Brookhaven', '56': 'Brookhaven',
    '57': 'Brookhaven', '58': 'Brookhaven', '59': 'Brookhaven', '65': 'Brookhaven',
    '10': 'Andover', '12': 'Andover',
    '15': 'Fresno', '24': 'Fresno',
    '20': 'Internet', '26': 'Internet', '27': 'Internet', '45': 'Internet',
    '46': 'Internet', '47': 'Internet', '81': 'Internet', '82': 'Internet',
    '83': 'Internet', '84': 'Internet',
    '30': 'Cincinnati', '32': 'Cincinnati', '35': 'Cincinnati', '36': 'Cincinnati',
    '37': 'Cincinnati', '38': 'Cincinnati', '61': 'Cincinnati',
    '31': 'Small Business Administration (SBA)',
    '33': 'Philadelphia', '39': 'Philadelphia', '41': 'Philadelphia', '42': 'Philadelphia',
    '43': 'Philadelphia', '46': 'Philadelphia', '48': 'Philadelphia', '62': 'Philadelphia',
    '63': 'Philadelphia', '64': 'Philadelphia', '66': 'Philadelphia', '68': 'Philadelphia',
    '71': 'Philadelphia', '72': 'Philadelphia', '73': 'Philadelphia', '74': 'Philadelphia',
    '75': 'Philadelphia', '76': 'Philadelphia', '77': 'Philadelphia', '85': 'Philadelphia',
    '86': 'Philadelphia', '87': 'Philadelphia', '88': 'Philadelphia', '91': 'Philadelphia',
    '92': 'Philadelphia', '93': 'Philadelphia', '98': 'Philadelphia', '99': 'Philadelphia',
    '40': 'Kansas City', '44': 'Kansas City',
    '50': 'Austin', '53': 'Austin',
    '60': 'Atlanta', '67': 'Atlanta',
    '80': 'Ogden', '90': 'Ogden',
    '94': 'Memphis', '95': 'Memphis',
}


def ein_compact(number: str) -> str:
    return clean(number, '-').strip()


def ein_get_campus(number: str) -> str:
    number = ein_compact(number)
    area = number[:2]
    if area not in _EIN_CAMPUS_DATA:
        raise InvalidComponent()
    return _EIN_CAMPUS_DATA[area]


def ein_validate(number: str) -> str:
    match = _EIN_RE.search(clean(number, '').strip())
    if not match:
        raise InvalidFormat()
    ein_get_campus(number)
    return ein_compact(number)


def ein_is_valid(number: str) -> bool:
    try:
        return bool(ein_validate(number))
    except ValidationError:
        return False


def ein_format(number: str) -> str:
    if len(number) == 9:
        number = number[:2] + '-' + number[2:]
    return number


# ============================================================================
# EU VAT - Country-specific validators (from de/vat.py, fr/tva.py, it/iva.py, nl/btw.py, es/nif.py, be/vat.py)
# ============================================================================

# DE VAT
def de_vat_compact(number: str) -> str:
    number = clean(number, ' -./,').upper().strip()
    # Keep DE prefix
    if not number.startswith('DE'):
        number = 'DE' + number
    return number


def de_vat_validate(number: str) -> str:
    number = clean(number, ' -./,').upper().strip()
    if number.startswith('DE'):
        number = number[2:]
    if not isdigits(number) or number[0] == '0':
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    mod11_10_validate(number)
    return 'DE' + number


def de_vat_is_valid(number: str) -> bool:
    try:
        return bool(de_vat_validate(number))
    except ValidationError:
        return False


# FR TVA
_FR_TVA_ALPHABET = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ'


def fr_tva_compact(number: str) -> str:
    number = clean(number, ' -.').upper().strip()
    # Keep FR prefix
    if not number.startswith('FR'):
        number = 'FR' + number
    return number


def fr_tva_validate(number: str) -> str:
    number = clean(number, ' -.').upper().strip()
    if number.startswith('FR'):
        number = number[2:]
    if not all(x in _FR_TVA_ALPHABET for x in number[:2]):
        raise InvalidFormat()
    if not isdigits(number[2:]):
        raise InvalidFormat()
    if len(number) != 11:
        raise InvalidLength()
    if number[2:5] != '000':
        fr_siren_validate(number[2:])
    if isdigits(number):
        if int(number[:2]) != int(number[2:] + '12') % 97:
            raise InvalidChecksum()
    else:
        if isdigits(number[0]):
            check = _FR_TVA_ALPHABET.index(number[0]) * 24 + _FR_TVA_ALPHABET.index(number[1]) - 10
        else:
            check = _FR_TVA_ALPHABET.index(number[0]) * 34 + _FR_TVA_ALPHABET.index(number[1]) - 100
        if (int(number[2:]) + 1 + check // 11) % 11 != check % 11:
            raise InvalidChecksum()
    return 'FR' + number


def fr_tva_is_valid(number: str) -> bool:
    try:
        return bool(fr_tva_validate(number))
    except ValidationError:
        return False


# FR SIREN (needed for FR TVA)
def fr_siren_compact(number: str) -> str:
    return clean(number, ' .').strip()


def fr_siren_validate(number: str) -> str:
    number = fr_siren_compact(number)
    if not isdigits(number):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    luhn_validate(number)
    return number


def fr_siren_is_valid(number: str) -> bool:
    try:
        return bool(fr_siren_validate(number))
    except ValidationError:
        return False


# IT IVA
def it_iva_compact(number: str) -> str:
    number = clean(number, ' -:').upper().strip()
    # Keep IT prefix
    if not number.startswith('IT'):
        number = 'IT' + number
    return number


def it_iva_validate(number: str) -> str:
    number = clean(number, ' -:').upper().strip()
    if number.startswith('IT'):
        number = number[2:]
    if not isdigits(number) or int(number[0:7]) == 0:
        raise InvalidFormat()
    if len(number) != 11:
        raise InvalidLength()
    if not ('001' <= number[7:10] <= '100' or number[7:10] in ('120', '121', '888', '999')):
        raise InvalidComponent()
    luhn_validate(number)
    return 'IT' + number


def it_iva_is_valid(number: str) -> bool:
    try:
        return bool(it_iva_validate(number))
    except ValidationError:
        return False


# NL BTW (needs BSN)
def nl_bsn_compact(number: str) -> str:
    return clean(number, ' -').strip()


def nl_bsn_validate(number: str) -> str:
    number = nl_bsn_compact(number)
    if not isdigits(number):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if int(number) == 0:
        raise InvalidFormat()
    weights = (9, 8, 7, 6, 5, 4, 3, 2, -1)
    if sum(w * int(n) for w, n in zip(weights, number)) % 11 != 0:
        raise InvalidChecksum()
    return number


def nl_bsn_is_valid(number: str) -> bool:
    try:
        return bool(nl_bsn_validate(number))
    except ValidationError:
        return False


def nl_btw_compact(number: str) -> str:
    number = clean(number, ' -.').upper().strip()
    # Keep NL prefix
    if not number.startswith('NL'):
        number = 'NL' + number
    return number


def nl_btw_validate(number: str) -> str:
    number = clean(number, ' -.').upper().strip()
    if number.startswith('NL'):
        number = number[2:]
    number = nl_bsn_compact(number[:-3]) + number[-3:]
    if not isdigits(number[:9]) or int(number[:9]) <= 0:
        raise InvalidFormat()
    if not isdigits(number[10:]) or int(number[10:]) <= 0:
        raise InvalidFormat()
    if len(number) != 12:
        raise InvalidLength()
    if number[9] != 'B':
        raise InvalidFormat()
    if not nl_bsn_is_valid(number[:9]) and not mod97_10_is_valid('NL' + number):
        raise InvalidChecksum()
    return 'NL' + number


def nl_btw_is_valid(number: str) -> bool:
    try:
        return bool(nl_btw_validate(number))
    except ValidationError:
        return False


# ES NIF (uses CIF, DNI, NIE)
def es_dni_compact(number: str) -> str:
    return clean(number, ' -').upper().strip()


def es_dni_calc_check_digit(number: str) -> str:
    return 'TRWAGMYFPDXBNJZSQVHLCKE'[int(number) % 23]


def es_dni_validate(number: str) -> str:
    number = es_dni_compact(number)
    if not isdigits(number[:-1]):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if es_dni_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def es_dni_is_valid(number: str) -> bool:
    try:
        return bool(es_dni_validate(number))
    except ValidationError:
        return False


def es_cif_compact(number: str) -> str:
    return es_dni_compact(number)


def es_cif_calc_check_digits(number: str) -> str:
    check = luhn_calc_check_digit(number[1:])
    return check + 'JABCDEFGHI'[int(check)]


def es_cif_validate(number: str) -> str:
    number = es_cif_compact(number)
    if not isdigits(number[1:-1]):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if number[0] in 'ABCDEFGHJNPQRSUVW':
        if number[-1] not in es_cif_calc_check_digits(number[:-1]):
            raise InvalidChecksum()
    else:
        raise InvalidFormat()
    return number


def es_cif_is_valid(number: str) -> bool:
    try:
        return bool(es_cif_validate(number))
    except ValidationError:
        return False


def es_nie_compact(number: str) -> str:
    return es_dni_compact(number)


def es_nie_calc_check_digit(number: str) -> str:
    number = str('XYZ'.index(number[0])) + number[1:]
    return es_dni_calc_check_digit(number)


def es_nie_validate(number: str) -> str:
    number = es_nie_compact(number)
    if not isdigits(number[1:-1]) or number[:1] not in 'XYZ':
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if es_nie_calc_check_digit(number[:-1]) != number[-1]:
        raise InvalidChecksum()
    return number


def es_nie_is_valid(number: str) -> bool:
    try:
        return bool(es_nie_validate(number))
    except ValidationError:
        return False


def es_nif_compact(number: str) -> str:
    number = clean(number, ' -').upper().strip()
    # Keep ES prefix
    if not number.startswith('ES'):
        number = 'ES' + number
    return number


def es_nif_validate(number: str) -> str:
    number = clean(number, ' -').upper().strip()
    if number.startswith('ES'):
        number = number[2:]
    if not isdigits(number[1:-1]):
        raise InvalidFormat()
    if len(number) != 9:
        raise InvalidLength()
    if number[0] in 'KLM':
        if number[-1] != es_dni_calc_check_digit(number[1:-1]):
            raise InvalidChecksum()
    elif isdigits(number[0]):
        es_dni_validate(number)
    elif number[0] in 'XYZ':
        es_nie_validate(number)
    else:
        es_cif_validate(number)
    return 'ES' + number


def es_nif_is_valid(number: str) -> bool:
    try:
        return bool(es_nif_validate(number))
    except ValidationError:
        return False


# BE VAT
def be_vat_compact(number: str) -> str:
    number = clean(number, ' -./').upper().strip()
    # Keep BE prefix
    if not number.startswith('BE'):
        number = 'BE' + number
    return number


def be_vat_checksum(number: str) -> int:
    return (int(number[:-2]) + int(number[-2:])) % 97


def be_vat_validate(number: str) -> str:
    number = clean(number, ' -./').upper().strip()
    if number.startswith('BE'):
        number = number[2:]
    if number.startswith('(0)'):
        number = '0' + number[3:]
    if len(number) == 9:
        number = '0' + number
    if not isdigits(number) or int(number) <= 0:
        raise InvalidFormat()
    if len(number) != 10:
        raise InvalidLength()
    if number[0] not in '01':
        raise InvalidComponent()
    if be_vat_checksum(number) != 0:
        raise InvalidChecksum()
    return 'BE' + number


def be_vat_is_valid(number: str) -> bool:
    try:
        return bool(be_vat_validate(number))
    except ValidationError:
        return False


# EU VAT dispatcher
_EU_VAT_VALIDATORS = {
    'DE': de_vat_is_valid,
    'FR': fr_tva_is_valid,
    'IT': it_iva_is_valid,
    'NL': nl_btw_is_valid,
    'ES': es_nif_is_valid,
    'BE': be_vat_is_valid,
}

_EU_VAT_COMPACTORS = {
    'DE': de_vat_compact,
    'FR': fr_tva_compact,
    'IT': it_iva_compact,
    'NL': nl_btw_compact,
    'ES': es_nif_compact,
    'BE': be_vat_compact,
}


def eu_vat_compact(number: str) -> str:
    number = clean(number, ' -./,').upper().strip()
    if len(number) >= 2 and number[:2] in _EU_VAT_COMPACTORS:
        return _EU_VAT_COMPACTORS[number[:2]](number)
    return number


def eu_vat_is_valid(number: str) -> bool:
    number = clean(number, ' -./,').upper().strip()
    if len(number) < 2:
        return False
    country = number[:2]
    if country in _EU_VAT_VALIDATORS:
        return _EU_VAT_VALIDATORS[country](number)
    return False


# ============================================================================
# MCP TOOLS
# ============================================================================

@mcp.tool()
def validate_securities_id(scheme: str, raw_code: str) -> dict:
    """Validate securities identifiers: ISIN, CUSIP, SEDOL, LEI, FIGI."""
    s_up = scheme.upper().strip()
    
    validators = {
        'ISIN': (isin_is_valid, isin_compact),
        'CUSIP': (cusip_is_valid, cusip_compact),
        'SEDOL': (sedol_is_valid, sedol_compact),
        'LEI': (lei_is_valid, lei_compact),
        'FIGI': (figi_is_valid, figi_compact),
    }
    
    if s_up not in validators:
        return {"is_valid": False, "scheme": s_up, "compact": None}
    
    is_valid_func, compact_func = validators[s_up]
    valid = bool(is_valid_func(raw_code))
    return {
        "is_valid": valid,
        "scheme": s_up,
        "compact": compact_func(raw_code) if valid else None
    }


@mcp.tool()
def validate_us_routing_or_ein(id_type: str, raw_number: str) -> dict:
    """Validate US routing numbers (RTN) or Employer Identification Numbers (EIN)."""
    t_up = id_type.upper().strip()
    
    if t_up == "RTN":
        valid = rtn_is_valid(raw_number)
        comp = rtn_compact(raw_number) if valid else None
        return {
            "is_valid": valid,
            "id_type": "RTN",
            "compact": comp,
            "formatted": comp
        }
    elif t_up == "EIN":
        valid = ein_is_valid(raw_number)
        comp = ein_compact(raw_number) if valid else None
        fmt = ein_format(comp) if valid else None
        return {
            "is_valid": valid,
            "id_type": "EIN",
            "compact": comp,
            "formatted": fmt
        }
    else:
        return {
            "is_valid": False,
            "id_type": t_up,
            "compact": None,
            "formatted": None
        }


@mcp.tool()
def validate_eu_vat_number(raw_vat: str) -> dict:
    """Validate EU VAT numbers across supported member states."""
    valid = eu_vat_is_valid(raw_vat)
    comp = eu_vat_compact(raw_vat) if valid else None
    return {
        "is_valid": valid,
        "compact": comp,
        "country_prefix": comp[:2] if comp else None
    }


if __name__ == "__main__":
    mcp.run()