I am trying to send a button in the second message but it only sends the text and not a button, why is that

import asyncio
import json
import time
from telethon import TelegramClient, errors, Button

# Configuration Constants
GROUP_LINK = 'https://t.me/rocketproxyupdates'  # Telegram group link
BUTTON_TEXT = 'Join Our Telegram Group'         # Text displayed on the button

USER_LIST_FILE = 'targets.json'
SENT_FILE = 'sent.json'

# Function to read API IDs and hashes from a JSON file
def read_api_config(filename):
    with open(filename, 'r') as f:
        data = json.load(f)
    return data['API_ID_LIST'], data['API_HASH_LIST']

# Read API_ID_LIST and API_HASH_LIST from the JSON file
API_ID_LIST, API_HASH_LIST = read_api_config('clean_accounts.json')

# Source chat information
FORWARD_SOURCE_CHAT_ID = 'rocketproxyupdates'  # Correct group username
# Alternatively, use numerical ID if preferred:
# FORWARD_SOURCE_CHAT_ID = -1002325284937  # Example format for supergroups

WAIT_TIME_BASE = 1  # base wait time in seconds
WAIT_TIME_FACTOR = 5  # wait time factor based on errors


async def forward_to_user(client, user, source_chat_entity, message_id):
    """
    Forwards a message from the source chat to the target user using the provided client.
    """
    try:
        # Forward the message from the source chat to the user
        await client.forward_messages(
            entity=user['username'],
            messages=message_id,
            from_peer=source_chat_entity
        )
        print(f"Forwarded message to {user['username']} using API ID {client.api_id}")
        return True
    except errors.FloodWaitError as e:
        wait_time = max(WAIT_TIME_BASE, e.seconds + WAIT_TIME_FACTOR)
        print(f"Flood wait error: Waiting for {wait_time} seconds before retrying.")
        await asyncio.sleep(wait_time)
        return False
    except errors.UsernameNotOccupiedError:
        print(f"No user has '{user['username']}' as username.")
        return False
    except errors.PeerFloodError:
        print(f"Peer flood error when forwarding to '{user['username']}'.")
        return False
    except Exception as e:
        print(f"Failed to forward message to {user['username']}. Error: {e}")
        return False


async def send_button_message(client, user):
    """
    Sends a message with an inline button linking to the Telegram group to the target user using the provided client.
    """
    try:
        buttons = [
            [Button.url(BUTTON_TEXT, GROUP_LINK)]
        ]
        await client.send_message(
            entity=user['username'],
            message="🔗 **Stay Updated!** Click the button below to join our Telegram group:",
            buttons=buttons
        )
        print(f"Sent button message to {user['username']} using API ID {client.api_id}")
        return True
    except errors.FloodWaitError as e:
        wait_time = max(WAIT_TIME_BASE, e.seconds + WAIT_TIME_FACTOR)
        print(f"Flood wait error: Waiting for {wait_time} seconds before retrying.")
        await asyncio.sleep(wait_time)
        return False
    except errors.UsernameNotOccupiedError:
        print(f"No user has '{user['username']}' as username.")
        return False
    except errors.PeerFloodError:
        print(f"Peer flood error when sending button to '{user['username']}'.")
        return False
    except Exception as e:
        print(f"Failed to send button message to {user['username']}. Error: {e}")
        return False


async def get_source_chat_and_message(client):
    """
    Retrieves the source chat entity and the latest message ID using the provided client.
    """
    try:
        source_chat = await client.get_entity(FORWARD_SOURCE_CHAT_ID)
    except Exception as e:
        print(f"Error resolving source chat '{FORWARD_SOURCE_CHAT_ID}': {e}")
        return None, None

    try:
        message = await client.get_messages(source_chat, limit=1)
        if not message:
            print(f"No messages found in the source chat '{FORWARD_SOURCE_CHAT_ID}'.")
            return source_chat, None
        return source_chat, message[0].id
    except Exception as e:
        print(f"Error fetching messages from '{FORWARD_SOURCE_CHAT_ID}': {e}")
        return source_chat, None


async def main():
    # Load target users
    with open(USER_LIST_FILE, 'r') as f:
        users = json.load(f)

    # Load already sent users to prevent duplicates
    sent_users = set()
    try:
        with open(SENT_FILE, 'r') as f:
            sent_users = set(json.load(f))
    except FileNotFoundError:
        pass

    num_apis = len(API_ID_LIST)
    api_index = 0  # start with the first API ID

    for user in users:


        api_id = API_ID_LIST[api_index]
        api_hash = API_HASH_LIST[api_index]

        session_name = f'session_name_{api_id}'
        try:
            async with TelegramClient(session_name, api_id, api_hash) as client:
                # Retrieve the latest message from the source chat
                source_chat_entity, message_id = await get_source_chat_and_message(client)
                if not source_chat_entity or not message_id:
                    print(f"Skipping user '{user['username']}' due to source chat or message retrieval failure.")
                    continue

                # Forward the original message
                sent_forward = await forward_to_user(client, user, source_chat_entity, message_id)
                if sent_forward:
                    # Send the button message
                    sent_button = await send_button_message(client, user)
                    if sent_button:
                        sent_users.add(user['username'])
                        with open(SENT_FILE, 'w') as f:
                            json.dump(list(sent_users), f)

        except Exception as e:
            print(f"An error occurred with API ID {api_id}: {e}")

        wait_time = WAIT_TIME_BASE
        print(f"Waiting {wait_time} seconds before next user.")
        await asyncio.sleep(wait_time)

        api_index = (api_index + 1) % num_apis  # move to the next API ID, wrapping around if necessary)


if __name__ == '__main__':
    asyncio.run(main())