From e40681b62fbf563cee29c11e79bc95443f1a8a70 Mon Sep 17 00:00:00 2001
From: Daniil Svetlov <svetlov@bpcbt.com>
Date: Wed, 1 Apr 2026 16:37:45 +0300
Subject: [PATCH 1/5] feat: add multi-account support

Support multiple Telegram accounts simultaneously via label-suffixed
env vars (TELEGRAM_SESSION_STRING_WORK, _PERSONAL, etc.). Single-account
configs remain fully backward-compatible.

- Replace global client singleton with clients dict registry
- Add @with_account decorator to all 93 tools: read-only tools fan out
  to all accounts, write tools require explicit account
- Add list_accounts tool for account discovery
- Concurrent client startup via asyncio.gather
- Update session_string_generator.py with optional label prompt
- Parameterize resolve_entity/resolve_input_entity

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .env.example                                  |  10 +-
 main.py                                       | 948 ++++++++++++------
 .../multi-account-support/.openspec.yaml      |   2 +
 .../changes/multi-account-support/design.md   |  90 ++
 .../changes/multi-account-support/proposal.md |  27 +
 .../specs/account-aware-tools/spec.md         |  52 +
 .../specs/multi-account/spec.md               |  56 ++
 .../changes/multi-account-support/tasks.md    |  54 +
 openspec/config.yaml                          |  20 +
 session_string_generator.py                   |  19 +-
 10 files changed, 966 insertions(+), 312 deletions(-)
 create mode 100644 openspec/changes/multi-account-support/.openspec.yaml
 create mode 100644 openspec/changes/multi-account-support/design.md
 create mode 100644 openspec/changes/multi-account-support/proposal.md
 create mode 100644 openspec/changes/multi-account-support/specs/account-aware-tools/spec.md
 create mode 100644 openspec/changes/multi-account-support/specs/multi-account/spec.md
 create mode 100644 openspec/changes/multi-account-support/tasks.md
 create mode 100644 openspec/config.yaml

diff --git a/.env.example b/.env.example
index 8af8654..5fdfd54 100644
--- a/.env.example
+++ b/.env.example
@@ -2,8 +2,14 @@
 TELEGRAM_API_ID=123456
 TELEGRAM_API_HASH=0123456789abcdef0123456789abcdef
 
-# Session Management (Choose ONE)
+# --- Single account (backward-compatible) ---
 # Option 1: File-based session (a .session file will be created)
 TELEGRAM_SESSION_NAME=telegram_session
-# Option 2: String-based session (if you generate one, e.g., using Telethon's string session generator)
+# Option 2: String-based session
 TELEGRAM_SESSION_STRING=1231231232erfdfdffd
+
+# --- Multiple accounts ---
+# Add _<LABEL> suffix to session variables. Labels become account identifiers.
+# Shared API_ID and API_HASH are used for all accounts.
+# TELEGRAM_SESSION_STRING_WORK=<session string for work account>
+# TELEGRAM_SESSION_STRING_PERSONAL=<session string for personal account>
diff --git a/main.py b/main.py
index bc36cae..ff8cfa6 100644
--- a/main.py
+++ b/main.py
@@ -91,19 +91,124 @@ def get_entity_filter_type(entity: Any) -> Optional[str]:
 
 TELEGRAM_API_ID = int(os.getenv("TELEGRAM_API_ID"))
 TELEGRAM_API_HASH = os.getenv("TELEGRAM_API_HASH")
-TELEGRAM_SESSION_NAME = os.getenv("TELEGRAM_SESSION_NAME")
-
-# Check if a string session exists in environment, otherwise use file-based session
-SESSION_STRING = os.getenv("TELEGRAM_SESSION_STRING")
 
 mcp = FastMCP("telegram")
 
-if SESSION_STRING:
-    # Use the string session if available
-    client = TelegramClient(StringSession(SESSION_STRING), TELEGRAM_API_ID, TELEGRAM_API_HASH)
-else:
-    # Use file-based session
-    client = TelegramClient(TELEGRAM_SESSION_NAME, TELEGRAM_API_ID, TELEGRAM_API_HASH)
+
+# ---------------------------------------------------------------------------
+# Multi-account configuration
+# ---------------------------------------------------------------------------
+
+
+def _discover_accounts() -> dict[str, TelegramClient]:
+    """Scan env vars to build account label -> TelegramClient mapping.
+
+    Detection rules:
+    - TELEGRAM_SESSION_STRING_<LABEL> / TELEGRAM_SESSION_NAME_<LABEL> -> multi-mode
+    - Unsuffixed TELEGRAM_SESSION_STRING / TELEGRAM_SESSION_NAME -> label "default"
+    - If both suffixed and unsuffixed exist -> unsuffixed becomes "default"
+    """
+    accounts: dict[str, TelegramClient] = {}
+
+    prefix_str = "TELEGRAM_SESSION_STRING_"
+    prefix_name = "TELEGRAM_SESSION_NAME_"
+
+    for key, value in os.environ.items():
+        if key.startswith(prefix_str) and value:
+            label = key[len(prefix_str) :].lower()
+            accounts[label] = TelegramClient(
+                StringSession(value), TELEGRAM_API_ID, TELEGRAM_API_HASH
+            )
+        elif key.startswith(prefix_name) and value:
+            label = key[len(prefix_name) :].lower()
+            accounts[label] = TelegramClient(value, TELEGRAM_API_ID, TELEGRAM_API_HASH)
+
+    # Backward-compatible unsuffixed variables
+    session_string = os.getenv("TELEGRAM_SESSION_STRING")
+    session_name = os.getenv("TELEGRAM_SESSION_NAME")
+
+    if session_string and "default" not in accounts:
+        accounts["default"] = TelegramClient(
+            StringSession(session_string), TELEGRAM_API_ID, TELEGRAM_API_HASH
+        )
+    elif session_name and "default" not in accounts:
+        accounts["default"] = TelegramClient(session_name, TELEGRAM_API_ID, TELEGRAM_API_HASH)
+
+    if not accounts:
+        print(
+            "Error: No Telegram session configured. "
+            "Set TELEGRAM_SESSION_STRING or TELEGRAM_SESSION_STRING_<LABEL> in .env",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    return accounts
+
+
+clients: dict[str, TelegramClient] = _discover_accounts()
+
+
+def get_client(account: str = None) -> TelegramClient:
+    """Resolve account label to TelegramClient."""
+    if account is None:
+        if len(clients) == 1:
+            return next(iter(clients.values()))
+        raise ValueError(
+            f"Account is required. Available accounts: {', '.join(clients.keys())}"
+        )
+    label = account.lower()
+    if label not in clients:
+        raise ValueError(
+            f"Unknown account '{account}'. Available accounts: {', '.join(clients.keys())}"
+        )
+    return clients[label]
+
+
+def is_multi_mode() -> bool:
+    """Return True when more than one account is configured."""
+    return len(clients) > 1
+
+
+def with_account(readonly=False):
+    """Decorator that adds multi-account support to MCP tools.
+
+    - In single-mode: always uses the sole client, no output tagging.
+    - In multi-mode with explicit account: uses that account's client.
+    - In multi-mode without account + readonly: fans out to all accounts
+      concurrently, prefixes each result with [label], concatenates.
+    - In multi-mode without account + NOT readonly: returns an error.
+
+    The wrapped function must accept ``account: str = None`` and use
+    ``get_client(account)`` internally to obtain the TelegramClient.
+    """
+
+    def decorator(fn):
+        @wraps(fn)
+        async def wrapper(*args, **kwargs):
+            account = kwargs.get("account")
+
+            # Explicit account OR single-mode -> call once
+            if account is not None or not is_multi_mode():
+                return await fn(*args, **kwargs)
+
+            # account is None AND multi-mode
+            if not readonly:
+                labels = ", ".join(clients.keys())
+                return f"Error: 'account' is required. Available accounts: {labels}"
+
+            # Read-only fan-out to all accounts concurrently
+            async def _call_for(label):
+                kw = dict(kwargs)
+                kw["account"] = label
+                return label, await fn(*args, **kw)
+
+            results = await asyncio.gather(*(_call_for(label) for label in clients))
+            return "\n\n".join(f"[{label}]\n{result}" for label, result in results)
+
+        return wrapper
+
+    return decorator
+
 
 # Setup robust logging with both file and console output
 logger = logging.getLogger("telegram_mcp")
@@ -341,13 +446,15 @@ def format_entity(entity) -> Dict[str, Any]:
     return result
 
 
-async def resolve_entity(identifier: Union[int, str]) -> Any:
+async def resolve_entity(identifier: Union[int, str], client=None) -> Any:
     """Resolve entity with automatic cache warming on miss.
 
     StringSession has no persistent entity cache. If get_entity() fails
     because the cache is cold (ValueError on PeerUser lookup for group IDs),
     warm the cache via get_dialogs() and retry.
     """
+    if client is None:
+        client = get_client()
     try:
         return await client.get_entity(identifier)
     except ValueError:
@@ -355,8 +462,10 @@ async def resolve_entity(identifier: Union[int, str]) -> Any:
         return await client.get_entity(identifier)
 
 
-async def resolve_input_entity(identifier: Union[int, str]) -> Any:
+async def resolve_input_entity(identifier: Union[int, str], client=None) -> Any:
     """Like resolve_entity() but returns an InputPeer."""
+    if client is None:
+        client = get_client()
     try:
         return await client.get_input_entity(identifier)
     except ValueError:
@@ -685,8 +794,29 @@ def _configure_allowed_roots_from_cli(argv: Optional[List[str]] = None) -> None:
     SERVER_ALLOWED_ROOTS = _dedupe_paths(resolved_roots)
 
 
+@mcp.tool(annotations=ToolAnnotations(title="List Accounts", readOnlyHint=True))
+async def list_accounts() -> str:
+    """List all configured Telegram accounts with profile info."""
+    lines = []
+    for label, cl in clients.items():
+        try:
+            me = await cl.get_me()
+            name = f"{me.first_name or ''} {me.last_name or ''}".strip() or "Unknown"
+            phone = me.phone or "N/A"
+            status = getattr(me, "status", None)
+            if status:
+                status_str = type(status).__name__.replace("UserStatus", "").lower()
+            else:
+                status_str = "unknown"
+            lines.append(f"{label}: {name} (+{phone}) — {status_str}")
+        except Exception:
+            lines.append(f"{label}: (unable to fetch profile)")
+    return "\n".join(lines)
+
+
 @mcp.tool(annotations=ToolAnnotations(title="Get Chats", openWorldHint=True, readOnlyHint=True))
-async def get_chats(page: int = 1, page_size: int = 20) -> str:
+@with_account(readonly=True)
+async def get_chats(account: str = None, page: int = 1, page_size: int = 20) -> str:
     """
     Get a paginated list of chats.
     Args:
@@ -694,7 +824,8 @@ async def get_chats(page: int = 1, page_size: int = 20) -> str:
         page_size: Number of chats per page.
     """
     try:
-        dialogs = await client.get_dialogs()
+        cl = get_client(account)
+        dialogs = await cl.get_dialogs()
         start = (page - 1) * page_size
         end = start + page_size
         if start >= len(dialogs):
@@ -712,8 +843,9 @@ async def get_chats(page: int = 1, page_size: int = 20) -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Messages", openWorldHint=True, readOnlyHint=True))
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_messages(chat_id: Union[int, str], page: int = 1, page_size: int = 20) -> str:
+async def get_messages(chat_id: Union[int, str], page: int = 1, page_size: int = 20, account: str = None) -> str:
     """
     Get paginated messages from a specific chat.
     Args:
@@ -722,9 +854,10 @@ async def get_messages(chat_id: Union[int, str], page: int = 1, page_size: int =
         page_size: Number of messages per page.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
         offset = (page - 1) * page_size
-        messages = await client.get_messages(entity, limit=page_size, add_offset=offset)
+        messages = await cl.get_messages(entity, limit=page_size, add_offset=offset)
         if not messages:
             return "No messages found for this page."
         lines = []
@@ -749,9 +882,11 @@ async def get_messages(chat_id: Union[int, str], page: int = 1, page_size: int =
 @mcp.tool(
     annotations=ToolAnnotations(title="Send Message", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def send_message(
-    chat_id: Union[int, str], message: str, parse_mode: Optional[str] = None
+    chat_id: Union[int, str], message: str, parse_mode: Optional[str] = None,
+    account: str = None,
 ) -> str:
     """
     Send a message to a specific chat.
@@ -763,8 +898,9 @@ async def send_message(
             ```pre```), or omit for plain text (no formatting).
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.send_message(entity, message, parse_mode=parse_mode)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_message(entity, message, parse_mode=parse_mode)
         return "Message sent successfully."
     except Exception as e:
         return log_and_format_error("send_message", e, chat_id=chat_id)
@@ -778,14 +914,16 @@ async def send_message(
         idempotentHint=True,
     )
 )
+@with_account(readonly=False)
 @validate_id("channel")
-async def subscribe_public_channel(channel: Union[int, str]) -> str:
+async def subscribe_public_channel(channel: Union[int, str], account: str = None) -> str:
     """
     Subscribe (join) to a public channel or supergroup by username or ID.
     """
     try:
-        entity = await resolve_entity(channel)
-        await client(functions.channels.JoinChannelRequest(channel=entity))
+        cl = get_client(account)
+        entity = await resolve_entity(channel, cl)
+        await cl(functions.channels.JoinChannelRequest(channel=entity))
         title = getattr(entity, "title", getattr(entity, "username", "Unknown channel"))
         return f"Subscribed to {title}."
     except telethon.errors.rpcerrorlist.UserAlreadyParticipantError:
@@ -800,29 +938,32 @@ async def subscribe_public_channel(channel: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="List Inline Buttons", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
 async def list_inline_buttons(
-    chat_id: Union[int, str], message_id: Optional[Union[int, str]] = None, limit: int = 20
+    chat_id: Union[int, str], message_id: Optional[Union[int, str]] = None, limit: int = 20,
+    account: str = None,
 ) -> str:
     """
     Inspect inline buttons on a recent message to discover their indices/text/URLs.
     """
     try:
+        cl = get_client(account)
         if isinstance(message_id, str):
             if message_id.isdigit():
                 message_id = int(message_id)
             else:
                 return "message_id must be an integer."
 
-        entity = await resolve_entity(chat_id)
+        entity = await resolve_entity(chat_id, cl)
         target_message = None
 
         if message_id is not None:
-            target_message = await client.get_messages(entity, ids=message_id)
+            target_message = await cl.get_messages(entity, ids=message_id)
             if isinstance(target_message, list):
                 target_message = target_message[0] if target_message else None
         else:
-            recent_messages = await client.get_messages(entity, limit=limit)
+            recent_messages = await cl.get_messages(entity, limit=limit)
             target_message = next(
                 (msg for msg in recent_messages if getattr(msg, "buttons", None)), None
             )
@@ -868,12 +1009,14 @@ async def list_inline_buttons(
         title="Press Inline Button", openWorldHint=True, destructiveHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def press_inline_button(
     chat_id: Union[int, str],
     message_id: Optional[Union[int, str]] = None,
     button_text: Optional[str] = None,
     button_index: Optional[int] = None,
+    account: str = None,
 ) -> str:
     """
     Press an inline button (callback) in a chat message.
@@ -885,6 +1028,7 @@ async def press_inline_button(
         button_index: Zero-based index among all buttons if you prefer positional access.
     """
     try:
+        cl = get_client(account)
         if button_text is None and button_index is None:
             return "Provide button_text or button_index to choose a button."
 
@@ -901,15 +1045,15 @@ async def press_inline_button(
             else:
                 return "button_index must be an integer."
 
-        entity = await resolve_entity(chat_id)
+        entity = await resolve_entity(chat_id, cl)
 
         target_message = None
         if message_id is not None:
-            target_message = await client.get_messages(entity, ids=message_id)
+            target_message = await cl.get_messages(entity, ids=message_id)
             if isinstance(target_message, list):
                 target_message = target_message[0] if target_message else None
         else:
-            recent_messages = await client.get_messages(entity, limit=20)
+            recent_messages = await cl.get_messages(entity, limit=20)
             target_message = next(
                 (msg for msg in recent_messages if getattr(msg, "buttons", None)), None
             )
@@ -956,7 +1100,7 @@ async def press_inline_button(
                 return f"Selected button opens a URL instead of sending a callback: {url}"
             return "Selected button does not provide callback data to press."
 
-        callback_result = await client(
+        callback_result = await cl(
             functions.messages.GetBotCallbackAnswerRequest(
                 peer=entity, msg_id=target_message.id, data=target_button.data
             )
@@ -985,12 +1129,14 @@ async def press_inline_button(
 @mcp.tool(
     annotations=ToolAnnotations(title="List Contacts", openWorldHint=True, readOnlyHint=True)
 )
-async def list_contacts() -> str:
+@with_account(readonly=True)
+async def list_contacts(account: str = None) -> str:
     """
     List all contacts in your Telegram account.
     """
     try:
-        result = await client(functions.contacts.GetContactsRequest(hash=0))
+        cl = get_client(account)
+        result = await cl(functions.contacts.GetContactsRequest(hash=0))
         users = result.users
         if not users:
             return "No contacts found."
@@ -1013,14 +1159,16 @@ async def list_contacts() -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Search Contacts", openWorldHint=True, readOnlyHint=True)
 )
-async def search_contacts(query: str) -> str:
+@with_account(readonly=True)
+async def search_contacts(query: str, account: str = None) -> str:
     """
     Search for contacts by name, username, or phone number using Telethon's SearchRequest.
     Args:
         query: The search term to look for in contact names, usernames, or phone numbers.
     """
     try:
-        result = await client(functions.contacts.SearchRequest(q=query, limit=50))
+        cl = get_client(account)
+        result = await cl(functions.contacts.SearchRequest(q=query, limit=50))
         users = result.users
         if not users:
             return f"No contacts found matching '{query}'."
@@ -1043,12 +1191,14 @@ async def search_contacts(query: str) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Contact Ids", openWorldHint=True, readOnlyHint=True)
 )
-async def get_contact_ids() -> str:
+@with_account(readonly=True)
+async def get_contact_ids(account: str = None) -> str:
     """
     Get all contact IDs in your Telegram account.
     """
     try:
-        result = await client(functions.contacts.GetContactIDsRequest(hash=0))
+        cl = get_client(account)
+        result = await cl(functions.contacts.GetContactIDsRequest(hash=0))
         if not result:
             return "No contact IDs found."
         return "Contact IDs: " + ", ".join(str(cid) for cid in result)
@@ -1059,6 +1209,7 @@ async def get_contact_ids() -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="List Messages", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
 async def list_messages(
     chat_id: Union[int, str],
@@ -1066,6 +1217,7 @@ async def list_messages(
     search_query: str = None,
     from_date: str = None,
     to_date: str = None,
+    account: str = None,
 ) -> str:
     """
     Retrieve messages with optional filters.
@@ -1078,7 +1230,8 @@ async def list_messages(
         to_date: Filter messages until this date (format: YYYY-MM-DD).
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         # Parse date filters if provided
         from_date_obj = None
@@ -1122,7 +1275,7 @@ async def list_messages(
             # Use server-side search alone, then enforce date bounds client-side.
             params["search"] = search_query
             messages = []
-            async for msg in client.iter_messages(entity, **params):  # newest -> oldest
+            async for msg in cl.iter_messages(entity, **params):  # newest -> oldest
                 if to_date_obj and msg.date > to_date_obj:
                     continue
                 if from_date_obj and msg.date < from_date_obj:
@@ -1138,7 +1291,7 @@ async def list_messages(
                 messages = []
                 if from_date_obj:
                     # Walk forward from start date (oldest -> newest)
-                    async for msg in client.iter_messages(
+                    async for msg in cl.iter_messages(
                         entity, offset_date=from_date_obj, reverse=True
                     ):
                         if to_date_obj and msg.date > to_date_obj:
@@ -1150,7 +1303,7 @@ async def list_messages(
                             break
                 else:
                     # Only upper bound: walk backward from end bound
-                    async for msg in client.iter_messages(
+                    async for msg in cl.iter_messages(
                         # offset_date is exclusive; +1µs makes to_date inclusive
                         entity,
                         offset_date=to_date_obj + timedelta(microseconds=1),
@@ -1159,7 +1312,7 @@ async def list_messages(
                         if len(messages) >= limit:
                             break
             else:
-                messages = await client.get_messages(entity, limit=limit, **params)
+                messages = await cl.get_messages(entity, limit=limit, **params)
 
         if not messages:
             return "No messages found matching the criteria."
@@ -1184,11 +1337,13 @@ async def list_messages(
 
 
 @mcp.tool(annotations=ToolAnnotations(title="List Topics", openWorldHint=True, readOnlyHint=True))
+@with_account(readonly=True)
 async def list_topics(
     chat_id: int,
     limit: int = 200,
     offset_topic: int = 0,
     search_query: str = None,
+    account: str = None,
 ) -> str:
     """
     Retrieve forum topics from a supergroup with the forum feature enabled.
@@ -1203,7 +1358,8 @@ async def list_topics(
         search_query: Optional query to filter topics by title.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         if not isinstance(entity, Channel) or not getattr(entity, "megagroup", False):
             return "The specified chat is not a supergroup."
@@ -1211,7 +1367,7 @@ async def list_topics(
         if not getattr(entity, "forum", False):
             return "The specified supergroup does not have forum topics enabled."
 
-        result = await client(
+        result = await cl(
             functions.channels.GetForumTopicsRequest(
                 channel=entity,
                 offset_date=0,
@@ -1271,7 +1427,9 @@ async def list_topics(
 
 
 @mcp.tool(annotations=ToolAnnotations(title="List Chats", openWorldHint=True, readOnlyHint=True))
+@with_account(readonly=True)
 async def list_chats(
+    account: str = None,
     chat_type: str = None, limit: int = 20, unread_only: bool = False, unmuted_only: bool = False
 ) -> str:
     """
@@ -1284,7 +1442,8 @@ async def list_chats(
         unmuted_only: If True, only return unmuted chats.
     """
     try:
-        dialogs = await client.get_dialogs(limit=limit)
+        cl = get_client(account)
+        dialogs = await cl.get_dialogs(limit=limit)
 
         results = []
         for dialog in dialogs:
@@ -1370,8 +1529,9 @@ async def list_chats(
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Chat", openWorldHint=True, readOnlyHint=True))
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_chat(chat_id: Union[int, str]) -> str:
+async def get_chat(chat_id: Union[int, str], account: str = None) -> str:
     """
     Get detailed information about a specific chat.
 
@@ -1379,7 +1539,8 @@ async def get_chat(chat_id: Union[int, str]) -> str:
         chat_id: The ID or username of the chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         result = []
         result.append(f"ID: {entity.id}")
@@ -1394,7 +1555,7 @@ async def get_chat(chat_id: Union[int, str]) -> str:
 
             # Fetch participants count reliably
             try:
-                participants_count = (await client.get_participants(entity, limit=0)).total
+                participants_count = (await cl.get_participants(entity, limit=0)).total
                 result.append(f"Participants: {participants_count}")
             except Exception as pe:
                 result.append(f"Participants: Error fetching ({pe})")
@@ -1416,7 +1577,7 @@ async def get_chat(chat_id: Union[int, str]) -> str:
         try:
             # Using get_dialogs might be slow if there are many dialogs
             # Alternative: Get entity again via get_dialogs if needed for unread count
-            dialog = await client.get_dialogs(limit=1, offset_id=0, offset_peer=entity)
+            dialog = await cl.get_dialogs(limit=1, offset_id=0, offset_peer=entity)
             if dialog:
                 dialog = dialog[0]
                 result.append(f"Unread Messages: {dialog.unread_count}")
@@ -1446,7 +1607,8 @@ async def get_chat(chat_id: Union[int, str]) -> str:
         title="Get Direct Chat By Contact", openWorldHint=True, readOnlyHint=True
     )
 )
-async def get_direct_chat_by_contact(contact_query: str) -> str:
+@with_account(readonly=True)
+async def get_direct_chat_by_contact(contact_query: str, account: str = None) -> str:
     """
     Find a direct chat with a specific contact by name, username, or phone.
 
@@ -1454,8 +1616,9 @@ async def get_direct_chat_by_contact(contact_query: str) -> str:
         contact_query: Name, username, or phone number to search for.
     """
     try:
+        cl = get_client(account)
         # Fetch all contacts using the correct Telethon method
-        result = await client(functions.contacts.GetContactsRequest(hash=0))
+        result = await cl(functions.contacts.GetContactsRequest(hash=0))
         contacts = result.users
         found_contacts = []
         for contact in contacts:
@@ -1476,7 +1639,7 @@ async def get_direct_chat_by_contact(contact_query: str) -> str:
             return f"No contacts found matching '{contact_query}'."
         # If we found contacts, look for direct chats with them
         results = []
-        dialogs = await client.get_dialogs()
+        dialogs = await cl.get_dialogs()
         for contact in found_contacts:
             contact_name = (
                 f"{getattr(contact, 'first_name', '')} {getattr(contact, 'last_name', '')}".strip()
@@ -1503,8 +1666,9 @@ async def get_direct_chat_by_contact(contact_query: str) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Contact Chats", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("contact_id")
-async def get_contact_chats(contact_id: Union[int, str]) -> str:
+async def get_contact_chats(contact_id: Union[int, str], account: str = None) -> str:
     """
     List all chats involving a specific contact.
 
@@ -1512,8 +1676,9 @@ async def get_contact_chats(contact_id: Union[int, str]) -> str:
         contact_id: The ID or username of the contact.
     """
     try:
+        cl = get_client(account)
         # Get contact info
-        contact = await resolve_entity(contact_id)
+        contact = await resolve_entity(contact_id, cl)
         if not isinstance(contact, User):
             return f"ID {contact_id} is not a user/contact."
 
@@ -1523,7 +1688,7 @@ async def get_contact_chats(contact_id: Union[int, str]) -> str:
 
         # Find direct chat
         direct_chat = None
-        dialogs = await client.get_dialogs()
+        dialogs = await cl.get_dialogs()
 
         results = []
 
@@ -1539,7 +1704,7 @@ async def get_contact_chats(contact_id: Union[int, str]) -> str:
         # Look for common groups/channels
         common_chats = []
         try:
-            common = await client.get_common_chats(contact)
+            common = await cl.get_common_chats(contact)
             for chat in common:
                 chat_type = get_entity_type(chat)
                 chat_info = f"Chat ID: {chat.id}, Title: {chat.title}, Type: {chat_type}"
@@ -1560,8 +1725,9 @@ async def get_contact_chats(contact_id: Union[int, str]) -> str:
         title="Get Last Interaction", openWorldHint=True, readOnlyHint=True
     )
 )
+@with_account(readonly=True)
 @validate_id("contact_id")
-async def get_last_interaction(contact_id: Union[int, str]) -> str:
+async def get_last_interaction(contact_id: Union[int, str], account: str = None) -> str:
     """
     Get the most recent message with a contact.
 
@@ -1569,8 +1735,9 @@ async def get_last_interaction(contact_id: Union[int, str]) -> str:
         contact_id: The ID or username of the contact.
     """
     try:
+        cl = get_client(account)
         # Get contact info
-        contact = await resolve_entity(contact_id)
+        contact = await resolve_entity(contact_id, cl)
         if not isinstance(contact, User):
             return f"ID {contact_id} is not a user/contact."
 
@@ -1579,7 +1746,7 @@ async def get_last_interaction(contact_id: Union[int, str]) -> str:
         )
 
         # Get the last few messages
-        messages = await client.get_messages(contact, limit=5)
+        messages = await cl.get_messages(contact, limit=5)
 
         if not messages:
             return f"No messages found with {contact_name} (ID: {contact_id})."
@@ -1599,9 +1766,11 @@ async def get_last_interaction(contact_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Message Context", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
 async def get_message_context(
-    chat_id: Union[int, str], message_id: int, context_size: int = 3
+    chat_id: Union[int, str], message_id: int, context_size: int = 3,
+    account: str = None,
 ) -> str:
     """
     Retrieve context around a specific message.
@@ -1612,16 +1781,17 @@ async def get_message_context(
         context_size: Number of messages before and after to include.
     """
     try:
-        chat = await resolve_entity(chat_id)
+        cl = get_client(account)
+        chat = await resolve_entity(chat_id, cl)
         # Get messages around the specified message
-        messages_before = await client.get_messages(chat, limit=context_size, max_id=message_id)
-        central_message = await client.get_messages(chat, ids=message_id)
+        messages_before = await cl.get_messages(chat, limit=context_size, max_id=message_id)
+        central_message = await cl.get_messages(chat, ids=message_id)
         # Fix: get_messages(ids=...) returns a single Message, not a list
         if central_message is not None and not isinstance(central_message, list):
             central_message = [central_message]
         elif central_message is None:
             central_message = []
-        messages_after = await client.get_messages(
+        messages_after = await cl.get_messages(
             chat, limit=context_size, min_id=message_id, reverse=True
         )
         if not central_message:
@@ -1638,7 +1808,7 @@ async def get_message_context(
             reply_content = ""
             if msg.reply_to and msg.reply_to.reply_to_msg_id:
                 try:
-                    replied_msg = await client.get_messages(chat, ids=msg.reply_to.reply_to_msg_id)
+                    replied_msg = await cl.get_messages(chat, ids=msg.reply_to.reply_to_msg_id)
                     if replied_msg:
                         replied_sender = "Unknown"
                         if replied_msg.sender:
@@ -1670,7 +1840,9 @@ async def get_message_context(
         title="Add Contact", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 async def add_contact(
+    account: str = None,
     phone: Optional[str] = None,
     first_name: str = "",
     last_name: str = "",
@@ -1688,6 +1860,7 @@ async def add_contact(
     and add the contact using contacts.addContact API (which supports adding contacts without phone numbers).
     """
     try:
+        cl = get_client(account)
         # Normalize None to empty string for easier checking
         phone = phone or ""
         username = username or ""
@@ -1705,7 +1878,7 @@ async def add_contact(
 
             # Resolve username to get user information
             try:
-                resolve_result = await client(
+                resolve_result = await cl(
                     functions.contacts.ResolveUsernameRequest(username=username_clean)
                 )
 
@@ -1723,7 +1896,7 @@ async def add_contact(
                 # Use contacts.addContact to add the contact by user ID
                 from telethon.tl.types import InputUser
 
-                result = await client(
+                result = await cl(
                     functions.contacts.AddContactRequest(
                         id=InputUser(user_id=user_id, access_hash=access_hash),
                         first_name=first_name,
@@ -1749,7 +1922,7 @@ async def add_contact(
             # Original phone-based contact addition
             from telethon.tl.types import InputPhoneContact
 
-            result = await client(
+            result = await cl(
                 functions.contacts.ImportContactsRequest(
                     contacts=[
                         InputPhoneContact(
@@ -1771,7 +1944,7 @@ async def add_contact(
         # Try alternative approach using raw API (only for phone-based)
         if phone and not username:
             try:
-                result = await client(
+                result = await cl(
                     functions.contacts.ImportContactsRequest(
                         contacts=[
                             {
@@ -1803,16 +1976,18 @@ async def add_contact(
         title="Delete Contact", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("user_id")
-async def delete_contact(user_id: Union[int, str]) -> str:
+async def delete_contact(user_id: Union[int, str], account: str = None) -> str:
     """
     Delete a contact by user ID.
     Args:
         user_id: The Telegram user ID or username of the contact to delete.
     """
     try:
-        user = await resolve_entity(user_id)
-        await client(functions.contacts.DeleteContactsRequest(id=[user]))
+        cl = get_client(account)
+        user = await resolve_entity(user_id, cl)
+        await cl(functions.contacts.DeleteContactsRequest(id=[user]))
         return f"Contact with user ID {user_id} deleted."
     except Exception as e:
         return log_and_format_error("delete_contact", e, user_id=user_id)
@@ -1823,16 +1998,18 @@ async def delete_contact(user_id: Union[int, str]) -> str:
         title="Block User", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("user_id")
-async def block_user(user_id: Union[int, str]) -> str:
+async def block_user(user_id: Union[int, str], account: str = None) -> str:
     """
     Block a user by user ID.
     Args:
         user_id: The Telegram user ID or username to block.
     """
     try:
-        user = await resolve_entity(user_id)
-        await client(functions.contacts.BlockRequest(id=user))
+        cl = get_client(account)
+        user = await resolve_entity(user_id, cl)
+        await cl(functions.contacts.BlockRequest(id=user))
         return f"User {user_id} blocked."
     except Exception as e:
         return log_and_format_error("block_user", e, user_id=user_id)
@@ -1843,28 +2020,32 @@ async def block_user(user_id: Union[int, str]) -> str:
         title="Unblock User", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("user_id")
-async def unblock_user(user_id: Union[int, str]) -> str:
+async def unblock_user(user_id: Union[int, str], account: str = None) -> str:
     """
     Unblock a user by user ID.
     Args:
         user_id: The Telegram user ID or username to unblock.
     """
     try:
-        user = await resolve_entity(user_id)
-        await client(functions.contacts.UnblockRequest(id=user))
+        cl = get_client(account)
+        user = await resolve_entity(user_id, cl)
+        await cl(functions.contacts.UnblockRequest(id=user))
         return f"User {user_id} unblocked."
     except Exception as e:
         return log_and_format_error("unblock_user", e, user_id=user_id)
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Me", openWorldHint=True, readOnlyHint=True))
-async def get_me() -> str:
+@with_account(readonly=True)
+async def get_me(account: str = None) -> str:
     """
     Get your own user information.
     """
     try:
-        me = await client.get_me()
+        cl = get_client(account)
+        me = await cl.get_me()
         return json.dumps(format_entity(me), indent=2)
     except Exception as e:
         return log_and_format_error("get_me", e)
@@ -1873,8 +2054,9 @@ async def get_me() -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Create Group", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("user_ids")
-async def create_group(title: str, user_ids: List[Union[int, str]]) -> str:
+async def create_group(title: str, user_ids: List[Union[int, str]], account: str = None) -> str:
     """
     Create a new group or supergroup and add users.
 
@@ -1883,11 +2065,12 @@ async def create_group(title: str, user_ids: List[Union[int, str]]) -> str:
         user_ids: List of user IDs or usernames to add to the group
     """
     try:
+        cl = get_client(account)
         # Convert user IDs to entities
         users = []
         for user_id in user_ids:
             try:
-                user = await resolve_entity(user_id)
+                user = await resolve_entity(user_id, cl)
                 users.append(user)
             except Exception as e:
                 logger.error(f"Failed to get entity for user ID {user_id}: {e}")
@@ -1899,7 +2082,7 @@ async def create_group(title: str, user_ids: List[Union[int, str]]) -> str:
         # Create the group with the users
         try:
             # Create a new chat with selected users
-            result = await client(functions.messages.CreateChatRequest(users=users, title=title))
+            result = await cl(functions.messages.CreateChatRequest(users=users, title=title))
 
             # Check what type of response we got
             if hasattr(result, "chats") and result.chats:
@@ -1913,7 +2096,7 @@ async def create_group(title: str, user_ids: List[Union[int, str]]) -> str:
                 # If we can't determine the chat ID directly from the result
                 # Try to find it in recent dialogs
                 await asyncio.sleep(1)  # Give Telegram a moment to register the new group
-                dialogs = await client.get_dialogs(limit=5)  # Get recent dialogs
+                dialogs = await cl.get_dialogs(limit=5)  # Get recent dialogs
                 for dialog in dialogs:
                     if dialog.title == title:
                         return f"Group created with ID: {dialog.id}"
@@ -1936,8 +2119,9 @@ async def create_group(title: str, user_ids: List[Union[int, str]]) -> str:
         title="Invite To Group", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("group_id", "user_ids")
-async def invite_to_group(group_id: Union[int, str], user_ids: List[Union[int, str]]) -> str:
+async def invite_to_group(group_id: Union[int, str], user_ids: List[Union[int, str]], account: str = None) -> str:
     """
     Invite users to a group or channel.
 
@@ -1946,18 +2130,19 @@ async def invite_to_group(group_id: Union[int, str], user_ids: List[Union[int, s
         user_ids: List of user IDs or usernames to invite.
     """
     try:
-        entity = await resolve_entity(group_id)
+        cl = get_client(account)
+        entity = await resolve_entity(group_id, cl)
         users_to_add = []
 
         for user_id in user_ids:
             try:
-                user = await resolve_entity(user_id)
+                user = await resolve_entity(user_id, cl)
                 users_to_add.append(user)
             except ValueError as e:
                 return f"Error: User with ID {user_id} could not be found. {e}"
 
         try:
-            result = await client(
+            result = await cl(
                 functions.channels.InviteToChannelRequest(channel=entity, users=users_to_add)
             )
 
@@ -1990,8 +2175,9 @@ async def invite_to_group(group_id: Union[int, str], user_ids: List[Union[int, s
         title="Leave Chat", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def leave_chat(chat_id: Union[int, str]) -> str:
+async def leave_chat(chat_id: Union[int, str], account: str = None) -> str:
     """
     Leave a group or channel by chat ID.
 
@@ -1999,13 +2185,14 @@ async def leave_chat(chat_id: Union[int, str]) -> str:
         chat_id: The chat ID or username to leave.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         # Check the entity type carefully
         if isinstance(entity, Channel):
             # Handle both channels and supergroups (which are also channels in Telegram)
             try:
-                await client(functions.channels.LeaveChannelRequest(channel=entity))
+                await cl(functions.channels.LeaveChannelRequest(channel=entity))
                 chat_name = getattr(entity, "title", str(chat_id))
                 return f"Left channel/supergroup {chat_name} (ID: {chat_id})."
             except Exception as chan_err:
@@ -2015,8 +2202,8 @@ async def leave_chat(chat_id: Union[int, str]) -> str:
             # Traditional basic groups (not supergroups)
             try:
                 # First try with InputPeerUser
-                me = await client.get_me(input_peer=True)
-                await client(
+                me = await cl.get_me(input_peer=True)
+                await cl(
                     functions.messages.DeleteChatUserRequest(
                         chat_id=entity.id,
                         user_id=me,  # Use the entity ID directly
@@ -2032,8 +2219,8 @@ async def leave_chat(chat_id: Union[int, str]) -> str:
 
                 try:
                     # Alternative approach - sometimes this works better
-                    me_full = await client.get_me()
-                    await client(
+                    me_full = await cl.get_me()
+                    await cl(
                         functions.messages.DeleteChatUserRequest(
                             chat_id=entity.id, user_id=me_full.id
                         )
@@ -2073,15 +2260,17 @@ async def leave_chat(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Participants", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_participants(chat_id: Union[int, str]) -> str:
+async def get_participants(chat_id: Union[int, str], account: str = None) -> str:
     """
     List all participants in a group or channel.
     Args:
         chat_id: The group or channel ID or username.
     """
     try:
-        participants = await client.get_participants(chat_id)
+        cl = get_client(account)
+        participants = await cl.get_participants(chat_id)
         lines = [
             f"ID: {p.id}, Name: {getattr(p, 'first_name', '')} {getattr(p, 'last_name', '')}"
             for p in participants
@@ -2092,12 +2281,14 @@ async def get_participants(chat_id: Union[int, str]) -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Send File", openWorldHint=True, destructiveHint=True))
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def send_file(
     chat_id: Union[int, str],
     file_path: str,
     caption: str = None,
     ctx: Optional[Context] = None,
+    account: str = None,
 ) -> str:
     """
     Send a file to a chat.
@@ -2107,6 +2298,7 @@ async def send_file(
         caption: Optional caption for the file.
     """
     try:
+        cl = get_client(account)
         safe_path, path_error = await _resolve_readable_file_path(
             raw_path=file_path,
             ctx=ctx,
@@ -2114,8 +2306,8 @@ async def send_file(
         )
         if path_error:
             return path_error
-        entity = await resolve_entity(chat_id)
-        await client.send_file(entity, str(safe_path), caption=caption)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_file(entity, str(safe_path), caption=caption)
         return f"File sent to chat {chat_id} from {safe_path}."
     except Exception as e:
         return log_and_format_error(
@@ -2126,12 +2318,14 @@ async def send_file(
 @mcp.tool(
     annotations=ToolAnnotations(title="Download Media", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def download_media(
     chat_id: Union[int, str],
     message_id: int,
     file_path: Optional[str] = None,
     ctx: Optional[Context] = None,
+    account: str = None,
 ) -> str:
     """
     Download media from a message in a chat.
@@ -2142,8 +2336,9 @@ async def download_media(
             If omitted, saves into `<first_root>/downloads/`.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        msg = await client.get_messages(entity, ids=message_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        msg = await cl.get_messages(entity, ids=message_id)
         if not msg or not msg.media:
             return "No media found in the specified message."
 
@@ -2157,7 +2352,7 @@ async def download_media(
         if path_error:
             return path_error
 
-        downloaded = await client.download_media(msg, file=str(out_path))
+        downloaded = await cl.download_media(msg, file=str(out_path))
         if not downloaded:
             return f"Download failed for message {message_id}."
 
@@ -2184,12 +2379,14 @@ async def download_media(
         title="Update Profile", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def update_profile(first_name: str = None, last_name: str = None, about: str = None) -> str:
+@with_account(readonly=False)
+async def update_profile(account: str = None, first_name: str = None, last_name: str = None, about: str = None) -> str:
     """
     Update your profile information (name, bio).
     """
     try:
-        await client(
+        cl = get_client(account)
+        await cl(
             functions.account.UpdateProfileRequest(
                 first_name=first_name, last_name=last_name, about=about
             )
@@ -2206,11 +2403,13 @@ async def update_profile(first_name: str = None, last_name: str = None, about: s
         title="Set Profile Photo", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def set_profile_photo(file_path: str, ctx: Optional[Context] = None) -> str:
+@with_account(readonly=False)
+async def set_profile_photo(file_path: str, ctx: Optional[Context] = None, account: str = None) -> str:
     """
     Set a new profile photo.
     """
     try:
+        cl = get_client(account)
         safe_path, path_error = await _resolve_readable_file_path(
             raw_path=file_path,
             ctx=ctx,
@@ -2218,9 +2417,9 @@ async def set_profile_photo(file_path: str, ctx: Optional[Context] = None) -> st
         )
         if path_error:
             return path_error
-        await client(
+        await cl(
             functions.photos.UploadProfilePhotoRequest(
-                file=await client.upload_file(str(safe_path))
+                file=await cl.upload_file(str(safe_path))
             )
         )
         return f"Profile photo updated from {safe_path}."
@@ -2233,17 +2432,19 @@ async def set_profile_photo(file_path: str, ctx: Optional[Context] = None) -> st
         title="Delete Profile Photo", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def delete_profile_photo() -> str:
+@with_account(readonly=False)
+async def delete_profile_photo(account: str = None) -> str:
     """
     Delete your current profile photo.
     """
     try:
-        photos = await client(
+        cl = get_client(account)
+        photos = await cl(
             functions.photos.GetUserPhotosRequest(user_id="me", offset=0, max_id=0, limit=1)
         )
         if not photos.photos:
             return "No profile photo to delete."
-        await client(functions.photos.DeletePhotosRequest(id=[photos.photos[0]]))
+        await cl(functions.photos.DeletePhotosRequest(id=[photos.photos[0]]))
         return "Profile photo deleted."
     except Exception as e:
         return log_and_format_error("delete_profile_photo", e)
@@ -2254,16 +2455,18 @@ async def delete_profile_photo() -> str:
         title="Get Privacy Settings", openWorldHint=True, readOnlyHint=True
     )
 )
-async def get_privacy_settings() -> str:
+@with_account(readonly=True)
+async def get_privacy_settings(account: str = None) -> str:
     """
     Get your privacy settings for last seen status.
     """
     try:
+        cl = get_client(account)
         # Import needed types directly
         from telethon.tl.types import InputPrivacyKeyStatusTimestamp
 
         try:
-            settings = await client(
+            settings = await cl(
                 functions.account.GetPrivacyRequest(key=InputPrivacyKeyStatusTimestamp())
             )
             return str(settings)
@@ -2282,11 +2485,13 @@ async def get_privacy_settings() -> str:
         title="Set Privacy Settings", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("allow_users", "disallow_users")
 async def set_privacy_settings(
     key: str,
     allow_users: Optional[List[Union[int, str]]] = None,
     disallow_users: Optional[List[Union[int, str]]] = None,
+    account: str = None,
 ) -> str:
     """
     Set privacy settings (e.g., last seen, phone, etc.).
@@ -2297,6 +2502,7 @@ async def set_privacy_settings(
         disallow_users: List of user IDs or usernames to disallow
     """
     try:
+        cl = get_client(account)
         # Import needed types
         from telethon.tl.types import (
             InputPrivacyKeyStatusTimestamp,
@@ -2334,7 +2540,7 @@ async def set_privacy_settings(
                 allow_entities = []
                 for user_id in allow_users:
                     try:
-                        user = await resolve_entity(user_id)
+                        user = await resolve_entity(user_id, cl)
                         allow_entities.append(user)
                     except Exception as user_err:
                         logger.warning(f"Could not get entity for user ID {user_id}: {user_err}")
@@ -2351,7 +2557,7 @@ async def set_privacy_settings(
                 disallow_entities = []
                 for user_id in disallow_users:
                     try:
-                        user = await resolve_entity(user_id)
+                        user = await resolve_entity(user_id, cl)
                         disallow_entities.append(user)
                     except Exception as user_err:
                         logger.warning(f"Could not get entity for user ID {user_id}: {user_err}")
@@ -2364,7 +2570,7 @@ async def set_privacy_settings(
 
         # Apply the privacy settings
         try:
-            result = await client(
+            result = await cl(
                 functions.account.SetPrivacyRequest(key=privacy_key, rules=rules)
             )
             return f"Privacy settings for {key} updated successfully."
@@ -2381,11 +2587,13 @@ async def set_privacy_settings(
 @mcp.tool(
     annotations=ToolAnnotations(title="Import Contacts", openWorldHint=True, destructiveHint=True)
 )
-async def import_contacts(contacts: list) -> str:
+@with_account(readonly=False)
+async def import_contacts(contacts: list, account: str = None) -> str:
     """
     Import a list of contacts. Each contact should be a dict with phone, first_name, last_name.
     """
     try:
+        cl = get_client(account)
         input_contacts = [
             functions.contacts.InputPhoneContact(
                 client_id=i,
@@ -2395,7 +2603,7 @@ async def import_contacts(contacts: list) -> str:
             )
             for i, c in enumerate(contacts)
         ]
-        result = await client(functions.contacts.ImportContactsRequest(contacts=input_contacts))
+        result = await cl(functions.contacts.ImportContactsRequest(contacts=input_contacts))
         return f"Imported {len(result.imported)} contacts."
     except Exception as e:
         return log_and_format_error("import_contacts", e, contacts=contacts)
@@ -2404,12 +2612,14 @@ async def import_contacts(contacts: list) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Export Contacts", openWorldHint=True, readOnlyHint=True)
 )
-async def export_contacts() -> str:
+@with_account(readonly=True)
+async def export_contacts(account: str = None) -> str:
     """
     Export all contacts as a JSON string.
     """
     try:
-        result = await client(functions.contacts.GetContactsRequest(hash=0))
+        cl = get_client(account)
+        result = await cl(functions.contacts.GetContactsRequest(hash=0))
         users = result.users
         return json.dumps([format_entity(u) for u in users], indent=2)
     except Exception as e:
@@ -2419,12 +2629,14 @@ async def export_contacts() -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Blocked Users", openWorldHint=True, readOnlyHint=True)
 )
-async def get_blocked_users() -> str:
+@with_account(readonly=True)
+async def get_blocked_users(account: str = None) -> str:
     """
     Get a list of blocked users.
     """
     try:
-        result = await client(functions.contacts.GetBlockedRequest(offset=0, limit=100))
+        cl = get_client(account)
+        result = await cl(functions.contacts.GetBlockedRequest(offset=0, limit=100))
         return json.dumps([format_entity(u) for u in result.users], indent=2)
     except Exception as e:
         return log_and_format_error("get_blocked_users", e)
@@ -2433,12 +2645,14 @@ async def get_blocked_users() -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Create Channel", openWorldHint=True, destructiveHint=True)
 )
-async def create_channel(title: str, about: str = "", megagroup: bool = False) -> str:
+@with_account(readonly=False)
+async def create_channel(title: str, about: str = "", megagroup: bool = False, account: str = None) -> str:
     """
     Create a new channel or supergroup.
     """
     try:
-        result = await client(
+        cl = get_client(account)
+        result = await cl(
             functions.channels.CreateChannelRequest(title=title, about=about, megagroup=megagroup)
         )
         return f"Channel '{title}' created with ID: {result.chats[0].id}"
@@ -2453,17 +2667,19 @@ async def create_channel(title: str, about: str = "", megagroup: bool = False) -
         title="Edit Chat Title", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def edit_chat_title(chat_id: Union[int, str], title: str) -> str:
+async def edit_chat_title(chat_id: Union[int, str], title: str, account: str = None) -> str:
     """
     Edit the title of a chat, group, or channel.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
         if isinstance(entity, Channel):
-            await client(functions.channels.EditTitleRequest(channel=entity, title=title))
+            await cl(functions.channels.EditTitleRequest(channel=entity, title=title))
         elif isinstance(entity, Chat):
-            await client(functions.messages.EditChatTitleRequest(chat_id=chat_id, title=title))
+            await cl(functions.messages.EditChatTitleRequest(chat_id=chat_id, title=title))
         else:
             return f"Cannot edit title for this entity type ({type(entity)})."
         return f"Chat {chat_id} title updated to '{title}'."
@@ -2477,16 +2693,19 @@ async def edit_chat_title(chat_id: Union[int, str], title: str) -> str:
         title="Edit Chat Photo", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def edit_chat_photo(
     chat_id: Union[int, str],
     file_path: str,
     ctx: Optional[Context] = None,
+    account: str = None,
 ) -> str:
     """
     Edit the photo of a chat, group, or channel. Requires a file path to an image.
     """
     try:
+        cl = get_client(account)
         safe_path, path_error = await _resolve_readable_file_path(
             raw_path=file_path,
             ctx=ctx,
@@ -2495,17 +2714,17 @@ async def edit_chat_photo(
         if path_error:
             return path_error
 
-        entity = await resolve_entity(chat_id)
-        uploaded_file = await client.upload_file(str(safe_path))
+        entity = await resolve_entity(chat_id, cl)
+        uploaded_file = await cl.upload_file(str(safe_path))
 
         if isinstance(entity, Channel):
             # For channels/supergroups, use EditPhotoRequest with InputChatUploadedPhoto
             input_photo = InputChatUploadedPhoto(file=uploaded_file)
-            await client(functions.channels.EditPhotoRequest(channel=entity, photo=input_photo))
+            await cl(functions.channels.EditPhotoRequest(channel=entity, photo=input_photo))
         elif isinstance(entity, Chat):
             # For basic groups, use EditChatPhotoRequest with InputChatUploadedPhoto
             input_photo = InputChatUploadedPhoto(file=uploaded_file)
-            await client(
+            await cl(
                 functions.messages.EditChatPhotoRequest(chat_id=chat_id, photo=input_photo)
             )
         else:
@@ -2522,21 +2741,23 @@ async def edit_chat_photo(
         title="Delete Chat Photo", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def delete_chat_photo(chat_id: Union[int, str]) -> str:
+async def delete_chat_photo(chat_id: Union[int, str], account: str = None) -> str:
     """
     Delete the photo of a chat, group, or channel.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
         if isinstance(entity, Channel):
             # Use InputChatPhotoEmpty for channels/supergroups
-            await client(
+            await cl(
                 functions.channels.EditPhotoRequest(channel=entity, photo=InputChatPhotoEmpty())
             )
         elif isinstance(entity, Chat):
             # Use None (or InputChatPhotoEmpty) for basic groups
-            await client(
+            await cl(
                 functions.messages.EditChatPhotoRequest(
                     chat_id=chat_id, photo=InputChatPhotoEmpty()
                 )
@@ -2555,9 +2776,11 @@ async def delete_chat_photo(chat_id: Union[int, str]) -> str:
         title="Promote Admin", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("group_id", "user_id")
 async def promote_admin(
-    group_id: Union[int, str], user_id: Union[int, str], rights: dict = None
+    group_id: Union[int, str], user_id: Union[int, str], rights: dict = None,
+    account: str = None,
 ) -> str:
     """
     Promote a user to admin in a group/channel.
@@ -2568,8 +2791,9 @@ async def promote_admin(
         rights: Admin rights to give (optional)
     """
     try:
-        chat = await resolve_entity(group_id)
-        user = await resolve_entity(user_id)
+        cl = get_client(account)
+        chat = await resolve_entity(group_id, cl)
+        user = await resolve_entity(user_id, cl)
 
         # Set default admin rights if not provided
         if not rights:
@@ -2602,7 +2826,7 @@ async def promote_admin(
         )
 
         try:
-            result = await client(
+            result = await cl(
                 functions.channels.EditAdminRequest(
                     channel=chat, user_id=user, admin_rights=admin_rights, rank="Admin"
                 )
@@ -2626,8 +2850,9 @@ async def promote_admin(
         title="Demote Admin", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("group_id", "user_id")
-async def demote_admin(group_id: Union[int, str], user_id: Union[int, str]) -> str:
+async def demote_admin(group_id: Union[int, str], user_id: Union[int, str], account: str = None) -> str:
     """
     Demote a user from admin in a group/channel.
 
@@ -2636,8 +2861,9 @@ async def demote_admin(group_id: Union[int, str], user_id: Union[int, str]) -> s
         user_id: User ID or username to demote
     """
     try:
-        chat = await resolve_entity(group_id)
-        user = await resolve_entity(user_id)
+        cl = get_client(account)
+        chat = await resolve_entity(group_id, cl)
+        user = await resolve_entity(user_id, cl)
 
         # Create empty admin rights (regular user)
         admin_rights = ChatAdminRights(
@@ -2655,7 +2881,7 @@ async def demote_admin(group_id: Union[int, str], user_id: Union[int, str]) -> s
         )
 
         try:
-            result = await client(
+            result = await cl(
                 functions.channels.EditAdminRequest(
                     channel=chat, user_id=user, admin_rights=admin_rights, rank=""
                 )
@@ -2679,8 +2905,9 @@ async def demote_admin(group_id: Union[int, str], user_id: Union[int, str]) -> s
         title="Ban User", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id", "user_id")
-async def ban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
+async def ban_user(chat_id: Union[int, str], user_id: Union[int, str], account: str = None) -> str:
     """
     Ban a user from a group or channel.
 
@@ -2689,8 +2916,9 @@ async def ban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
         user_id: User ID or username to ban
     """
     try:
-        chat = await resolve_entity(chat_id)
-        user = await resolve_entity(user_id)
+        cl = get_client(account)
+        chat = await resolve_entity(chat_id, cl)
+        user = await resolve_entity(user_id, cl)
 
         # Create banned rights (all restrictions enabled)
         banned_rights = ChatBannedRights(
@@ -2710,7 +2938,7 @@ async def ban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
         )
 
         try:
-            await client(
+            await cl(
                 functions.channels.EditBannedRequest(
                     channel=chat, participant=user, banned_rights=banned_rights
                 )
@@ -2730,8 +2958,9 @@ async def ban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
         title="Unban User", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id", "user_id")
-async def unban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
+async def unban_user(chat_id: Union[int, str], user_id: Union[int, str], account: str = None) -> str:
     """
     Unban a user from a group or channel.
 
@@ -2740,8 +2969,9 @@ async def unban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
         user_id: User ID or username to unban
     """
     try:
-        chat = await resolve_entity(chat_id)
-        user = await resolve_entity(user_id)
+        cl = get_client(account)
+        chat = await resolve_entity(chat_id, cl)
+        user = await resolve_entity(user_id, cl)
 
         # Create unbanned rights (no restrictions)
         unbanned_rights = ChatBannedRights(
@@ -2761,7 +2991,7 @@ async def unban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
         )
 
         try:
-            await client(
+            await cl(
                 functions.channels.EditBannedRequest(
                     channel=chat, participant=user, banned_rights=unbanned_rights
                 )
@@ -2777,14 +3007,16 @@ async def unban_user(chat_id: Union[int, str], user_id: Union[int, str]) -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Admins", openWorldHint=True, readOnlyHint=True))
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_admins(chat_id: Union[int, str]) -> str:
+async def get_admins(chat_id: Union[int, str], account: str = None) -> str:
     """
     Get all admins in a group or channel.
     """
     try:
+        cl = get_client(account)
         # Fix: Use the correct filter type ChannelParticipantsAdmins
-        participants = await client.get_participants(chat_id, filter=ChannelParticipantsAdmins())
+        participants = await cl.get_participants(chat_id, filter=ChannelParticipantsAdmins())
         lines = [
             f"ID: {p.id}, Name: {getattr(p, 'first_name', '')} {getattr(p, 'last_name', '')}".strip()
             for p in participants
@@ -2798,14 +3030,16 @@ async def get_admins(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Banned Users", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_banned_users(chat_id: Union[int, str]) -> str:
+async def get_banned_users(chat_id: Union[int, str], account: str = None) -> str:
     """
     Get all banned users in a group or channel.
     """
     try:
+        cl = get_client(account)
         # Fix: Use the correct filter type ChannelParticipantsKicked
-        participants = await client.get_participants(
+        participants = await cl.get_participants(
             chat_id, filter=ChannelParticipantsKicked(q="")
         )
         lines = [
@@ -2821,19 +3055,21 @@ async def get_banned_users(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Invite Link", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_invite_link(chat_id: Union[int, str]) -> str:
+async def get_invite_link(chat_id: Union[int, str], account: str = None) -> str:
     """
     Get the invite link for a group or channel.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         # Try using ExportChatInviteRequest first
         try:
             from telethon.tl import functions
 
-            result = await client(functions.messages.ExportChatInviteRequest(peer=entity))
+            result = await cl(functions.messages.ExportChatInviteRequest(peer=entity))
             return result.link
         except AttributeError:
             # If the function doesn't exist in the current Telethon version
@@ -2842,9 +3078,9 @@ async def get_invite_link(chat_id: Union[int, str]) -> str:
             # If that fails, log and try alternative approach
             logger.warning(f"ExportChatInviteRequest failed: {e1}")
 
-        # Alternative approach using client.export_chat_invite_link
+        # Alternative approach using cl.export_chat_invite_link
         try:
-            invite_link = await client.export_chat_invite_link(entity)
+            invite_link = await cl.export_chat_invite_link(entity)
             return invite_link
         except Exception as e2:
             logger.warning(f"export_chat_invite_link failed: {e2}")
@@ -2852,7 +3088,7 @@ async def get_invite_link(chat_id: Union[int, str]) -> str:
         # Last resort: Try directly fetching chat info
         try:
             if isinstance(entity, (Chat, Channel)):
-                full_chat = await client(functions.messages.GetFullChatRequest(chat_id=entity.id))
+                full_chat = await cl(functions.messages.GetFullChatRequest(chat_id=entity.id))
                 if hasattr(full_chat, "full_chat") and hasattr(full_chat.full_chat, "invite_link"):
                     return full_chat.full_chat.invite_link or "No invite link available."
         except Exception as e3:
@@ -2869,11 +3105,13 @@ async def get_invite_link(chat_id: Union[int, str]) -> str:
         title="Join Chat By Link", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def join_chat_by_link(link: str) -> str:
+@with_account(readonly=False)
+async def join_chat_by_link(link: str, account: str = None) -> str:
     """
     Join a chat by invite link.
     """
     try:
+        cl = get_client(account)
         # Extract the hash from the invite link
         if "/" in link:
             hash_part = link.split("/")[-1]
@@ -2885,7 +3123,7 @@ async def join_chat_by_link(link: str) -> str:
         # Try checking the invite before joining
         try:
             # Try to check invite info first (will often fail if not a member)
-            invite_info = await client(functions.messages.CheckChatInviteRequest(hash=hash_part))
+            invite_info = await cl(functions.messages.CheckChatInviteRequest(hash=hash_part))
             if hasattr(invite_info, "chat") and invite_info.chat:
                 # If we got chat info, we're already a member
                 chat_title = getattr(invite_info.chat, "title", "Unknown Chat")
@@ -2895,7 +3133,7 @@ async def join_chat_by_link(link: str) -> str:
             pass
 
         # Join the chat using the hash
-        result = await client(functions.messages.ImportChatInviteRequest(hash=hash_part))
+        result = await cl(functions.messages.ImportChatInviteRequest(hash=hash_part))
         if result and hasattr(result, "chats") and result.chats:
             chat_title = getattr(result.chats[0], "title", "Unknown Chat")
             return f"Successfully joined chat: {chat_title}"
@@ -2915,19 +3153,21 @@ async def join_chat_by_link(link: str) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Export Chat Invite", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def export_chat_invite(chat_id: Union[int, str]) -> str:
+async def export_chat_invite(chat_id: Union[int, str], account: str = None) -> str:
     """
     Export a chat invite link.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         # Try using ExportChatInviteRequest first
         try:
             from telethon.tl import functions
 
-            result = await client(functions.messages.ExportChatInviteRequest(peer=entity))
+            result = await cl(functions.messages.ExportChatInviteRequest(peer=entity))
             return result.link
         except AttributeError:
             # If the function doesn't exist in the current Telethon version
@@ -2936,9 +3176,9 @@ async def export_chat_invite(chat_id: Union[int, str]) -> str:
             # If that fails, log and try alternative approach
             logger.warning(f"ExportChatInviteRequest failed: {e1}")
 
-        # Alternative approach using client.export_chat_invite_link
+        # Alternative approach using cl.export_chat_invite_link
         try:
-            invite_link = await client.export_chat_invite_link(entity)
+            invite_link = await cl.export_chat_invite_link(entity)
             return invite_link
         except Exception as e2:
             logger.warning(f"export_chat_invite_link failed: {e2}")
@@ -2954,11 +3194,13 @@ async def export_chat_invite(chat_id: Union[int, str]) -> str:
         title="Import Chat Invite", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def import_chat_invite(hash: str) -> str:
+@with_account(readonly=False)
+async def import_chat_invite(hash: str, account: str = None) -> str:
     """
     Import a chat invite by hash.
     """
     try:
+        cl = get_client(account)
         # Remove any prefixes like '+' if present
         if hash.startswith("+"):
             hash = hash[1:]
@@ -2974,7 +3216,7 @@ async def import_chat_invite(hash: str) -> str:
             )
 
             # Try to check invite info first (will often fail if not a member)
-            invite_info = await client(functions.messages.CheckChatInviteRequest(hash=hash))
+            invite_info = await cl(functions.messages.CheckChatInviteRequest(hash=hash))
             if hasattr(invite_info, "chat") and invite_info.chat:
                 # If we got chat info, we're already a member
                 chat_title = getattr(invite_info.chat, "title", "Unknown Chat")
@@ -2985,7 +3227,7 @@ async def import_chat_invite(hash: str) -> str:
 
         # Join the chat using the hash
         try:
-            result = await client(functions.messages.ImportChatInviteRequest(hash=hash))
+            result = await cl(functions.messages.ImportChatInviteRequest(hash=hash))
             if result and hasattr(result, "chats") and result.chats:
                 chat_title = getattr(result.chats[0], "title", "Unknown Chat")
                 return f"Successfully joined chat: {chat_title}"
@@ -3013,11 +3255,13 @@ async def import_chat_invite(hash: str) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Send Voice", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def send_voice(
     chat_id: Union[int, str],
     file_path: str,
     ctx: Optional[Context] = None,
+    account: str = None,
 ) -> str:
     """
     Send a voice message to a chat. File must be an OGG/OPUS voice note.
@@ -3027,6 +3271,7 @@ async def send_voice(
         file_path: Absolute or relative path under allowed roots to the OGG/OPUS file.
     """
     try:
+        cl = get_client(account)
         safe_path, path_error = await _resolve_readable_file_path(
             raw_path=file_path,
             ctx=ctx,
@@ -3046,8 +3291,8 @@ async def send_voice(
         ):
             return "Voice file must be .ogg or .opus format."
 
-        entity = await resolve_entity(chat_id)
-        await client.send_file(entity, str(safe_path), voice_note=True)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_file(entity, str(safe_path), voice_note=True)
         return f"Voice message sent to chat {chat_id} from {safe_path}."
     except Exception as e:
         return log_and_format_error("send_voice", e, chat_id=chat_id, file_path=file_path)
@@ -3056,7 +3301,8 @@ async def send_voice(
 @mcp.tool(
     annotations=ToolAnnotations(title="Upload File", openWorldHint=True, destructiveHint=True)
 )
-async def upload_file(file_path: str, ctx: Optional[Context] = None) -> str:
+@with_account(readonly=False)
+async def upload_file(file_path: str, ctx: Optional[Context] = None, account: str = None) -> str:
     """
     Upload a local file to Telegram and return upload metadata.
 
@@ -3064,6 +3310,7 @@ async def upload_file(file_path: str, ctx: Optional[Context] = None) -> str:
         file_path: Absolute or relative path under allowed roots.
     """
     try:
+        cl = get_client(account)
         safe_path, path_error = await _resolve_readable_file_path(
             raw_path=file_path,
             ctx=ctx,
@@ -3072,7 +3319,7 @@ async def upload_file(file_path: str, ctx: Optional[Context] = None) -> str:
         if path_error:
             return path_error
 
-        uploaded = await client.upload_file(str(safe_path))
+        uploaded = await cl.upload_file(str(safe_path))
         payload = {
             "path": str(safe_path),
             "name": getattr(uploaded, "name", safe_path.name),
@@ -3087,17 +3334,20 @@ async def upload_file(file_path: str, ctx: Optional[Context] = None) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Forward Message", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("from_chat_id", "to_chat_id")
 async def forward_message(
-    from_chat_id: Union[int, str], message_id: int, to_chat_id: Union[int, str]
+    from_chat_id: Union[int, str], message_id: int, to_chat_id: Union[int, str],
+    account: str = None,
 ) -> str:
     """
     Forward a message from one chat to another.
     """
     try:
-        from_entity = await resolve_entity(from_chat_id)
-        to_entity = await resolve_entity(to_chat_id)
-        await client.forward_messages(to_entity, message_id, from_entity)
+        cl = get_client(account)
+        from_entity = await resolve_entity(from_chat_id, cl)
+        to_entity = await resolve_entity(to_chat_id, cl)
+        await cl.forward_messages(to_entity, message_id, from_entity)
         return f"Message {message_id} forwarded from {from_chat_id} to {to_chat_id}."
     except Exception as e:
         return log_and_format_error(
@@ -3114,14 +3364,16 @@ async def forward_message(
         title="Edit Message", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def edit_message(chat_id: Union[int, str], message_id: int, new_text: str) -> str:
+async def edit_message(chat_id: Union[int, str], message_id: int, new_text: str, account: str = None) -> str:
     """
     Edit a message you sent.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.edit_message(entity, message_id, new_text)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.edit_message(entity, message_id, new_text)
         return f"Message {message_id} edited."
     except Exception as e:
         return log_and_format_error(
@@ -3134,14 +3386,16 @@ async def edit_message(chat_id: Union[int, str], message_id: int, new_text: str)
         title="Delete Message", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def delete_message(chat_id: Union[int, str], message_id: int) -> str:
+async def delete_message(chat_id: Union[int, str], message_id: int, account: str = None) -> str:
     """
     Delete a message by ID.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.delete_messages(entity, message_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.delete_messages(entity, message_id)
         return f"Message {message_id} deleted."
     except Exception as e:
         return log_and_format_error("delete_message", e, chat_id=chat_id, message_id=message_id)
@@ -3152,14 +3406,16 @@ async def delete_message(chat_id: Union[int, str], message_id: int) -> str:
         title="Pin Message", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def pin_message(chat_id: Union[int, str], message_id: int) -> str:
+async def pin_message(chat_id: Union[int, str], message_id: int, account: str = None) -> str:
     """
     Pin a message in a chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.pin_message(entity, message_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.pin_message(entity, message_id)
         return f"Message {message_id} pinned in chat {chat_id}."
     except Exception as e:
         return log_and_format_error("pin_message", e, chat_id=chat_id, message_id=message_id)
@@ -3170,14 +3426,16 @@ async def pin_message(chat_id: Union[int, str], message_id: int) -> str:
         title="Unpin Message", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def unpin_message(chat_id: Union[int, str], message_id: int) -> str:
+async def unpin_message(chat_id: Union[int, str], message_id: int, account: str = None) -> str:
     """
     Unpin a message in a chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.unpin_message(entity, message_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.unpin_message(entity, message_id)
         return f"Message {message_id} unpinned in chat {chat_id}."
     except Exception as e:
         return log_and_format_error("unpin_message", e, chat_id=chat_id, message_id=message_id)
@@ -3188,14 +3446,16 @@ async def unpin_message(chat_id: Union[int, str], message_id: int) -> str:
         title="Mark As Read", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def mark_as_read(chat_id: Union[int, str]) -> str:
+async def mark_as_read(chat_id: Union[int, str], account: str = None) -> str:
     """
     Mark all messages as read in a chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.send_read_acknowledge(entity)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_read_acknowledge(entity)
         return f"Marked all messages as read in chat {chat_id}."
     except Exception as e:
         return log_and_format_error("mark_as_read", e, chat_id=chat_id)
@@ -3204,9 +3464,11 @@ async def mark_as_read(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Reply To Message", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def reply_to_message(
-    chat_id: Union[int, str], message_id: int, text: str, parse_mode: Optional[str] = None
+    chat_id: Union[int, str], message_id: int, text: str, parse_mode: Optional[str] = None,
+    account: str = None,
 ) -> str:
     """
     Reply to a specific message in a chat.
@@ -3219,8 +3481,9 @@ async def reply_to_message(
             ```pre```), or omit for plain text (no formatting).
     """
     try:
-        entity = await resolve_entity(chat_id)
-        await client.send_message(entity, text, reply_to=message_id, parse_mode=parse_mode)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_message(entity, text, reply_to=message_id, parse_mode=parse_mode)
         return f"Replied to message {message_id} in chat {chat_id}."
     except Exception as e:
         return log_and_format_error(
@@ -3231,8 +3494,9 @@ async def reply_to_message(
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Media Info", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_media_info(chat_id: Union[int, str], message_id: int) -> str:
+async def get_media_info(chat_id: Union[int, str], message_id: int, account: str = None) -> str:
     """
     Get info about media in a message.
 
@@ -3241,8 +3505,9 @@ async def get_media_info(chat_id: Union[int, str], message_id: int) -> str:
         message_id: The message ID.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        msg = await client.get_messages(entity, ids=message_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        msg = await cl.get_messages(entity, ids=message_id)
 
         if not msg or not msg.media:
             return "No media found in the specified message."
@@ -3255,12 +3520,14 @@ async def get_media_info(chat_id: Union[int, str], message_id: int) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Search Public Chats", openWorldHint=True, readOnlyHint=True)
 )
-async def search_public_chats(query: str, limit: int = 20) -> str:
+@with_account(readonly=True)
+async def search_public_chats(query: str, limit: int = 20, account: str = None) -> str:
     """
     Search for public chats, channels, or bots by username or title.
     """
     try:
-        result = await client(functions.contacts.SearchRequest(q=query, limit=limit))
+        cl = get_client(account)
+        result = await cl(functions.contacts.SearchRequest(q=query, limit=limit))
         entities = [format_entity(e) for e in result.chats + result.users]
         return json.dumps(entities, indent=2)
     except Exception as e:
@@ -3270,14 +3537,16 @@ async def search_public_chats(query: str, limit: int = 20) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Search Messages", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def search_messages(chat_id: Union[int, str], query: str, limit: int = 20) -> str:
+async def search_messages(chat_id: Union[int, str], query: str, limit: int = 20, account: str = None) -> str:
     """
     Search for messages in a chat by text.
     """
     try:
-        entity = await resolve_entity(chat_id)
-        messages = await client.get_messages(entity, limit=limit, search=query)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        messages = await cl.get_messages(entity, limit=limit, search=query)
 
         lines = []
         for msg in messages:
@@ -3302,13 +3571,15 @@ async def search_messages(chat_id: Union[int, str], query: str, limit: int = 20)
         readOnlyHint=True,
     )
 )
-async def search_global(query: str, page: int = 1, page_size: int = 20) -> str:
+@with_account(readonly=True)
+async def search_global(query: str, page: int = 1, page_size: int = 20, account: str = None) -> str:
     """
     Search for messages across all public chats and channels by text content.
     """
     try:
+        cl = get_client(account)
         offset = (page - 1) * page_size
-        messages = await client.get_messages(
+        messages = await cl.get_messages(
             None, limit=page_size, search=query, add_offset=offset
         )
 
@@ -3337,12 +3608,14 @@ async def search_global(query: str, page: int = 1, page_size: int = 20) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Resolve Username", openWorldHint=True, readOnlyHint=True)
 )
-async def resolve_username(username: str) -> str:
+@with_account(readonly=True)
+async def resolve_username(username: str, account: str = None) -> str:
     """
     Resolve a username to a user or chat ID.
     """
     try:
-        result = await client(functions.contacts.ResolveUsernameRequest(username=username))
+        cl = get_client(account)
+        result = await cl(functions.contacts.ResolveUsernameRequest(username=username))
         return str(result)
     except Exception as e:
         return log_and_format_error("resolve_username", e, username=username)
@@ -3353,16 +3626,18 @@ async def resolve_username(username: str) -> str:
         title="Mute Chat", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def mute_chat(chat_id: Union[int, str]) -> str:
+async def mute_chat(chat_id: Union[int, str], account: str = None) -> str:
     """
     Mute notifications for a chat.
     """
     try:
+        cl = get_client(account)
         from telethon.tl.types import InputPeerNotifySettings
 
-        peer = await resolve_entity(chat_id)
-        await client(
+        peer = await resolve_entity(chat_id, cl)
+        await cl(
             functions.account.UpdateNotifySettingsRequest(
                 peer=peer, settings=InputPeerNotifySettings(mute_until=2**31 - 1)
             )
@@ -3371,8 +3646,8 @@ async def mute_chat(chat_id: Union[int, str]) -> str:
     except (ImportError, AttributeError) as type_err:
         try:
             # Alternative approach directly using raw API
-            peer = await resolve_input_entity(chat_id)
-            await client(
+            peer = await resolve_input_entity(chat_id, cl)
+            await cl(
                 functions.account.UpdateNotifySettingsRequest(
                     peer=peer,
                     settings={
@@ -3396,16 +3671,18 @@ async def mute_chat(chat_id: Union[int, str]) -> str:
         title="Unmute Chat", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def unmute_chat(chat_id: Union[int, str]) -> str:
+async def unmute_chat(chat_id: Union[int, str], account: str = None) -> str:
     """
     Unmute notifications for a chat.
     """
     try:
+        cl = get_client(account)
         from telethon.tl.types import InputPeerNotifySettings
 
-        peer = await resolve_entity(chat_id)
-        await client(
+        peer = await resolve_entity(chat_id, cl)
+        await cl(
             functions.account.UpdateNotifySettingsRequest(
                 peer=peer, settings=InputPeerNotifySettings(mute_until=0)
             )
@@ -3414,8 +3691,8 @@ async def unmute_chat(chat_id: Union[int, str]) -> str:
     except (ImportError, AttributeError) as type_err:
         try:
             # Alternative approach directly using raw API
-            peer = await resolve_input_entity(chat_id)
-            await client(
+            peer = await resolve_input_entity(chat_id, cl)
+            await cl(
                 functions.account.UpdateNotifySettingsRequest(
                     peer=peer,
                     settings={
@@ -3439,15 +3716,17 @@ async def unmute_chat(chat_id: Union[int, str]) -> str:
         title="Archive Chat", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def archive_chat(chat_id: Union[int, str]) -> str:
+async def archive_chat(chat_id: Union[int, str], account: str = None) -> str:
     """
     Archive a chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
         peer = utils.get_input_peer(entity)
-        await client(
+        await cl(
             functions.folders.EditPeerFoldersRequest(
                 folder_peers=[types.InputFolderPeer(peer=peer, folder_id=1)]
             )
@@ -3462,15 +3741,17 @@ async def archive_chat(chat_id: Union[int, str]) -> str:
         title="Unarchive Chat", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def unarchive_chat(chat_id: Union[int, str]) -> str:
+async def unarchive_chat(chat_id: Union[int, str], account: str = None) -> str:
     """
     Unarchive a chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
         peer = utils.get_input_peer(entity)
-        await client(
+        await cl(
             functions.folders.EditPeerFoldersRequest(
                 folder_peers=[types.InputFolderPeer(peer=peer, folder_id=0)]
             )
@@ -3483,12 +3764,14 @@ async def unarchive_chat(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Sticker Sets", openWorldHint=True, readOnlyHint=True)
 )
-async def get_sticker_sets() -> str:
+@with_account(readonly=True)
+async def get_sticker_sets(account: str = None) -> str:
     """
     Get all sticker sets.
     """
     try:
-        result = await client(functions.messages.GetAllStickersRequest(hash=0))
+        cl = get_client(account)
+        result = await cl(functions.messages.GetAllStickersRequest(hash=0))
         return json.dumps([s.title for s in result.sets], indent=2)
     except Exception as e:
         return log_and_format_error("get_sticker_sets", e)
@@ -3497,11 +3780,13 @@ async def get_sticker_sets() -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Send Sticker", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def send_sticker(
     chat_id: Union[int, str],
     file_path: str,
     ctx: Optional[Context] = None,
+    account: str = None,
 ) -> str:
     """
     Send a sticker to a chat. File must be a valid .webp sticker file.
@@ -3511,6 +3796,7 @@ async def send_sticker(
         file_path: Absolute or relative path under allowed roots to the .webp sticker file.
     """
     try:
+        cl = get_client(account)
         safe_path, path_error = await _resolve_readable_file_path(
             raw_path=file_path,
             ctx=ctx,
@@ -3519,8 +3805,8 @@ async def send_sticker(
         if path_error:
             return path_error
 
-        entity = await resolve_entity(chat_id)
-        await client.send_file(entity, str(safe_path), force_document=False)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_file(entity, str(safe_path), force_document=False)
         return f"Sticker sent to chat {chat_id} from {safe_path}."
     except Exception as e:
         return log_and_format_error("send_sticker", e, chat_id=chat_id, file_path=file_path)
@@ -3529,7 +3815,8 @@ async def send_sticker(
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Gif Search", openWorldHint=True, readOnlyHint=True)
 )
-async def get_gif_search(query: str, limit: int = 10) -> str:
+@with_account(readonly=True)
+async def get_gif_search(query: str, limit: int = 10, account: str = None) -> str:
     """
     Search for GIFs by query. Returns a list of Telegram document IDs (not file paths).
 
@@ -3538,9 +3825,10 @@ async def get_gif_search(query: str, limit: int = 10) -> str:
         limit: Max number of GIFs to return.
     """
     try:
+        cl = get_client(account)
         # Try approach 1: SearchGifsRequest
         try:
-            result = await client(
+            result = await cl(
                 functions.messages.SearchGifsRequest(q=query, offset_id=0, limit=limit)
             )
             if not result.gifs:
@@ -3553,7 +3841,7 @@ async def get_gif_search(query: str, limit: int = 10) -> str:
             try:
                 from telethon.tl.types import InputMessagesFilterGif
 
-                result = await client(
+                result = await cl(
                     functions.messages.SearchRequest(
                         peer="gif",
                         q=query,
@@ -3585,8 +3873,9 @@ async def get_gif_search(query: str, limit: int = 10) -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Send Gif", openWorldHint=True, destructiveHint=True))
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def send_gif(chat_id: Union[int, str], gif_id: int) -> str:
+async def send_gif(chat_id: Union[int, str], gif_id: int, account: str = None) -> str:
     """
     Send a GIF to a chat by Telegram GIF document ID (not a file path).
 
@@ -3595,26 +3884,29 @@ async def send_gif(chat_id: Union[int, str], gif_id: int) -> str:
         gif_id: Telegram document ID for the GIF (from get_gif_search).
     """
     try:
+        cl = get_client(account)
         if not isinstance(gif_id, int):
             return "gif_id must be a Telegram document ID (integer), not a file path. Use get_gif_search to find IDs."
-        entity = await resolve_entity(chat_id)
-        await client.send_file(entity, gif_id)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_file(entity, gif_id)
         return f"GIF sent to chat {chat_id}."
     except Exception as e:
         return log_and_format_error("send_gif", e, chat_id=chat_id, gif_id=gif_id)
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Bot Info", openWorldHint=True, readOnlyHint=True))
-async def get_bot_info(bot_username: str) -> str:
+@with_account(readonly=True)
+async def get_bot_info(bot_username: str, account: str = None) -> str:
     """
     Get information about a bot by username.
     """
     try:
-        entity = await resolve_entity(bot_username)
+        cl = get_client(account)
+        entity = await resolve_entity(bot_username, cl)
         if not entity:
             return f"Bot with username {bot_username} not found."
 
-        result = await client(functions.users.GetFullUserRequest(id=entity))
+        result = await cl(functions.users.GetFullUserRequest(id=entity))
 
         # Create a more structured, serializable response
         if hasattr(result, "to_dict"):
@@ -3645,7 +3937,8 @@ async def get_bot_info(bot_username: str) -> str:
         title="Set Bot Commands", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def set_bot_commands(bot_username: str, commands: list) -> str:
+@with_account(readonly=False)
+async def set_bot_commands(bot_username: str, commands: list, account: str = None) -> str:
     """
     Set bot commands for a bot you own.
     Note: This function can only be used if the Telegram client is a bot account.
@@ -3656,8 +3949,9 @@ async def set_bot_commands(bot_username: str, commands: list) -> str:
         commands: List of command dictionaries with 'command' and 'description' keys.
     """
     try:
+        cl = get_client(account)
         # First check if the current client is a bot
-        me = await client.get_me()
+        me = await cl.get_me()
         if not getattr(me, "bot", False):
             return "Error: This function can only be used by bot accounts. Your current Telegram account is a regular user account, not a bot."
 
@@ -3671,10 +3965,10 @@ async def set_bot_commands(bot_username: str, commands: list) -> str:
         ]
 
         # Get the bot entity
-        bot = await resolve_entity(bot_username)
+        bot = await resolve_entity(bot_username, cl)
 
         # Set the commands with proper scope
-        await client(
+        await cl(
             SetBotCommandsRequest(
                 scope=BotCommandScopeDefault(),
                 lang_code="en",  # Default language code
@@ -3692,14 +3986,16 @@ async def set_bot_commands(bot_username: str, commands: list) -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get History", openWorldHint=True, readOnlyHint=True))
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_history(chat_id: Union[int, str], limit: int = 100) -> str:
+async def get_history(chat_id: Union[int, str], limit: int = 100, account: str = None) -> str:
     """
     Get full chat history (up to limit).
     """
     try:
-        entity = await resolve_entity(chat_id)
-        messages = await client.get_messages(entity, limit=limit)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        messages = await cl.get_messages(entity, limit=limit)
 
         lines = []
         for msg in messages:
@@ -3718,14 +4014,16 @@ async def get_history(chat_id: Union[int, str], limit: int = 100) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get User Photos", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("user_id")
-async def get_user_photos(user_id: Union[int, str], limit: int = 10) -> str:
+async def get_user_photos(user_id: Union[int, str], limit: int = 10, account: str = None) -> str:
     """
     Get profile photos of a user.
     """
     try:
-        user = await resolve_entity(user_id)
-        photos = await client(
+        cl = get_client(account)
+        user = await resolve_entity(user_id, cl)
+        photos = await cl(
             functions.photos.GetUserPhotosRequest(user_id=user, offset=0, max_id=0, limit=limit)
         )
         return json.dumps([p.id for p in photos.photos], indent=2)
@@ -3736,13 +4034,15 @@ async def get_user_photos(user_id: Union[int, str], limit: int = 10) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get User Status", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("user_id")
-async def get_user_status(user_id: Union[int, str]) -> str:
+async def get_user_status(user_id: Union[int, str], account: str = None) -> str:
     """
     Get the online status of a user.
     """
     try:
-        user = await resolve_entity(user_id)
+        cl = get_client(account)
+        user = await resolve_entity(user_id, cl)
         return str(user.status)
     except Exception as e:
         return log_and_format_error("get_user_status", e, user_id=user_id)
@@ -3751,13 +4051,15 @@ async def get_user_status(user_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Recent Actions", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_recent_actions(chat_id: Union[int, str]) -> str:
+async def get_recent_actions(chat_id: Union[int, str], account: str = None) -> str:
     """
     Get recent admin actions (admin log) in a group or channel.
     """
     try:
-        result = await client(
+        cl = get_client(account)
+        result = await cl(
             functions.channels.GetAdminLogRequest(
                 channel=chat_id,
                 q="",
@@ -3782,23 +4084,25 @@ async def get_recent_actions(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Get Pinned Messages", openWorldHint=True, readOnlyHint=True)
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
-async def get_pinned_messages(chat_id: Union[int, str]) -> str:
+async def get_pinned_messages(chat_id: Union[int, str], account: str = None) -> str:
     """
     Get all pinned messages in a chat.
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         # Use correct filter based on Telethon version
         try:
             # Try newer Telethon approach
             from telethon.tl.types import InputMessagesFilterPinned
 
-            messages = await client.get_messages(entity, filter=InputMessagesFilterPinned())
+            messages = await cl.get_messages(entity, filter=InputMessagesFilterPinned())
         except (ImportError, AttributeError):
             # Fallback - try without filter and manually filter pinned
-            all_messages = await client.get_messages(entity, limit=50)
+            all_messages = await cl.get_messages(entity, limit=50)
             messages = [m for m in all_messages if getattr(m, "pinned", False)]
 
         if not messages:
@@ -3823,6 +4127,7 @@ async def get_pinned_messages(chat_id: Union[int, str]) -> str:
 @mcp.tool(
     annotations=ToolAnnotations(title="Create Poll", openWorldHint=True, destructiveHint=True)
 )
+@with_account(readonly=False)
 async def create_poll(
     chat_id: int,
     question: str,
@@ -3831,6 +4136,7 @@ async def create_poll(
     quiz_mode: bool = False,
     public_votes: bool = True,
     close_date: str = None,
+    account: str = None,
 ) -> str:
     """
     Create a poll in a chat using Telegram's native poll feature.
@@ -3845,7 +4151,8 @@ async def create_poll(
         close_date: Optional close date in ISO format (YYYY-MM-DD HH:MM:SS)
     """
     try:
-        entity = await resolve_entity(chat_id)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
 
         # Validate options
         if len(options) < 2:
@@ -3878,7 +4185,7 @@ async def create_poll(
             close_date=close_date_obj,
         )
 
-        result = await client(
+        result = await cl(
             functions.messages.SendMediaRequest(
                 peer=entity,
                 media=InputMediaPoll(poll=poll),
@@ -3900,12 +4207,14 @@ async def create_poll(
         title="Send Reaction", openWorldHint=True, destructiveHint=False, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def send_reaction(
     chat_id: Union[int, str],
     message_id: int,
     emoji: str,
     big: bool = False,
+    account: str = None,
 ) -> str:
     """
     Send a reaction to a message.
@@ -3917,10 +4226,11 @@ async def send_reaction(
         big: Whether to show a big animation for the reaction (default: False)
     """
     try:
+        cl = get_client(account)
         from telethon.tl.types import ReactionEmoji
 
-        peer = await resolve_input_entity(chat_id)
-        await client(
+        peer = await resolve_input_entity(chat_id, cl)
+        await cl(
             functions.messages.SendReactionRequest(
                 peer=peer,
                 msg_id=message_id,
@@ -3943,10 +4253,12 @@ async def send_reaction(
         title="Remove Reaction", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def remove_reaction(
     chat_id: Union[int, str],
     message_id: int,
+    account: str = None,
 ) -> str:
     """
     Remove your reaction from a message.
@@ -3956,8 +4268,9 @@ async def remove_reaction(
         message_id: The message ID to remove reaction from
     """
     try:
-        peer = await resolve_input_entity(chat_id)
-        await client(
+        cl = get_client(account)
+        peer = await resolve_input_entity(chat_id, cl)
+        await cl(
             functions.messages.SendReactionRequest(
                 peer=peer,
                 msg_id=message_id,
@@ -3975,11 +4288,13 @@ async def remove_reaction(
         title="Get Message Reactions", openWorldHint=True, readOnlyHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=True)
 @validate_id("chat_id")
 async def get_message_reactions(
     chat_id: Union[int, str],
     message_id: int,
     limit: int = 50,
+    account: str = None,
 ) -> str:
     """
     Get the list of reactions on a message.
@@ -3990,11 +4305,12 @@ async def get_message_reactions(
         limit: Maximum number of users to return per reaction (default: 50)
     """
     try:
+        cl = get_client(account)
         from telethon.tl.types import ReactionEmoji, ReactionCustomEmoji
 
-        peer = await resolve_input_entity(chat_id)
+        peer = await resolve_input_entity(chat_id, cl)
 
-        result = await client(
+        result = await cl(
             functions.messages.GetMessageReactionsListRequest(
                 peer=peer,
                 id=message_id,
@@ -4051,12 +4367,14 @@ async def get_message_reactions(
         title="Save Draft", openWorldHint=True, destructiveHint=False, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def save_draft(
     chat_id: Union[int, str],
     message: str,
     reply_to_msg_id: Optional[int] = None,
     no_webpage: bool = False,
+    account: str = None,
 ) -> str:
     """
     Save a draft message to a chat or channel. The draft will appear in the Telegram
@@ -4069,7 +4387,8 @@ async def save_draft(
         no_webpage: If True, disable link preview in the draft
     """
     try:
-        peer = await resolve_input_entity(chat_id)
+        cl = get_client(account)
+        peer = await resolve_input_entity(chat_id, cl)
 
         # Build reply_to parameter if provided
         reply_to = None
@@ -4078,7 +4397,7 @@ async def save_draft(
 
             reply_to = InputReplyToMessage(reply_to_msg_id=reply_to_msg_id)
 
-        await client(
+        await cl(
             functions.messages.SaveDraftRequest(
                 peer=peer,
                 message=message,
@@ -4094,13 +4413,15 @@ async def save_draft(
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Drafts", openWorldHint=True, readOnlyHint=True))
-async def get_drafts() -> str:
+@with_account(readonly=True)
+async def get_drafts(account: str = None) -> str:
     """
     Get all draft messages across all chats.
     Returns a list of drafts with their chat info and message content.
     """
     try:
-        result = await client(functions.messages.GetAllDraftsRequest())
+        cl = get_client(account)
+        result = await cl(functions.messages.GetAllDraftsRequest())
 
         # The result contains updates with draft info
         drafts_info = []
@@ -4155,8 +4476,9 @@ async def get_drafts() -> str:
         title="Clear Draft", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def clear_draft(chat_id: Union[int, str]) -> str:
+async def clear_draft(chat_id: Union[int, str], account: str = None) -> str:
     """
     Clear/delete a draft from a specific chat.
 
@@ -4164,10 +4486,11 @@ async def clear_draft(chat_id: Union[int, str]) -> str:
         chat_id: The chat ID or username to clear the draft from
     """
     try:
-        peer = await resolve_input_entity(chat_id)
+        cl = get_client(account)
+        peer = await resolve_input_entity(chat_id, cl)
 
         # Saving an empty message clears the draft
-        await client(
+        await cl(
             functions.messages.SaveDraftRequest(
                 peer=peer,
                 message="",
@@ -4186,13 +4509,15 @@ async def clear_draft(chat_id: Union[int, str]) -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="List Folders", openWorldHint=True, readOnlyHint=True))
-async def list_folders() -> str:
+@with_account(readonly=True)
+async def list_folders(account: str = None) -> str:
     """
     Get all dialog folders (filters) with their IDs, names, and emoji.
     Returns a list of folders that can be used with other folder tools.
     """
     try:
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        cl = get_client(account)
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         folders = []
         for f in result.filters:
@@ -4250,7 +4575,8 @@ async def list_folders() -> str:
 
 
 @mcp.tool(annotations=ToolAnnotations(title="Get Folder", openWorldHint=True, readOnlyHint=True))
-async def get_folder(folder_id: int) -> str:
+@with_account(readonly=True)
+async def get_folder(folder_id: int, account: str = None) -> str:
     """
     Get detailed information about a specific folder including all included chats.
 
@@ -4258,7 +4584,8 @@ async def get_folder(folder_id: int) -> str:
         folder_id: The folder ID (get from list_folders)
     """
     try:
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        cl = get_client(account)
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         target_folder = None
         for f in result.filters:
@@ -4275,7 +4602,7 @@ async def get_folder(folder_id: int) -> str:
         included_chats = []
         for peer in getattr(target_folder, "include_peers", []):
             try:
-                entity = await resolve_entity(peer)
+                entity = await resolve_entity(peer, cl)
                 chat_info = {
                     "id": entity.id,
                     "name": getattr(entity, "title", None)
@@ -4292,7 +4619,7 @@ async def get_folder(folder_id: int) -> str:
         excluded_chats = []
         for peer in getattr(target_folder, "exclude_peers", []):
             try:
-                entity = await resolve_entity(peer)
+                entity = await resolve_entity(peer, cl)
                 chat_info = {
                     "id": entity.id,
                     "name": getattr(entity, "title", None)
@@ -4307,7 +4634,7 @@ async def get_folder(folder_id: int) -> str:
         pinned_chats = []
         for peer in getattr(target_folder, "pinned_peers", []):
             try:
-                entity = await resolve_entity(peer)
+                entity = await resolve_entity(peer, cl)
                 chat_info = {
                     "id": entity.id,
                     "name": getattr(entity, "title", None)
@@ -4357,6 +4684,7 @@ async def get_folder(folder_id: int) -> str:
         title="Create Folder", openWorldHint=True, destructiveHint=True, idempotentHint=False
     )
 )
+@with_account(readonly=False)
 async def create_folder(
     title: str,
     emoticon: Optional[str] = None,
@@ -4369,6 +4697,7 @@ async def create_folder(
     exclude_muted: bool = False,
     exclude_read: bool = False,
     exclude_archived: bool = True,
+    account: str = None,
 ) -> str:
     """
     Create a new dialog folder.
@@ -4387,8 +4716,9 @@ async def create_folder(
         exclude_archived: Exclude archived chats (default True)
     """
     try:
+        cl = get_client(account)
         # Get existing folders to check count and find next ID
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         existing_ids = set()
         folder_count = 0
@@ -4411,7 +4741,7 @@ async def create_folder(
         if chat_ids:
             for chat_id in chat_ids:
                 try:
-                    peer = await resolve_input_entity(chat_id)
+                    peer = await resolve_input_entity(chat_id, cl)
                     include_peers.append(peer)
                 except Exception as e:
                     return f"Failed to resolve chat '{chat_id}': {str(e)}"
@@ -4435,7 +4765,7 @@ async def create_folder(
             exclude_archived=exclude_archived,
         )
 
-        await client(functions.messages.UpdateDialogFilterRequest(id=new_id, filter=new_filter))
+        await cl(functions.messages.UpdateDialogFilterRequest(id=new_id, filter=new_filter))
 
         return json.dumps(
             {
@@ -4457,9 +4787,11 @@ async def create_folder(
         title="Add Chat to Folder", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
 async def add_chat_to_folder(
-    folder_id: int, chat_id: Union[int, str], pinned: bool = False
+    folder_id: int, chat_id: Union[int, str], pinned: bool = False,
+    account: str = None,
 ) -> str:
     """
     Add a chat to an existing folder.
@@ -4470,8 +4802,9 @@ async def add_chat_to_folder(
         pinned: Pin the chat in this folder (default False)
     """
     try:
+        cl = get_client(account)
         # Get the folder
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         target_folder = None
         for f in result.filters:
@@ -4486,7 +4819,7 @@ async def add_chat_to_folder(
 
         # Resolve chat to input peer
         try:
-            peer = await resolve_input_entity(chat_id)
+            peer = await resolve_input_entity(chat_id, cl)
         except Exception as e:
             return f"Failed to resolve chat '{chat_id}': {str(e)}"
 
@@ -4539,7 +4872,7 @@ async def add_chat_to_folder(
                 color=getattr(target_folder, "color", None),
             )
 
-        await client(
+        await cl(
             functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=updated_filter)
         )
 
@@ -4561,8 +4894,9 @@ async def add_chat_to_folder(
         idempotentHint=True,
     )
 )
+@with_account(readonly=False)
 @validate_id("chat_id")
-async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str]) -> str:
+async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str], account: str = None) -> str:
     """
     Remove a chat from a folder.
 
@@ -4571,8 +4905,9 @@ async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str]) -> s
         chat_id: Chat ID or username to remove
     """
     try:
+        cl = get_client(account)
         # Get the folder
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         target_folder = None
         for f in result.filters:
@@ -4587,7 +4922,7 @@ async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str]) -> s
 
         # Resolve chat to get peer ID
         try:
-            peer = await resolve_input_entity(chat_id)
+            peer = await resolve_input_entity(chat_id, cl)
             peer_id = utils.get_peer_id(peer)
         except Exception as e:
             return f"Failed to resolve chat '{chat_id}': {str(e)}"
@@ -4645,7 +4980,7 @@ async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str]) -> s
                 color=getattr(target_folder, "color", None),
             )
 
-        await client(
+        await cl(
             functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=updated_filter)
         )
 
@@ -4668,7 +5003,8 @@ async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str]) -> s
         title="Delete Folder", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def delete_folder(folder_id: int) -> str:
+@with_account(readonly=False)
+async def delete_folder(folder_id: int, account: str = None) -> str:
     """
     Delete a folder. Chats in the folder are preserved, only the folder is removed.
 
@@ -4676,12 +5012,13 @@ async def delete_folder(folder_id: int) -> str:
         folder_id: The folder ID to delete (get from list_folders)
     """
     try:
+        cl = get_client(account)
         # System folders (id < 2) cannot be deleted
         if folder_id < 2:
             return f"Cannot delete system folder (ID {folder_id}). Only custom folders can be deleted."
 
         # Check if folder exists
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         folder_exists = False
         folder_title = None
@@ -4699,7 +5036,7 @@ async def delete_folder(folder_id: int) -> str:
             return f"Folder with ID {folder_id} not found (may already be deleted)."
 
         # Delete by passing None as filter
-        await client(functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=None))
+        await cl(functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=None))
 
         return f"Folder '{folder_title}' (ID {folder_id}) deleted. Chats are preserved."
     except Exception as e:
@@ -4712,7 +5049,8 @@ async def delete_folder(folder_id: int) -> str:
         title="Reorder Folders", openWorldHint=True, destructiveHint=True, idempotentHint=True
     )
 )
-async def reorder_folders(folder_ids: List[int]) -> str:
+@with_account(readonly=False)
+async def reorder_folders(folder_ids: List[int], account: str = None) -> str:
     """
     Change the order of folders in the folder list.
 
@@ -4720,8 +5058,9 @@ async def reorder_folders(folder_ids: List[int]) -> str:
         folder_ids: List of folder IDs in the desired order
     """
     try:
+        cl = get_client(account)
         # Get existing folders to validate
-        result = await client(functions.messages.GetDialogFiltersRequest())
+        result = await cl(functions.messages.GetDialogFiltersRequest())
 
         existing_ids = set()
         for f in result.filters:
@@ -4739,7 +5078,7 @@ async def reorder_folders(folder_ids: List[int]) -> str:
             return f"All folder IDs must be included. Missing: {missing}"
 
         # Reorder
-        await client(functions.messages.UpdateDialogFiltersOrderRequest(order=folder_ids))
+        await cl(functions.messages.UpdateDialogFiltersOrderRequest(order=folder_ids))
 
         return f"Folders reordered: {folder_ids}"
     except Exception as e:
@@ -4751,17 +5090,16 @@ async def reorder_folders(folder_ids: List[int]) -> str:
 
 async def _main() -> None:
     try:
-        # Start the Telethon client non-interactively
-        print("Starting Telegram client...", file=sys.stderr)
-        await client.start()
+        labels = ", ".join(clients.keys())
+        print(f"Starting {len(clients)} Telegram client(s) ({labels})...", file=sys.stderr)
+        await asyncio.gather(*(cl.start() for cl in clients.values()))
 
-        # Warm entity cache — StringSession has no persistent cache,
-        # so fetch all dialogs once to populate it
-        print("Warming entity cache...")
-        await client.get_dialogs()
+        # Warm entity caches — StringSession has no persistent cache,
+        # so fetch all dialogs once per client to populate them
+        print("Warming entity caches...", file=sys.stderr)
+        await asyncio.gather(*(cl.get_dialogs() for cl in clients.values()))
 
-        print("Telegram client started. Running MCP server...")
-        # Use the asynchronous entrypoint instead of mcp.run()
+        print(f"Telegram client(s) started ({labels}). Running MCP server...", file=sys.stderr)
         await mcp.run_stdio_async()
     except Exception as e:
         print(f"Error starting client: {e}", file=sys.stderr)
diff --git a/openspec/changes/multi-account-support/.openspec.yaml b/openspec/changes/multi-account-support/.openspec.yaml
new file mode 100644
index 0000000..8fb8631
--- /dev/null
+++ b/openspec/changes/multi-account-support/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-03-31
diff --git a/openspec/changes/multi-account-support/design.md b/openspec/changes/multi-account-support/design.md
new file mode 100644
index 0000000..846d8e9
--- /dev/null
+++ b/openspec/changes/multi-account-support/design.md
@@ -0,0 +1,90 @@
+## Context
+
+The server (`main.py`, ~4800 lines) initializes a single global `TelegramClient` at module level (line 101-106) from environment variables. All 60+ MCP tools reference this global `client` directly. Configuration lives in `.env` with three variables: `TELEGRAM_API_ID`, `TELEGRAM_API_HASH`, and `TELEGRAM_SESSION_STRING` (or `TELEGRAM_SESSION_NAME`).
+
+## Goals / Non-Goals
+
+**Goals:**
+- Support 2+ simultaneous Telegram accounts with user-defined labels
+- Zero breakage for single-account users (config and tool behavior unchanged)
+- Read-only tools fan out to all accounts when `account` is omitted
+- Write tools require explicit account selection
+- Minimal per-tool code changes via a shared decorator
+
+**Non-Goals:**
+- Dynamic account add/remove at runtime (requires server restart)
+- Per-account `API_ID`/`API_HASH` overrides (one Telegram app for all accounts)
+- Account-level permission/access control
+- Merging or deduplicating contacts across accounts
+
+## Decisions
+
+### 1. Client registry as a plain dict
+
+**Decision:** `clients: dict[str, TelegramClient]` at module level, replacing the single `client` global.
+
+**Alternatives considered:**
+- Class-based `AccountManager` with methods — adds indirection with no real benefit; a dict + a few helper functions is simpler.
+- Keep global `client` and add a second one — doesn't scale, creates ad-hoc naming.
+
+**Rationale:** A dict keyed by label is the simplest structure that supports N accounts. Helper function `get_client(account: str) -> TelegramClient` handles lookup and error messaging.
+
+### 2. `@with_account` decorator for tool injection
+
+**Decision:** A decorator that:
+- Adds `account: str = None` to the tool's MCP signature.
+- For `readonly=True` tools: if `account` is None and multi-mode is active, calls the wrapped function once per client, prefixes each result with `[label]`, and concatenates.
+- For `readonly=False` tools: if `account` is None in multi-mode, returns an error asking the LLM to specify an account.
+- In single-mode: always resolves to the sole client, `account` parameter is effectively ignored.
+- Injects resolved `TelegramClient` as the `client` keyword argument.
+
+**Alternatives considered:**
+- Manual edits to each tool without decorator — same effect but 60+ places to get wrong, harder to change behavior later.
+- Context-based injection via MCP Context — Context is already used for file-path security (Roots API); overloading it for client selection is confusing.
+
+**Rationale:** The decorator centralizes the account-resolution logic. Each tool change is mechanical: add decorator, replace bare `client` with `client` parameter.
+
+### 3. Label-suffixed `.env` variables for configuration
+
+**Decision:** Multi-account config via env var suffix convention:
+```
+TELEGRAM_API_ID=123456
+TELEGRAM_API_HASH=abcdef
+TELEGRAM_SESSION_STRING_WORK=...
+TELEGRAM_SESSION_STRING_PERSONAL=...
+```
+
+Detection logic at startup:
+1. Scan env vars matching `TELEGRAM_SESSION_STRING_*` and `TELEGRAM_SESSION_NAME_*`.
+2. If suffixed vars found → multi-mode. Labels extracted from suffixes, lowercased.
+3. If only unsuffixed `TELEGRAM_SESSION_STRING`/`TELEGRAM_SESSION_NAME` found → single-mode, label = `"default"`.
+4. If both suffixed and unsuffixed exist → unsuffixed becomes label `"default"`, combined with suffixed ones into multi-mode.
+5. If nothing found → startup error.
+
+**Alternatives considered:**
+- Separate YAML/JSON config file — requires new dependency or new file format; breaks existing single-account setups.
+- Numbered suffixes (`_1`, `_2`) — requires a separate label variable per account; less self-documenting.
+
+**Rationale:** Stays within `.env` convention. Existing single-account configs work unchanged. Labels are self-documenting. No new files or formats.
+
+### 4. Per-account entity cache warming
+
+**Decision:** At startup, call `await cl.get_dialogs()` for each client in the registry. Entity resolution functions (`resolve_entity`, `resolve_input_entity`) take a `client` parameter instead of using the global.
+
+**Rationale:** StringSession has no persistent entity cache. Each client needs its own warm cache. The existing pattern stays the same, just parameterized.
+
+### 5. Output tagging with `[label]` prefix
+
+**Decision:** When a read-only tool fans out to all accounts, each account's result block is prefixed with `[label]` on its own line, followed by the tool's normal output. In single-mode, no prefix is added.
+
+**Rationale:** Simple, readable by both humans and LLMs. The LLM can parse the label to determine which account context to use for subsequent write operations.
+
+## Risks / Trade-offs
+
+**[Increased startup time]** → Each additional account adds one `client.start()` + `get_dialogs()` call. For 2-3 accounts this is a few seconds. Mitigation: start clients concurrently with `asyncio.gather`.
+
+**[Larger tool signatures]** → Every tool gains an `account` parameter. For single-account users this is invisible (default = None, resolved to sole client). For multi-account users, LLMs handle it naturally via context.
+
+**[Mechanical refactor of 60+ tools]** → High volume of changes but each change is small and formulaic. Risk of missed tools or typos. Mitigation: grep for bare `client.` references after refactor to catch stragglers.
+
+**[Telethon concurrency]** → Multiple TelegramClient instances are independent and safe to run concurrently — each has its own connection and state. No shared-state issues. Fan-out reads use `asyncio.gather` for parallel execution.
diff --git a/openspec/changes/multi-account-support/proposal.md b/openspec/changes/multi-account-support/proposal.md
new file mode 100644
index 0000000..3a6bec2
--- /dev/null
+++ b/openspec/changes/multi-account-support/proposal.md
@@ -0,0 +1,27 @@
+## Why
+
+The Telegram MCP server currently supports only a single Telegram account per server instance. Users who maintain separate work and personal accounts need to interact with both simultaneously throughout the day — reading messages from all accounts at once and replying from the correct one based on context. Running multiple server instances is not viable: tool names collide, and shared contacts across accounts lead to messages sent from the wrong identity.
+
+## What Changes
+
+- **Multi-client registry**: Replace the global singleton `TelegramClient` with a `dict[str, TelegramClient]` keyed by user-defined labels (e.g., `"work"`, `"personal"`).
+- **Account-aware tools**: Add an `account` parameter to all 60+ MCP tools. Read-only tools default to querying all accounts (results concatenated with `[label]` prefix). Write tools require an explicit `account` value.
+- **Backward-compatible configuration**: Extend `.env` to support labeled session strings (`TELEGRAM_SESSION_STRING_WORK`, `TELEGRAM_SESSION_STRING_PERSONAL`) alongside the existing unsuffixed `TELEGRAM_SESSION_STRING` for single-account mode.
+- **Single-account mode preservation**: When only the unsuffixed `TELEGRAM_SESSION_STRING` is present, the server behaves exactly as today — `account` parameter is optional everywhere.
+- **New `list_accounts` tool**: Exposes available accounts with labels and profile info so the LLM can orient itself.
+- **Per-account entity caches**: Each `TelegramClient` maintains its own entity cache, warmed at startup.
+
+## Capabilities
+
+### New Capabilities
+- `multi-account`: Account registry, client lifecycle, configuration parsing, account resolution logic, and the `list_accounts` tool.
+- `account-aware-tools`: Decorator-based account injection into existing tools, including read-only fan-out and write-tool validation.
+
+### Modified Capabilities
+
+## Impact
+
+- **main.py**: All 60+ tool functions gain the `@with_account` decorator and replace direct `client` references with an injected `client` parameter. Startup sequence initializes multiple clients.
+- **Configuration**: `.env` format extended (backward-compatible). `.env.example` updated with multi-account examples.
+- **session_string_generator.py**: May need updates to label generated sessions.
+- **No breaking changes** for single-account users — existing `.env` files and tool call signatures continue to work unchanged.
diff --git a/openspec/changes/multi-account-support/specs/account-aware-tools/spec.md b/openspec/changes/multi-account-support/specs/account-aware-tools/spec.md
new file mode 100644
index 0000000..53a2c69
--- /dev/null
+++ b/openspec/changes/multi-account-support/specs/account-aware-tools/spec.md
@@ -0,0 +1,52 @@
+## ADDED Requirements
+
+### Requirement: with_account decorator injects client into tools
+A `@with_account(readonly=True|False)` decorator SHALL add an `account: str = None` parameter to the MCP tool signature and inject a resolved `TelegramClient` as the `client` keyword argument.
+
+#### Scenario: Read-only tool with explicit account
+- **WHEN** a read-only tool is called with `account="work"`
+- **THEN** the decorator resolves the `"work"` client and passes it as `client` to the tool function
+
+#### Scenario: Write tool with explicit account
+- **WHEN** a write tool is called with `account="personal"`
+- **THEN** the decorator resolves the `"personal"` client and passes it as `client` to the tool function
+
+### Requirement: Read-only tools fan out to all accounts when account is omitted
+In multi-mode, when a read-only tool (`@with_account(readonly=True)`) is called without an `account` parameter, the decorator SHALL execute the tool function once per registered client, prefix each result with `[label]`, and return the concatenated output.
+
+#### Scenario: get_chats without account in multi-mode
+- **WHEN** `get_chats(page=1)` is called without `account` and two accounts exist (`"work"`, `"personal"`)
+- **THEN** the tool executes for both accounts, returning results prefixed with `[work]` and `[personal]`
+
+#### Scenario: Fan-out executes concurrently
+- **WHEN** a read-only tool fans out to multiple accounts
+- **THEN** the calls to each account's client SHALL execute concurrently via `asyncio.gather`
+
+### Requirement: Write tools require explicit account in multi-mode
+In multi-mode, when a write tool (`@with_account(readonly=False)`) is called without an `account` parameter, the decorator SHALL return an error message listing available accounts.
+
+#### Scenario: send_message without account in multi-mode
+- **WHEN** `send_message(chat_id=123, text="hello")` is called without `account` and multiple accounts exist
+- **THEN** an error is returned: account is required, available accounts are listed
+
+### Requirement: Single-mode tools work without account parameter
+In single-mode (one account), all tools SHALL work without the `account` parameter regardless of readonly setting. The sole client is always used.
+
+#### Scenario: Tool call in single-mode without account
+- **WHEN** any tool is called without `account` and only one account (`"default"`) is configured
+- **THEN** the tool executes against the `"default"` client with no error
+
+#### Scenario: Tool call in single-mode with explicit account
+- **WHEN** a tool is called with `account="default"` in single-mode
+- **THEN** the tool executes normally against the sole client
+
+### Requirement: Output tagging in multi-mode fan-out
+When a read-only tool fans out to all accounts, each account's result block SHALL be prefixed with `[label]` on its own line. In single-mode, no prefix SHALL be added.
+
+#### Scenario: Tagged output format
+- **WHEN** a read-only tool returns `"Chat A\nChat B"` for account `"work"` and `"Chat C"` for account `"personal"`
+- **THEN** the combined output is `"[work]\nChat A\nChat B\n\n[personal]\nChat C"`
+
+#### Scenario: No tagging in single-mode
+- **WHEN** a read-only tool fans out in single-mode (one account)
+- **THEN** the output is returned without any `[label]` prefix
diff --git a/openspec/changes/multi-account-support/specs/multi-account/spec.md b/openspec/changes/multi-account-support/specs/multi-account/spec.md
new file mode 100644
index 0000000..2bad2e0
--- /dev/null
+++ b/openspec/changes/multi-account-support/specs/multi-account/spec.md
@@ -0,0 +1,56 @@
+## ADDED Requirements
+
+### Requirement: Configuration parsing supports labeled accounts
+The server SHALL parse `.env` variables matching `TELEGRAM_SESSION_STRING_<LABEL>` and `TELEGRAM_SESSION_NAME_<LABEL>` to discover multiple accounts. Labels SHALL be extracted from the suffix and lowercased. A shared `TELEGRAM_API_ID` and `TELEGRAM_API_HASH` SHALL be used for all accounts.
+
+#### Scenario: Multi-account config with two labeled sessions
+- **WHEN** `.env` contains `TELEGRAM_SESSION_STRING_WORK=...` and `TELEGRAM_SESSION_STRING_PERSONAL=...` along with shared `TELEGRAM_API_ID` and `TELEGRAM_API_HASH`
+- **THEN** the server starts in multi-mode with two clients labeled `"work"` and `"personal"`
+
+#### Scenario: Single-account backward compatibility
+- **WHEN** `.env` contains only unsuffixed `TELEGRAM_SESSION_STRING` (no suffixed variants)
+- **THEN** the server starts in single-mode with one client labeled `"default"` and all tools work without requiring the `account` parameter
+
+#### Scenario: Mixed suffixed and unsuffixed sessions
+- **WHEN** `.env` contains both unsuffixed `TELEGRAM_SESSION_STRING` and suffixed `TELEGRAM_SESSION_STRING_WORK`
+- **THEN** the server starts in multi-mode with the unsuffixed session labeled `"default"` and the suffixed session labeled `"work"`
+
+#### Scenario: No session configured
+- **WHEN** `.env` contains no `TELEGRAM_SESSION_STRING` or `TELEGRAM_SESSION_NAME` variables (suffixed or unsuffixed)
+- **THEN** the server SHALL exit with a configuration error message
+
+### Requirement: Client registry manages multiple TelegramClient instances
+The server SHALL maintain a `clients: dict[str, TelegramClient]` registry mapping account labels to authenticated `TelegramClient` instances. A `get_client(account: str) -> TelegramClient` function SHALL provide lookup with a clear error if the label is unknown.
+
+#### Scenario: Lookup existing account
+- **WHEN** `get_client("work")` is called and a client with label `"work"` exists
+- **THEN** the corresponding `TelegramClient` instance is returned
+
+#### Scenario: Lookup unknown account
+- **WHEN** `get_client("nonexistent")` is called
+- **THEN** an error is returned listing available account labels
+
+### Requirement: All clients are started and cache-warmed at startup
+The server SHALL call `client.start()` and `client.get_dialogs()` for every client in the registry during startup. Startup of multiple clients SHALL be concurrent via `asyncio.gather`.
+
+#### Scenario: Startup with two accounts
+- **WHEN** the server starts with accounts `"work"` and `"personal"` configured
+- **THEN** both clients are authenticated and their entity caches are warmed before the MCP server begins accepting requests
+
+### Requirement: list_accounts tool exposes available accounts
+The server SHALL provide a `list_accounts` MCP tool that returns all configured account labels with profile information (name, phone number, online status) for each.
+
+#### Scenario: List accounts in multi-mode
+- **WHEN** `list_accounts()` is called with two configured accounts
+- **THEN** the response includes each account's label, display name, phone number, and online status
+
+#### Scenario: List accounts in single-mode
+- **WHEN** `list_accounts()` is called in single-mode
+- **THEN** the response includes one account with label `"default"` and its profile information
+
+### Requirement: Entity resolution is per-client
+The `resolve_entity` and `resolve_input_entity` functions SHALL accept a `client` parameter instead of using a global. Each client's entity cache is independent.
+
+#### Scenario: Resolve entity for specific account
+- **WHEN** `resolve_entity(identifier, client=work_client)` is called
+- **THEN** entity resolution uses the `work_client`'s cache, falling back to `work_client.get_dialogs()` on cache miss
diff --git a/openspec/changes/multi-account-support/tasks.md b/openspec/changes/multi-account-support/tasks.md
new file mode 100644
index 0000000..1ac2d7b
--- /dev/null
+++ b/openspec/changes/multi-account-support/tasks.md
@@ -0,0 +1,54 @@
+## 1. Configuration & Client Registry
+
+- [x] 1.1 Replace global client initialization (lines 90-106) with config parsing logic: scan env vars for `TELEGRAM_SESSION_STRING_<LABEL>` / `TELEGRAM_SESSION_NAME_<LABEL>` suffixes, detect single vs multi mode
+- [x] 1.2 Create `clients: dict[str, TelegramClient]` registry and `get_client(account)` lookup function with error listing available labels
+- [x] 1.3 Implement `is_multi_mode()` helper that returns True when more than one account is configured
+- [x] 1.4 Update `_main()` startup (lines 4752-4783) to initialize and cache-warm all clients concurrently via `asyncio.gather`
+
+## 2. Decorator & Account Resolution
+
+- [x] 2.1 Implement `@with_account(readonly=True|False)` decorator: adds `account` param, resolves client, injects as `client` kwarg
+- [x] 2.2 Implement read-only fan-out logic in decorator: call tool for all accounts concurrently, prefix results with `[label]`, concatenate
+- [x] 2.3 Implement write-tool guard in decorator: error with available accounts list when `account` is omitted in multi-mode
+- [x] 2.4 Implement single-mode passthrough: ignore `account` param, always use sole client, no output tagging
+
+## 3. Parameterize Shared Helpers
+
+- [x] 3.1 Update `resolve_entity()` and `resolve_input_entity()` (lines 344-365) to accept a `client` parameter
+- [x] 3.2 Audit and update any other helper functions that reference the global `client` directly
+
+## 4. Migrate Tools — Read-only
+
+- [x] 4.1 Add `@with_account(readonly=True)` and replace `client` with param in read-only chat tools: `get_chats`, `list_chats`, `get_chat`, `get_participants`, `get_admins`, `get_banned_users`, `get_invite_link`
+- [x] 4.2 Add decorator to read-only message tools: `get_messages`, `list_messages`, `get_message_context`, `get_history`, `get_pinned_messages`, `search_messages`, `search_global`, `list_inline_buttons`, `get_message_reactions`, `get_last_interaction`, `list_topics`
+- [x] 4.3 Add decorator to read-only contact tools: `list_contacts`, `search_contacts`, `get_contact_ids`, `get_blocked_users`, `get_direct_chat_by_contact`, `get_contact_chats`
+- [x] 4.4 Add decorator to read-only profile/user tools: `get_me`, `get_user_photos`, `get_user_status`
+- [x] 4.5 Add decorator to read-only media tools: `get_media_info`
+- [x] 4.6 Add decorator to read-only discovery tools: `search_public_chats`, `resolve_username`
+- [x] 4.7 Add decorator to read-only drafts/folders/stickers/bot tools: `get_drafts`, `list_folders`, `get_folder`, `get_sticker_sets`, `get_bot_info`
+- [x] 4.8 Add decorator to any remaining read-only tools (`readOnlyHint=True` or equivalent)
+
+## 5. Migrate Tools — Write / Destructive
+
+- [x] 5.1 Add `@with_account(readonly=False)` to messaging write tools: `send_message`, `reply_to_message`, `edit_message`, `delete_message`, `forward_message`, `pin_message`, `unpin_message`, `mark_as_read`, `press_inline_button`, `create_poll`, `send_reaction`, `remove_reaction`
+- [x] 5.2 Add decorator to chat management write tools: `create_group`, `create_channel`, `invite_to_group`, `leave_chat`, `edit_chat_title`, `delete_chat_photo`, `edit_chat_photo`, `mute_chat`, `unmute_chat`, `archive_chat`, `unarchive_chat`, `export_chat_invite`
+- [x] 5.3 Add decorator to contact write tools: `add_contact`, `delete_contact`, `block_user`, `unblock_user`, `import_contacts`, `export_contacts`
+- [x] 5.4 Add decorator to profile write tools: `update_profile`, `set_profile_photo`, `delete_profile_photo`
+- [x] 5.5 Add decorator to admin/permission write tools: `promote_admin`, `demote_admin`, `ban_user`, `unban_user`, `set_privacy_settings`, `get_privacy_settings`
+- [x] 5.6 Add decorator to media write tools: `send_file`, `download_media`, `upload_file`, `send_voice`, `send_sticker`, `send_gif`
+- [x] 5.7 Add decorator to discovery write tools: `subscribe_public_channel`, `import_chat_invite`, `join_chat_by_link`
+- [x] 5.8 Add decorator to drafts/folders write tools: `save_draft`, `clear_draft`, `create_folder`, `edit_folder`, `delete_folder`, `reorder_folders`
+- [x] 5.9 Add decorator to bot write tools: `set_bot_commands`
+- [x] 5.10 Add decorator to any remaining write tools
+
+## 6. New Tool & Config Files
+
+- [x] 6.1 Implement `list_accounts` tool returning label, display name, phone, and online status for each account
+- [x] 6.2 Update `.env.example` with multi-account configuration examples
+- [x] 6.3 Update `session_string_generator.py` to prompt for an optional label and output the labeled env var name
+
+## 7. Validation & Cleanup
+
+- [x] 7.1 Grep for any remaining bare `client.` references (outside the registry/decorator code) and fix them
+- [x] 7.2 Test single-mode: verify existing `.env` with one account works identically to before
+- [ ] 7.3 Test multi-mode: verify two accounts, read-only fan-out, write-tool account requirement, `list_accounts`
diff --git a/openspec/config.yaml b/openspec/config.yaml
new file mode 100644
index 0000000..392946c
--- /dev/null
+++ b/openspec/config.yaml
@@ -0,0 +1,20 @@
+schema: spec-driven
+
+# Project context (optional)
+# This is shown to AI when creating artifacts.
+# Add your tech stack, conventions, style guides, domain knowledge, etc.
+# Example:
+#   context: |
+#     Tech stack: TypeScript, React, Node.js
+#     We use conventional commits
+#     Domain: e-commerce platform
+
+# Per-artifact rules (optional)
+# Add custom rules for specific artifacts.
+# Example:
+#   rules:
+#     proposal:
+#       - Keep proposals under 500 words
+#       - Always include a "Non-goals" section
+#     tasks:
+#       - Break tasks into chunks of max 2 hours
diff --git a/session_string_generator.py b/session_string_generator.py
index 5a06d3b..cb0ef60 100755
--- a/session_string_generator.py
+++ b/session_string_generator.py
@@ -111,7 +111,11 @@ def main() -> None:
         "\nYour credentials will NOT be stored on any server and are only used for local authentication.\n"
     )
 
-    print("Choose login method:")
+    label = input(
+        "Account label (optional, e.g. 'work', 'personal'; leave empty for default): "
+    ).strip().lower()
+
+    print("\nChoose login method:")
     print("  1) QR code login (recommended -- scan from your Telegram app)")
     print("  2) Phone number + verification code")
     method = input("\nEnter 1 or 2 [default: 1]: ").strip() or "1"
@@ -128,11 +132,16 @@ def main() -> None:
 
         session_string = StringSession.save(client.session)
 
+        if label:
+            env_var = f"TELEGRAM_SESSION_STRING_{label.upper()}"
+        else:
+            env_var = "TELEGRAM_SESSION_STRING"
+
         print("\nAuthentication successful!")
         print("\n----- Your Session String -----")
         print(f"\n{session_string}\n")
         print("Add this to your .env file as:")
-        print(f"TELEGRAM_SESSION_STRING={session_string}")
+        print(f"{env_var}={session_string}")
         print("\nIMPORTANT: Keep this string private and never share it with anyone!")
 
         choice = input(
@@ -145,13 +154,13 @@ def main() -> None:
 
                 session_string_line_found = False
                 for i, line in enumerate(env_contents):
-                    if line.startswith("TELEGRAM_SESSION_STRING="):
-                        env_contents[i] = f"TELEGRAM_SESSION_STRING={session_string}\n"
+                    if line.startswith(f"{env_var}="):
+                        env_contents[i] = f"{env_var}={session_string}\n"
                         session_string_line_found = True
                         break
 
                 if not session_string_line_found:
-                    env_contents.append(f"TELEGRAM_SESSION_STRING={session_string}\n")
+                    env_contents.append(f"{env_var}={session_string}\n")
 
                 with open(".env", "w") as file:
                     file.writelines(env_contents)

From eff8f2c96936dce3f39c9d9ab2dbc9f8f8a597c9 Mon Sep 17 00:00:00 2001
From: Daniil Svetlov <svetlov@bpcbt.com>
Date: Thu, 2 Apr 2026 01:00:47 +0300
Subject: [PATCH 2/5] docs: update README for multi-account support

- Add multi-account configuration section (.env with label suffixes)
- Add Multi-Account section to features list
- Update code examples to show @with_account decorator and get_client()
- Add multi-account usage examples
- Update Docker run instructions for multi-account env vars
- Mention session generator label prompt

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 README.md | 225 +++++++++++++++++++-----------------------------------
 1 file changed, 77 insertions(+), 148 deletions(-)

diff --git a/README.md b/README.md
index d64d18c..15c8111 100644
--- a/README.md
+++ b/README.md
@@ -140,6 +140,14 @@ This MCP server exposes a huge suite of Telegram tools. **Every major Telegram/T
 - **get_drafts()**: Get all draft messages across all chats
 - **clear_draft(chat_id)**: Clear/delete a draft from a specific chat
 
+### Multi-Account
+- **list_accounts()**: List all configured accounts with profile info
+
+All tools accept an optional `account` parameter to target a specific account. In multi-account mode:
+- **Read-only tools** (e.g., `get_chats`, `list_messages`) query all accounts when `account` is omitted, returning results prefixed with `[label]`.
+- **Write tools** (e.g., `send_message`, `mark_as_read`) require an explicit `account` value.
+- **Single-account setups** work exactly as before — the `account` parameter is optional everywhere.
+
 ### Input Validation
 
 To improve robustness, all functions accepting `chat_id` or `user_id` parameters now include input validation. You can use any of the following formats for these IDs:
@@ -203,18 +211,29 @@ uv sync
 ```bash
 uv run session_string_generator.py
 ```
-Follow the prompts to authenticate and update your `.env` file.
+Follow the prompts to authenticate. You'll be asked for an optional account label (e.g., `work`, `personal`) — leave empty for a single-account setup.
 
 ### 4. Configure .env
 
-Copy `.env.example` to `.env` and fill in your values:
+Copy `.env.example` to `.env` and fill in your values.
 
+**Single account:**
 ```
 TELEGRAM_API_ID=your_api_id_here
 TELEGRAM_API_HASH=your_api_hash_here
-TELEGRAM_SESSION_NAME=anon
 TELEGRAM_SESSION_STRING=your_session_string_here
 ```
+
+**Multiple accounts:**
+```
+TELEGRAM_API_ID=your_api_id_here
+TELEGRAM_API_HASH=your_api_hash_here
+TELEGRAM_SESSION_STRING_WORK=session_string_for_work_account
+TELEGRAM_SESSION_STRING_PERSONAL=session_string_for_personal_account
+```
+
+Add `_<LABEL>` suffix to `TELEGRAM_SESSION_STRING` for each account. Labels become account identifiers used in tool calls. A shared `TELEGRAM_API_ID` and `TELEGRAM_API_HASH` are used for all accounts.
+
 Get your API credentials at [my.telegram.org/apps](https://my.telegram.org/apps).
 
 ---
@@ -259,6 +278,7 @@ docker run -it --rm \
   telegram-mcp:latest
 ```
 *   Replace placeholders with your actual credentials.
+*   For multiple accounts, use `-e TELEGRAM_SESSION_STRING_WORK="..."` `-e TELEGRAM_SESSION_STRING_PERSONAL="..."` instead.
 *   Use `-e TELEGRAM_SESSION_NAME=your_session_file_name` instead of `TELEGRAM_SESSION_STRING` if you prefer file-based sessions (requires volume mounting, see `docker-compose.yml` for an example).
 *   The `-it` flags are crucial for interacting with the server.
 
@@ -293,37 +313,29 @@ Below are examples of the most commonly used tools with their implementation and
 
 ```python
 @mcp.tool()
-async def get_chats(page: int = 1, page_size: int = 20) -> str:
+@with_account(readonly=True)
+async def get_chats(account: str = None, page: int = 1, page_size: int = 20) -> str:
     """
     Get a paginated list of chats.
     Args:
+        account: Account label (optional in single-account mode).
         page: Page number (1-indexed).
         page_size: Number of chats per page.
     """
     try:
-        dialogs = await client.get_dialogs()
-        start = (page - 1) * page_size
-        end = start + page_size
-        if start >= len(dialogs):
-            return "Page out of range."
-        chats = dialogs[start:end]
-        lines = []
-        for dialog in chats:
-            entity = dialog.entity
-            chat_id = entity.id
-            title = getattr(entity, "title", None) or getattr(entity, "first_name", "Unknown")
-            lines.append(f"Chat ID: {chat_id}, Title: {title}")
-        return "\n".join(lines)
-    except Exception as e:
-        logger.exception(f"get_chats failed (page={page}, page_size={page_size})")
-        return "An error occurred (code: GETCHATS-ERR-001). Check mcp_errors.log for details."
+        cl = get_client(account)
+        dialogs = await cl.get_dialogs()
+        ...
 ```
 
-Example output:
+Example output (multi-account, no `account` specified):
 ```
-Chat ID: 123456789, Title: John Doe
+[work]
 Chat ID: -100987654321, Title: My Project Group
 Chat ID: 111223344, Title: Jane Smith
+
+[personal]
+Chat ID: 123456789, Title: John Doe
 Chat ID: -200123456789, Title: News Channel
 ```
 
@@ -331,20 +343,21 @@ Chat ID: -200123456789, Title: News Channel
 
 ```python
 @mcp.tool()
-async def send_message(chat_id: int, message: str) -> str:
+@with_account(readonly=False)
+async def send_message(chat_id: Union[int, str], message: str, account: str = None) -> str:
     """
     Send a message to a specific chat.
     Args:
         chat_id: The ID of the chat.
         message: The message content to send.
+        account: Account label (required in multi-account mode).
     """
     try:
-        entity = await client.get_entity(chat_id)
-        await client.send_message(entity, message)
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        await cl.send_message(entity, message)
         return "Message sent successfully."
-    except Exception as e:
-        logger.exception(f"send_message failed (chat_id={chat_id})")
-        return "An error occurred (code: SENDMSG-ERR-001). Check mcp_errors.log for details."
+    ...
 ```
 
 Example output:
@@ -356,10 +369,12 @@ Message sent successfully.
 
 ```python
 @mcp.tool()
+@with_account(readonly=True)
 async def list_inline_buttons(
     chat_id: Union[int, str],
     message_id: Optional[int] = None,
     limit: int = 20,
+    account: str = None,
 ) -> str:
     """
     Discover inline keyboard layout, including button indices, callback availability, and URLs.
@@ -383,11 +398,13 @@ Buttons for message 42 (date 2025-01-01 12:00:00+00:00):
 
 ```python
 @mcp.tool()
+@with_account(readonly=False)
 async def press_inline_button(
     chat_id: Union[int, str],
     message_id: Optional[int] = None,
     button_text: Optional[str] = None,
     button_index: Optional[int] = None,
+    account: str = None,
 ) -> str:
     """
     Press an inline keyboard button by label or zero-based index.
@@ -408,7 +425,8 @@ to quickly list options or call `list_inline_buttons` directly. Once you know th
 
 ```python
 @mcp.tool()
-async def subscribe_public_channel(channel: Union[int, str]) -> str:
+@with_account(readonly=False)
+async def subscribe_public_channel(channel: Union[int, str], account: str = None) -> str:
     """
     Join a public channel or supergroup by username (e.g., "@examplechannel") or ID.
     """
@@ -428,49 +446,17 @@ The `get_invite_link` function is particularly robust with multiple fallback met
 
 ```python
 @mcp.tool()
-async def get_invite_link(chat_id: int) -> str:
+@with_account(readonly=True)
+async def get_invite_link(chat_id: int, account: str = None) -> str:
     """
     Get the invite link for a group or channel.
     """
     try:
-        entity = await client.get_entity(chat_id)
-        
-        # Try using ExportChatInviteRequest first
-        try:
-            from telethon.tl import functions
-            result = await client(functions.messages.ExportChatInviteRequest(
-                peer=entity
-            ))
-            return result.link
-        except AttributeError:
-            # If the function doesn't exist in the current Telethon version
-            logger.warning("ExportChatInviteRequest not available, using alternative method")
-        except Exception as e1:
-            # If that fails, log and try alternative approach
-            logger.warning(f"ExportChatInviteRequest failed: {e1}")
-            
-        # Alternative approach using client.export_chat_invite_link
-        try:
-            invite_link = await client.export_chat_invite_link(entity)
-            return invite_link
-        except Exception as e2:
-            logger.warning(f"export_chat_invite_link failed: {e2}")
-            
-        # Last resort: Try directly fetching chat info
-        try:
-            if isinstance(entity, (Chat, Channel)):
-                full_chat = await client(functions.messages.GetFullChatRequest(
-                    chat_id=entity.id
-                ))
-                if hasattr(full_chat, 'full_chat') and hasattr(full_chat.full_chat, 'invite_link'):
-                    return full_chat.full_chat.invite_link or "No invite link available."
-        except Exception as e3:
-            logger.warning(f"GetFullChatRequest failed: {e3}")
-            
-        return "Could not retrieve invite link for this chat."
-    except Exception as e:
-        logger.exception(f"get_invite_link failed (chat_id={chat_id})")
-        return f"Error getting invite link: {e}"
+        cl = get_client(account)
+        entity = await resolve_entity(chat_id, cl)
+        # Tries ExportChatInviteRequest, then export_chat_invite_link,
+        # then GetFullChatRequest as fallbacks
+        ...
 ```
 
 Example output:
@@ -482,47 +468,15 @@ https://t.me/+AbCdEfGhIjKlMnOp
 
 ```python
 @mcp.tool()
-async def join_chat_by_link(link: str) -> str:
+@with_account(readonly=False)
+async def join_chat_by_link(link: str, account: str = None) -> str:
     """
     Join a chat by invite link.
     """
     try:
-        # Extract the hash from the invite link
-        if '/' in link:
-            hash_part = link.split('/')[-1]
-            if hash_part.startswith('+'):
-                hash_part = hash_part[1:]  # Remove the '+' if present
-        else:
-            hash_part = link
-            
-        # Try checking the invite before joining
-        try:
-            # Try to check invite info first (will often fail if not a member)
-            invite_info = await client(functions.messages.CheckChatInviteRequest(hash=hash_part))
-            if hasattr(invite_info, 'chat') and invite_info.chat:
-                # If we got chat info, we're already a member
-                chat_title = getattr(invite_info.chat, 'title', 'Unknown Chat')
-                return f"You are already a member of this chat: {chat_title}"
-        except Exception:
-            # This often fails if not a member - just continue
-            pass
-            
-        # Join the chat using the hash
-        result = await client(functions.messages.ImportChatInviteRequest(hash=hash_part))
-        if result and hasattr(result, 'chats') and result.chats:
-            chat_title = getattr(result.chats[0], 'title', 'Unknown Chat')
-            return f"Successfully joined chat: {chat_title}"
-        return f"Joined chat via invite hash."
-    except Exception as e:
-        err_str = str(e).lower()
-        if "expired" in err_str:
-            return "The invite hash has expired and is no longer valid."
-        elif "invalid" in err_str:
-            return "The invite hash is invalid or malformed."
-        elif "already" in err_str and "participant" in err_str:
-            return "You are already a member of this chat."
-        logger.exception(f"join_chat_by_link failed (link={link})")
-        return f"Error joining chat: {e}"
+        cl = get_client(account)
+        # Extracts hash, checks membership, and joins via ImportChatInviteRequest
+        ...
 ```
 
 Example output:
@@ -534,16 +488,17 @@ Successfully joined chat: Developer Community
 
 ```python
 @mcp.tool()
-async def search_public_chats(query: str, limit: int = 20) -> str:
+@with_account(readonly=True)
+async def search_public_chats(query: str, limit: int = 20, account: str = None) -> str:
     """
     Search for public chats, channels, or bots by username or title.
     """
     try:
-        result = await client(functions.contacts.SearchRequest(q=query, limit=limit))
+        cl = get_client(account)
+        result = await cl(functions.contacts.SearchRequest(q=query, limit=limit))
         entities = [format_entity(e) for e in result.chats + result.users]
         return json.dumps(entities, indent=2)
-    except Exception as e:
-        return f"Error searching public chats: {e}"
+    ...
 ```
 
 Example output:
@@ -568,51 +523,19 @@ Example output:
 
 ```python
 @mcp.tool()
-async def get_direct_chat_by_contact(contact_query: str) -> str:
+@with_account(readonly=True)
+async def get_direct_chat_by_contact(contact_query: str, account: str = None) -> str:
     """
     Find a direct chat with a specific contact by name, username, or phone.
-    
+
     Args:
         contact_query: Name, username, or phone number to search for.
     """
     try:
-        # Fetch all contacts using the correct Telethon method
-        result = await client(functions.contacts.GetContactsRequest(hash=0))
-        contacts = result.users
-        found_contacts = []
-        for contact in contacts:
-            if not contact:
-                continue
-            name = f"{getattr(contact, 'first_name', '')} {getattr(contact, 'last_name', '')}".strip()
-            username = getattr(contact, 'username', '')
-            phone = getattr(contact, 'phone', '')
-            if (contact_query.lower() in name.lower() or 
-                (username and contact_query.lower() in username.lower()) or 
-                (phone and contact_query in phone)):
-                found_contacts.append(contact)
-        if not found_contacts:
-            return f"No contacts found matching '{contact_query}'."
-        # If we found contacts, look for direct chats with them
-        results = []
-        dialogs = await client.get_dialogs()
-        for contact in found_contacts:
-            contact_name = f"{getattr(contact, 'first_name', '')} {getattr(contact, 'last_name', '')}".strip()
-            for dialog in dialogs:
-                if isinstance(dialog.entity, User) and dialog.entity.id == contact.id:
-                    chat_info = f"Chat ID: {dialog.entity.id}, Contact: {contact_name}"
-                    if getattr(contact, 'username', ''):
-                        chat_info += f", Username: @{contact.username}"
-                    if dialog.unread_count:
-                        chat_info += f", Unread: {dialog.unread_count}"
-                    results.append(chat_info)
-                    break
-        
-        if not results:
-            return f"Found contacts matching '{contact_query}', but no direct chats with them."
-        
-        return "\n".join(results)
-    except Exception as e:
-        return f"Error searching for direct chat: {e}"
+        cl = get_client(account)
+        result = await cl(functions.contacts.GetContactsRequest(hash=0))
+        # Searches contacts, then matches against dialogs
+        ...
 ```
 
 Example output:
@@ -636,6 +559,11 @@ Chat ID: 123456789, Contact: John Smith, Username: @johnsmith, Unread: 3
 - "Send a sticker to my Saved Messages"
 - "Get all my sticker sets"
 
+**Multi-account examples:**
+- "Show unread messages from all accounts"
+- "Reply to John from my work account: see you at 3pm"
+- "List my accounts"
+
 You can use these tools via natural language in Claude, Cursor, or any MCP-compatible client.
 
 ---
@@ -644,6 +572,7 @@ You can use these tools via natural language in Claude, Cursor, or any MCP-compa
 
 This implementation includes comprehensive error handling:
 
+- **Multi-account support**: Run multiple Telegram accounts simultaneously with label-based configuration
 - **Session management**: Works with both file-based and string-based sessions
 - **Error reporting**: Detailed errors logged to `mcp_errors.log`
 - **Graceful degradation**: Multiple fallback approaches for critical functions

From 5080759da6647904f8a2367c064392dab7601833 Mon Sep 17 00:00:00 2001
From: Daniil Svetlov <svetlov@bpcbt.com>
Date: Thu, 2 Apr 2026 02:09:38 +0300
Subject: [PATCH 3/5] style: format with black

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 main.py                     | 110 ++++++++++++++++++++++--------------
 session_string_generator.py |   8 ++-
 2 files changed, 72 insertions(+), 46 deletions(-)

diff --git a/main.py b/main.py
index e3f7fda..e0acd36 100644
--- a/main.py
+++ b/main.py
@@ -153,9 +153,7 @@ def get_client(account: str = None) -> TelegramClient:
     if account is None:
         if len(clients) == 1:
             return next(iter(clients.values()))
-        raise ValueError(
-            f"Account is required. Available accounts: {', '.join(clients.keys())}"
-        )
+        raise ValueError(f"Account is required. Available accounts: {', '.join(clients.keys())}")
     label = account.lower()
     if label not in clients:
         raise ValueError(
@@ -845,7 +843,9 @@ async def get_chats(account: str = None, page: int = 1, page_size: int = 20) ->
 @mcp.tool(annotations=ToolAnnotations(title="Get Messages", openWorldHint=True, readOnlyHint=True))
 @with_account(readonly=True)
 @validate_id("chat_id")
-async def get_messages(chat_id: Union[int, str], page: int = 1, page_size: int = 20, account: str = None) -> str:
+async def get_messages(
+    chat_id: Union[int, str], page: int = 1, page_size: int = 20, account: str = None
+) -> str:
     """
     Get paginated messages from a specific chat.
     Args:
@@ -885,7 +885,9 @@ async def get_messages(chat_id: Union[int, str], page: int = 1, page_size: int =
 @with_account(readonly=False)
 @validate_id("chat_id")
 async def send_message(
-    chat_id: Union[int, str], message: str, parse_mode: Optional[str] = None,
+    chat_id: Union[int, str],
+    message: str,
+    parse_mode: Optional[str] = None,
     account: str = None,
 ) -> str:
     """
@@ -941,7 +943,9 @@ async def subscribe_public_channel(channel: Union[int, str], account: str = None
 @with_account(readonly=True)
 @validate_id("chat_id")
 async def list_inline_buttons(
-    chat_id: Union[int, str], message_id: Optional[Union[int, str]] = None, limit: int = 20,
+    chat_id: Union[int, str],
+    message_id: Optional[Union[int, str]] = None,
+    limit: int = 20,
     account: str = None,
 ) -> str:
     """
@@ -1430,7 +1434,10 @@ async def list_topics(
 @with_account(readonly=True)
 async def list_chats(
     account: str = None,
-    chat_type: str = None, limit: int = 20, unread_only: bool = False, unmuted_only: bool = False
+    chat_type: str = None,
+    limit: int = 20,
+    unread_only: bool = False,
+    unmuted_only: bool = False,
 ) -> str:
     """
     List available chats with metadata.
@@ -1769,7 +1776,9 @@ async def get_last_interaction(contact_id: Union[int, str], account: str = None)
 @with_account(readonly=True)
 @validate_id("chat_id")
 async def get_message_context(
-    chat_id: Union[int, str], message_id: int, context_size: int = 3,
+    chat_id: Union[int, str],
+    message_id: int,
+    context_size: int = 3,
     account: str = None,
 ) -> str:
     """
@@ -2121,7 +2130,9 @@ async def create_group(title: str, user_ids: List[Union[int, str]], account: str
 )
 @with_account(readonly=False)
 @validate_id("group_id", "user_ids")
-async def invite_to_group(group_id: Union[int, str], user_ids: List[Union[int, str]], account: str = None) -> str:
+async def invite_to_group(
+    group_id: Union[int, str], user_ids: List[Union[int, str]], account: str = None
+) -> str:
     """
     Invite users to a group or channel.
 
@@ -2385,7 +2396,9 @@ async def download_media(
     )
 )
 @with_account(readonly=False)
-async def update_profile(account: str = None, first_name: str = None, last_name: str = None, about: str = None) -> str:
+async def update_profile(
+    account: str = None, first_name: str = None, last_name: str = None, about: str = None
+) -> str:
     """
     Update your profile information (name, bio).
     """
@@ -2409,7 +2422,9 @@ async def update_profile(account: str = None, first_name: str = None, last_name:
     )
 )
 @with_account(readonly=False)
-async def set_profile_photo(file_path: str, ctx: Optional[Context] = None, account: str = None) -> str:
+async def set_profile_photo(
+    file_path: str, ctx: Optional[Context] = None, account: str = None
+) -> str:
     """
     Set a new profile photo.
     """
@@ -2423,9 +2438,7 @@ async def set_profile_photo(file_path: str, ctx: Optional[Context] = None, accou
         if path_error:
             return path_error
         await cl(
-            functions.photos.UploadProfilePhotoRequest(
-                file=await cl.upload_file(str(safe_path))
-            )
+            functions.photos.UploadProfilePhotoRequest(file=await cl.upload_file(str(safe_path)))
         )
         return f"Profile photo updated from {safe_path}."
     except Exception as e:
@@ -2575,9 +2588,7 @@ async def set_privacy_settings(
 
         # Apply the privacy settings
         try:
-            result = await cl(
-                functions.account.SetPrivacyRequest(key=privacy_key, rules=rules)
-            )
+            result = await cl(functions.account.SetPrivacyRequest(key=privacy_key, rules=rules))
             return f"Privacy settings for {key} updated successfully."
         except TypeError as type_err:
             if "TLObject was expected" in str(type_err):
@@ -2651,7 +2662,9 @@ async def get_blocked_users(account: str = None) -> str:
     annotations=ToolAnnotations(title="Create Channel", openWorldHint=True, destructiveHint=True)
 )
 @with_account(readonly=False)
-async def create_channel(title: str, about: str = "", megagroup: bool = False, account: str = None) -> str:
+async def create_channel(
+    title: str, about: str = "", megagroup: bool = False, account: str = None
+) -> str:
     """
     Create a new channel or supergroup.
     """
@@ -2729,9 +2742,7 @@ async def edit_chat_photo(
         elif isinstance(entity, Chat):
             # For basic groups, use EditChatPhotoRequest with InputChatUploadedPhoto
             input_photo = InputChatUploadedPhoto(file=uploaded_file)
-            await cl(
-                functions.messages.EditChatPhotoRequest(chat_id=chat_id, photo=input_photo)
-            )
+            await cl(functions.messages.EditChatPhotoRequest(chat_id=chat_id, photo=input_photo))
         else:
             return f"Cannot edit photo for this entity type ({type(entity)})."
 
@@ -2784,7 +2795,9 @@ async def delete_chat_photo(chat_id: Union[int, str], account: str = None) -> st
 @with_account(readonly=False)
 @validate_id("group_id", "user_id")
 async def promote_admin(
-    group_id: Union[int, str], user_id: Union[int, str], rights: dict = None,
+    group_id: Union[int, str],
+    user_id: Union[int, str],
+    rights: dict = None,
     account: str = None,
 ) -> str:
     """
@@ -2857,7 +2870,9 @@ async def promote_admin(
 )
 @with_account(readonly=False)
 @validate_id("group_id", "user_id")
-async def demote_admin(group_id: Union[int, str], user_id: Union[int, str], account: str = None) -> str:
+async def demote_admin(
+    group_id: Union[int, str], user_id: Union[int, str], account: str = None
+) -> str:
     """
     Demote a user from admin in a group/channel.
 
@@ -2965,7 +2980,9 @@ async def ban_user(chat_id: Union[int, str], user_id: Union[int, str], account:
 )
 @with_account(readonly=False)
 @validate_id("chat_id", "user_id")
-async def unban_user(chat_id: Union[int, str], user_id: Union[int, str], account: str = None) -> str:
+async def unban_user(
+    chat_id: Union[int, str], user_id: Union[int, str], account: str = None
+) -> str:
     """
     Unban a user from a group or channel.
 
@@ -3044,9 +3061,7 @@ async def get_banned_users(chat_id: Union[int, str], account: str = None) -> str
     try:
         cl = get_client(account)
         # Fix: Use the correct filter type ChannelParticipantsKicked
-        participants = await cl.get_participants(
-            chat_id, filter=ChannelParticipantsKicked(q="")
-        )
+        participants = await cl.get_participants(chat_id, filter=ChannelParticipantsKicked(q=""))
         lines = [
             f"ID: {p.id}, Name: {getattr(p, 'first_name', '')} {getattr(p, 'last_name', '')}".strip()
             for p in participants
@@ -3342,7 +3357,9 @@ async def upload_file(file_path: str, ctx: Optional[Context] = None, account: st
 @with_account(readonly=False)
 @validate_id("from_chat_id", "to_chat_id")
 async def forward_message(
-    from_chat_id: Union[int, str], message_id: int, to_chat_id: Union[int, str],
+    from_chat_id: Union[int, str],
+    message_id: int,
+    to_chat_id: Union[int, str],
     account: str = None,
 ) -> str:
     """
@@ -3371,7 +3388,9 @@ async def forward_message(
 )
 @with_account(readonly=False)
 @validate_id("chat_id")
-async def edit_message(chat_id: Union[int, str], message_id: int, new_text: str, account: str = None) -> str:
+async def edit_message(
+    chat_id: Union[int, str], message_id: int, new_text: str, account: str = None
+) -> str:
     """
     Edit a message you sent.
     """
@@ -3472,7 +3491,10 @@ async def mark_as_read(chat_id: Union[int, str], account: str = None) -> str:
 @with_account(readonly=False)
 @validate_id("chat_id")
 async def reply_to_message(
-    chat_id: Union[int, str], message_id: int, text: str, parse_mode: Optional[str] = None,
+    chat_id: Union[int, str],
+    message_id: int,
+    text: str,
+    parse_mode: Optional[str] = None,
     account: str = None,
 ) -> str:
     """
@@ -3544,7 +3566,9 @@ async def search_public_chats(query: str, limit: int = 20, account: str = None)
 )
 @with_account(readonly=True)
 @validate_id("chat_id")
-async def search_messages(chat_id: Union[int, str], query: str, limit: int = 20, account: str = None) -> str:
+async def search_messages(
+    chat_id: Union[int, str], query: str, limit: int = 20, account: str = None
+) -> str:
     """
     Search for messages in a chat by text.
     """
@@ -3577,16 +3601,16 @@ async def search_messages(chat_id: Union[int, str], query: str, limit: int = 20,
     )
 )
 @with_account(readonly=True)
-async def search_global(query: str, page: int = 1, page_size: int = 20, account: str = None) -> str:
+async def search_global(
+    query: str, page: int = 1, page_size: int = 20, account: str = None
+) -> str:
     """
     Search for messages across all public chats and channels by text content.
     """
     try:
         cl = get_client(account)
         offset = (page - 1) * page_size
-        messages = await cl.get_messages(
-            None, limit=page_size, search=query, add_offset=offset
-        )
+        messages = await cl.get_messages(None, limit=page_size, search=query, add_offset=offset)
 
         if not messages:
             return "No messages found for this page."
@@ -4795,7 +4819,9 @@ async def create_folder(
 @with_account(readonly=False)
 @validate_id("chat_id")
 async def add_chat_to_folder(
-    folder_id: int, chat_id: Union[int, str], pinned: bool = False,
+    folder_id: int,
+    chat_id: Union[int, str],
+    pinned: bool = False,
     account: str = None,
 ) -> str:
     """
@@ -4877,9 +4903,7 @@ async def add_chat_to_folder(
                 color=getattr(target_folder, "color", None),
             )
 
-        await cl(
-            functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=updated_filter)
-        )
+        await cl(functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=updated_filter))
 
         return (
             f"Chat {chat_id} added to folder {folder_id}" + (" (pinned)" if pinned else "") + "."
@@ -4901,7 +4925,9 @@ async def add_chat_to_folder(
 )
 @with_account(readonly=False)
 @validate_id("chat_id")
-async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str], account: str = None) -> str:
+async def remove_chat_from_folder(
+    folder_id: int, chat_id: Union[int, str], account: str = None
+) -> str:
     """
     Remove a chat from a folder.
 
@@ -4985,9 +5011,7 @@ async def remove_chat_from_folder(folder_id: int, chat_id: Union[int, str], acco
                 color=getattr(target_folder, "color", None),
             )
 
-        await cl(
-            functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=updated_filter)
-        )
+        await cl(functions.messages.UpdateDialogFilterRequest(id=folder_id, filter=updated_filter))
 
         return f"Chat {chat_id} removed from folder {folder_id}."
     except Exception as e:
diff --git a/session_string_generator.py b/session_string_generator.py
index cb0ef60..fc90a40 100755
--- a/session_string_generator.py
+++ b/session_string_generator.py
@@ -111,9 +111,11 @@ def main() -> None:
         "\nYour credentials will NOT be stored on any server and are only used for local authentication.\n"
     )
 
-    label = input(
-        "Account label (optional, e.g. 'work', 'personal'; leave empty for default): "
-    ).strip().lower()
+    label = (
+        input("Account label (optional, e.g. 'work', 'personal'; leave empty for default): ")
+        .strip()
+        .lower()
+    )
 
     print("\nChoose login method:")
     print("  1) QR code login (recommended -- scan from your Telegram app)")

From 58f225dfd30b6d842399270bc422b3d8b12dc618 Mon Sep 17 00:00:00 2001
From: Daniil Svetlov <svetlov@bpcbt.com>
Date: Fri, 24 Apr 2026 00:15:29 +0300
Subject: [PATCH 4/5] chore: remove openspec folder from PR

These were local spec-driven planning artifacts and should not be
committed. Removing per maintainer feedback.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../multi-account-support/.openspec.yaml      |  2 -
 .../changes/multi-account-support/design.md   | 90 -------------------
 .../changes/multi-account-support/proposal.md | 27 ------
 .../specs/account-aware-tools/spec.md         | 52 -----------
 .../specs/multi-account/spec.md               | 56 ------------
 .../changes/multi-account-support/tasks.md    | 54 -----------
 openspec/config.yaml                          | 20 -----
 7 files changed, 301 deletions(-)
 delete mode 100644 openspec/changes/multi-account-support/.openspec.yaml
 delete mode 100644 openspec/changes/multi-account-support/design.md
 delete mode 100644 openspec/changes/multi-account-support/proposal.md
 delete mode 100644 openspec/changes/multi-account-support/specs/account-aware-tools/spec.md
 delete mode 100644 openspec/changes/multi-account-support/specs/multi-account/spec.md
 delete mode 100644 openspec/changes/multi-account-support/tasks.md
 delete mode 100644 openspec/config.yaml

diff --git a/openspec/changes/multi-account-support/.openspec.yaml b/openspec/changes/multi-account-support/.openspec.yaml
deleted file mode 100644
index 8fb8631..0000000
--- a/openspec/changes/multi-account-support/.openspec.yaml
+++ /dev/null
@@ -1,2 +0,0 @@
-schema: spec-driven
-created: 2026-03-31
diff --git a/openspec/changes/multi-account-support/design.md b/openspec/changes/multi-account-support/design.md
deleted file mode 100644
index 846d8e9..0000000
--- a/openspec/changes/multi-account-support/design.md
+++ /dev/null
@@ -1,90 +0,0 @@
-## Context
-
-The server (`main.py`, ~4800 lines) initializes a single global `TelegramClient` at module level (line 101-106) from environment variables. All 60+ MCP tools reference this global `client` directly. Configuration lives in `.env` with three variables: `TELEGRAM_API_ID`, `TELEGRAM_API_HASH`, and `TELEGRAM_SESSION_STRING` (or `TELEGRAM_SESSION_NAME`).
-
-## Goals / Non-Goals
-
-**Goals:**
-- Support 2+ simultaneous Telegram accounts with user-defined labels
-- Zero breakage for single-account users (config and tool behavior unchanged)
-- Read-only tools fan out to all accounts when `account` is omitted
-- Write tools require explicit account selection
-- Minimal per-tool code changes via a shared decorator
-
-**Non-Goals:**
-- Dynamic account add/remove at runtime (requires server restart)
-- Per-account `API_ID`/`API_HASH` overrides (one Telegram app for all accounts)
-- Account-level permission/access control
-- Merging or deduplicating contacts across accounts
-
-## Decisions
-
-### 1. Client registry as a plain dict
-
-**Decision:** `clients: dict[str, TelegramClient]` at module level, replacing the single `client` global.
-
-**Alternatives considered:**
-- Class-based `AccountManager` with methods — adds indirection with no real benefit; a dict + a few helper functions is simpler.
-- Keep global `client` and add a second one — doesn't scale, creates ad-hoc naming.
-
-**Rationale:** A dict keyed by label is the simplest structure that supports N accounts. Helper function `get_client(account: str) -> TelegramClient` handles lookup and error messaging.
-
-### 2. `@with_account` decorator for tool injection
-
-**Decision:** A decorator that:
-- Adds `account: str = None` to the tool's MCP signature.
-- For `readonly=True` tools: if `account` is None and multi-mode is active, calls the wrapped function once per client, prefixes each result with `[label]`, and concatenates.
-- For `readonly=False` tools: if `account` is None in multi-mode, returns an error asking the LLM to specify an account.
-- In single-mode: always resolves to the sole client, `account` parameter is effectively ignored.
-- Injects resolved `TelegramClient` as the `client` keyword argument.
-
-**Alternatives considered:**
-- Manual edits to each tool without decorator — same effect but 60+ places to get wrong, harder to change behavior later.
-- Context-based injection via MCP Context — Context is already used for file-path security (Roots API); overloading it for client selection is confusing.
-
-**Rationale:** The decorator centralizes the account-resolution logic. Each tool change is mechanical: add decorator, replace bare `client` with `client` parameter.
-
-### 3. Label-suffixed `.env` variables for configuration
-
-**Decision:** Multi-account config via env var suffix convention:
-```
-TELEGRAM_API_ID=123456
-TELEGRAM_API_HASH=abcdef
-TELEGRAM_SESSION_STRING_WORK=...
-TELEGRAM_SESSION_STRING_PERSONAL=...
-```
-
-Detection logic at startup:
-1. Scan env vars matching `TELEGRAM_SESSION_STRING_*` and `TELEGRAM_SESSION_NAME_*`.
-2. If suffixed vars found → multi-mode. Labels extracted from suffixes, lowercased.
-3. If only unsuffixed `TELEGRAM_SESSION_STRING`/`TELEGRAM_SESSION_NAME` found → single-mode, label = `"default"`.
-4. If both suffixed and unsuffixed exist → unsuffixed becomes label `"default"`, combined with suffixed ones into multi-mode.
-5. If nothing found → startup error.
-
-**Alternatives considered:**
-- Separate YAML/JSON config file — requires new dependency or new file format; breaks existing single-account setups.
-- Numbered suffixes (`_1`, `_2`) — requires a separate label variable per account; less self-documenting.
-
-**Rationale:** Stays within `.env` convention. Existing single-account configs work unchanged. Labels are self-documenting. No new files or formats.
-
-### 4. Per-account entity cache warming
-
-**Decision:** At startup, call `await cl.get_dialogs()` for each client in the registry. Entity resolution functions (`resolve_entity`, `resolve_input_entity`) take a `client` parameter instead of using the global.
-
-**Rationale:** StringSession has no persistent entity cache. Each client needs its own warm cache. The existing pattern stays the same, just parameterized.
-
-### 5. Output tagging with `[label]` prefix
-
-**Decision:** When a read-only tool fans out to all accounts, each account's result block is prefixed with `[label]` on its own line, followed by the tool's normal output. In single-mode, no prefix is added.
-
-**Rationale:** Simple, readable by both humans and LLMs. The LLM can parse the label to determine which account context to use for subsequent write operations.
-
-## Risks / Trade-offs
-
-**[Increased startup time]** → Each additional account adds one `client.start()` + `get_dialogs()` call. For 2-3 accounts this is a few seconds. Mitigation: start clients concurrently with `asyncio.gather`.
-
-**[Larger tool signatures]** → Every tool gains an `account` parameter. For single-account users this is invisible (default = None, resolved to sole client). For multi-account users, LLMs handle it naturally via context.
-
-**[Mechanical refactor of 60+ tools]** → High volume of changes but each change is small and formulaic. Risk of missed tools or typos. Mitigation: grep for bare `client.` references after refactor to catch stragglers.
-
-**[Telethon concurrency]** → Multiple TelegramClient instances are independent and safe to run concurrently — each has its own connection and state. No shared-state issues. Fan-out reads use `asyncio.gather` for parallel execution.
diff --git a/openspec/changes/multi-account-support/proposal.md b/openspec/changes/multi-account-support/proposal.md
deleted file mode 100644
index 3a6bec2..0000000
--- a/openspec/changes/multi-account-support/proposal.md
+++ /dev/null
@@ -1,27 +0,0 @@
-## Why
-
-The Telegram MCP server currently supports only a single Telegram account per server instance. Users who maintain separate work and personal accounts need to interact with both simultaneously throughout the day — reading messages from all accounts at once and replying from the correct one based on context. Running multiple server instances is not viable: tool names collide, and shared contacts across accounts lead to messages sent from the wrong identity.
-
-## What Changes
-
-- **Multi-client registry**: Replace the global singleton `TelegramClient` with a `dict[str, TelegramClient]` keyed by user-defined labels (e.g., `"work"`, `"personal"`).
-- **Account-aware tools**: Add an `account` parameter to all 60+ MCP tools. Read-only tools default to querying all accounts (results concatenated with `[label]` prefix). Write tools require an explicit `account` value.
-- **Backward-compatible configuration**: Extend `.env` to support labeled session strings (`TELEGRAM_SESSION_STRING_WORK`, `TELEGRAM_SESSION_STRING_PERSONAL`) alongside the existing unsuffixed `TELEGRAM_SESSION_STRING` for single-account mode.
-- **Single-account mode preservation**: When only the unsuffixed `TELEGRAM_SESSION_STRING` is present, the server behaves exactly as today — `account` parameter is optional everywhere.
-- **New `list_accounts` tool**: Exposes available accounts with labels and profile info so the LLM can orient itself.
-- **Per-account entity caches**: Each `TelegramClient` maintains its own entity cache, warmed at startup.
-
-## Capabilities
-
-### New Capabilities
-- `multi-account`: Account registry, client lifecycle, configuration parsing, account resolution logic, and the `list_accounts` tool.
-- `account-aware-tools`: Decorator-based account injection into existing tools, including read-only fan-out and write-tool validation.
-
-### Modified Capabilities
-
-## Impact
-
-- **main.py**: All 60+ tool functions gain the `@with_account` decorator and replace direct `client` references with an injected `client` parameter. Startup sequence initializes multiple clients.
-- **Configuration**: `.env` format extended (backward-compatible). `.env.example` updated with multi-account examples.
-- **session_string_generator.py**: May need updates to label generated sessions.
-- **No breaking changes** for single-account users — existing `.env` files and tool call signatures continue to work unchanged.
diff --git a/openspec/changes/multi-account-support/specs/account-aware-tools/spec.md b/openspec/changes/multi-account-support/specs/account-aware-tools/spec.md
deleted file mode 100644
index 53a2c69..0000000
--- a/openspec/changes/multi-account-support/specs/account-aware-tools/spec.md
+++ /dev/null
@@ -1,52 +0,0 @@
-## ADDED Requirements
-
-### Requirement: with_account decorator injects client into tools
-A `@with_account(readonly=True|False)` decorator SHALL add an `account: str = None` parameter to the MCP tool signature and inject a resolved `TelegramClient` as the `client` keyword argument.
-
-#### Scenario: Read-only tool with explicit account
-- **WHEN** a read-only tool is called with `account="work"`
-- **THEN** the decorator resolves the `"work"` client and passes it as `client` to the tool function
-
-#### Scenario: Write tool with explicit account
-- **WHEN** a write tool is called with `account="personal"`
-- **THEN** the decorator resolves the `"personal"` client and passes it as `client` to the tool function
-
-### Requirement: Read-only tools fan out to all accounts when account is omitted
-In multi-mode, when a read-only tool (`@with_account(readonly=True)`) is called without an `account` parameter, the decorator SHALL execute the tool function once per registered client, prefix each result with `[label]`, and return the concatenated output.
-
-#### Scenario: get_chats without account in multi-mode
-- **WHEN** `get_chats(page=1)` is called without `account` and two accounts exist (`"work"`, `"personal"`)
-- **THEN** the tool executes for both accounts, returning results prefixed with `[work]` and `[personal]`
-
-#### Scenario: Fan-out executes concurrently
-- **WHEN** a read-only tool fans out to multiple accounts
-- **THEN** the calls to each account's client SHALL execute concurrently via `asyncio.gather`
-
-### Requirement: Write tools require explicit account in multi-mode
-In multi-mode, when a write tool (`@with_account(readonly=False)`) is called without an `account` parameter, the decorator SHALL return an error message listing available accounts.
-
-#### Scenario: send_message without account in multi-mode
-- **WHEN** `send_message(chat_id=123, text="hello")` is called without `account` and multiple accounts exist
-- **THEN** an error is returned: account is required, available accounts are listed
-
-### Requirement: Single-mode tools work without account parameter
-In single-mode (one account), all tools SHALL work without the `account` parameter regardless of readonly setting. The sole client is always used.
-
-#### Scenario: Tool call in single-mode without account
-- **WHEN** any tool is called without `account` and only one account (`"default"`) is configured
-- **THEN** the tool executes against the `"default"` client with no error
-
-#### Scenario: Tool call in single-mode with explicit account
-- **WHEN** a tool is called with `account="default"` in single-mode
-- **THEN** the tool executes normally against the sole client
-
-### Requirement: Output tagging in multi-mode fan-out
-When a read-only tool fans out to all accounts, each account's result block SHALL be prefixed with `[label]` on its own line. In single-mode, no prefix SHALL be added.
-
-#### Scenario: Tagged output format
-- **WHEN** a read-only tool returns `"Chat A\nChat B"` for account `"work"` and `"Chat C"` for account `"personal"`
-- **THEN** the combined output is `"[work]\nChat A\nChat B\n\n[personal]\nChat C"`
-
-#### Scenario: No tagging in single-mode
-- **WHEN** a read-only tool fans out in single-mode (one account)
-- **THEN** the output is returned without any `[label]` prefix
diff --git a/openspec/changes/multi-account-support/specs/multi-account/spec.md b/openspec/changes/multi-account-support/specs/multi-account/spec.md
deleted file mode 100644
index 2bad2e0..0000000
--- a/openspec/changes/multi-account-support/specs/multi-account/spec.md
+++ /dev/null
@@ -1,56 +0,0 @@
-## ADDED Requirements
-
-### Requirement: Configuration parsing supports labeled accounts
-The server SHALL parse `.env` variables matching `TELEGRAM_SESSION_STRING_<LABEL>` and `TELEGRAM_SESSION_NAME_<LABEL>` to discover multiple accounts. Labels SHALL be extracted from the suffix and lowercased. A shared `TELEGRAM_API_ID` and `TELEGRAM_API_HASH` SHALL be used for all accounts.
-
-#### Scenario: Multi-account config with two labeled sessions
-- **WHEN** `.env` contains `TELEGRAM_SESSION_STRING_WORK=...` and `TELEGRAM_SESSION_STRING_PERSONAL=...` along with shared `TELEGRAM_API_ID` and `TELEGRAM_API_HASH`
-- **THEN** the server starts in multi-mode with two clients labeled `"work"` and `"personal"`
-
-#### Scenario: Single-account backward compatibility
-- **WHEN** `.env` contains only unsuffixed `TELEGRAM_SESSION_STRING` (no suffixed variants)
-- **THEN** the server starts in single-mode with one client labeled `"default"` and all tools work without requiring the `account` parameter
-
-#### Scenario: Mixed suffixed and unsuffixed sessions
-- **WHEN** `.env` contains both unsuffixed `TELEGRAM_SESSION_STRING` and suffixed `TELEGRAM_SESSION_STRING_WORK`
-- **THEN** the server starts in multi-mode with the unsuffixed session labeled `"default"` and the suffixed session labeled `"work"`
-
-#### Scenario: No session configured
-- **WHEN** `.env` contains no `TELEGRAM_SESSION_STRING` or `TELEGRAM_SESSION_NAME` variables (suffixed or unsuffixed)
-- **THEN** the server SHALL exit with a configuration error message
-
-### Requirement: Client registry manages multiple TelegramClient instances
-The server SHALL maintain a `clients: dict[str, TelegramClient]` registry mapping account labels to authenticated `TelegramClient` instances. A `get_client(account: str) -> TelegramClient` function SHALL provide lookup with a clear error if the label is unknown.
-
-#### Scenario: Lookup existing account
-- **WHEN** `get_client("work")` is called and a client with label `"work"` exists
-- **THEN** the corresponding `TelegramClient` instance is returned
-
-#### Scenario: Lookup unknown account
-- **WHEN** `get_client("nonexistent")` is called
-- **THEN** an error is returned listing available account labels
-
-### Requirement: All clients are started and cache-warmed at startup
-The server SHALL call `client.start()` and `client.get_dialogs()` for every client in the registry during startup. Startup of multiple clients SHALL be concurrent via `asyncio.gather`.
-
-#### Scenario: Startup with two accounts
-- **WHEN** the server starts with accounts `"work"` and `"personal"` configured
-- **THEN** both clients are authenticated and their entity caches are warmed before the MCP server begins accepting requests
-
-### Requirement: list_accounts tool exposes available accounts
-The server SHALL provide a `list_accounts` MCP tool that returns all configured account labels with profile information (name, phone number, online status) for each.
-
-#### Scenario: List accounts in multi-mode
-- **WHEN** `list_accounts()` is called with two configured accounts
-- **THEN** the response includes each account's label, display name, phone number, and online status
-
-#### Scenario: List accounts in single-mode
-- **WHEN** `list_accounts()` is called in single-mode
-- **THEN** the response includes one account with label `"default"` and its profile information
-
-### Requirement: Entity resolution is per-client
-The `resolve_entity` and `resolve_input_entity` functions SHALL accept a `client` parameter instead of using a global. Each client's entity cache is independent.
-
-#### Scenario: Resolve entity for specific account
-- **WHEN** `resolve_entity(identifier, client=work_client)` is called
-- **THEN** entity resolution uses the `work_client`'s cache, falling back to `work_client.get_dialogs()` on cache miss
diff --git a/openspec/changes/multi-account-support/tasks.md b/openspec/changes/multi-account-support/tasks.md
deleted file mode 100644
index 1ac2d7b..0000000
--- a/openspec/changes/multi-account-support/tasks.md
+++ /dev/null
@@ -1,54 +0,0 @@
-## 1. Configuration & Client Registry
-
-- [x] 1.1 Replace global client initialization (lines 90-106) with config parsing logic: scan env vars for `TELEGRAM_SESSION_STRING_<LABEL>` / `TELEGRAM_SESSION_NAME_<LABEL>` suffixes, detect single vs multi mode
-- [x] 1.2 Create `clients: dict[str, TelegramClient]` registry and `get_client(account)` lookup function with error listing available labels
-- [x] 1.3 Implement `is_multi_mode()` helper that returns True when more than one account is configured
-- [x] 1.4 Update `_main()` startup (lines 4752-4783) to initialize and cache-warm all clients concurrently via `asyncio.gather`
-
-## 2. Decorator & Account Resolution
-
-- [x] 2.1 Implement `@with_account(readonly=True|False)` decorator: adds `account` param, resolves client, injects as `client` kwarg
-- [x] 2.2 Implement read-only fan-out logic in decorator: call tool for all accounts concurrently, prefix results with `[label]`, concatenate
-- [x] 2.3 Implement write-tool guard in decorator: error with available accounts list when `account` is omitted in multi-mode
-- [x] 2.4 Implement single-mode passthrough: ignore `account` param, always use sole client, no output tagging
-
-## 3. Parameterize Shared Helpers
-
-- [x] 3.1 Update `resolve_entity()` and `resolve_input_entity()` (lines 344-365) to accept a `client` parameter
-- [x] 3.2 Audit and update any other helper functions that reference the global `client` directly
-
-## 4. Migrate Tools — Read-only
-
-- [x] 4.1 Add `@with_account(readonly=True)` and replace `client` with param in read-only chat tools: `get_chats`, `list_chats`, `get_chat`, `get_participants`, `get_admins`, `get_banned_users`, `get_invite_link`
-- [x] 4.2 Add decorator to read-only message tools: `get_messages`, `list_messages`, `get_message_context`, `get_history`, `get_pinned_messages`, `search_messages`, `search_global`, `list_inline_buttons`, `get_message_reactions`, `get_last_interaction`, `list_topics`
-- [x] 4.3 Add decorator to read-only contact tools: `list_contacts`, `search_contacts`, `get_contact_ids`, `get_blocked_users`, `get_direct_chat_by_contact`, `get_contact_chats`
-- [x] 4.4 Add decorator to read-only profile/user tools: `get_me`, `get_user_photos`, `get_user_status`
-- [x] 4.5 Add decorator to read-only media tools: `get_media_info`
-- [x] 4.6 Add decorator to read-only discovery tools: `search_public_chats`, `resolve_username`
-- [x] 4.7 Add decorator to read-only drafts/folders/stickers/bot tools: `get_drafts`, `list_folders`, `get_folder`, `get_sticker_sets`, `get_bot_info`
-- [x] 4.8 Add decorator to any remaining read-only tools (`readOnlyHint=True` or equivalent)
-
-## 5. Migrate Tools — Write / Destructive
-
-- [x] 5.1 Add `@with_account(readonly=False)` to messaging write tools: `send_message`, `reply_to_message`, `edit_message`, `delete_message`, `forward_message`, `pin_message`, `unpin_message`, `mark_as_read`, `press_inline_button`, `create_poll`, `send_reaction`, `remove_reaction`
-- [x] 5.2 Add decorator to chat management write tools: `create_group`, `create_channel`, `invite_to_group`, `leave_chat`, `edit_chat_title`, `delete_chat_photo`, `edit_chat_photo`, `mute_chat`, `unmute_chat`, `archive_chat`, `unarchive_chat`, `export_chat_invite`
-- [x] 5.3 Add decorator to contact write tools: `add_contact`, `delete_contact`, `block_user`, `unblock_user`, `import_contacts`, `export_contacts`
-- [x] 5.4 Add decorator to profile write tools: `update_profile`, `set_profile_photo`, `delete_profile_photo`
-- [x] 5.5 Add decorator to admin/permission write tools: `promote_admin`, `demote_admin`, `ban_user`, `unban_user`, `set_privacy_settings`, `get_privacy_settings`
-- [x] 5.6 Add decorator to media write tools: `send_file`, `download_media`, `upload_file`, `send_voice`, `send_sticker`, `send_gif`
-- [x] 5.7 Add decorator to discovery write tools: `subscribe_public_channel`, `import_chat_invite`, `join_chat_by_link`
-- [x] 5.8 Add decorator to drafts/folders write tools: `save_draft`, `clear_draft`, `create_folder`, `edit_folder`, `delete_folder`, `reorder_folders`
-- [x] 5.9 Add decorator to bot write tools: `set_bot_commands`
-- [x] 5.10 Add decorator to any remaining write tools
-
-## 6. New Tool & Config Files
-
-- [x] 6.1 Implement `list_accounts` tool returning label, display name, phone, and online status for each account
-- [x] 6.2 Update `.env.example` with multi-account configuration examples
-- [x] 6.3 Update `session_string_generator.py` to prompt for an optional label and output the labeled env var name
-
-## 7. Validation & Cleanup
-
-- [x] 7.1 Grep for any remaining bare `client.` references (outside the registry/decorator code) and fix them
-- [x] 7.2 Test single-mode: verify existing `.env` with one account works identically to before
-- [ ] 7.3 Test multi-mode: verify two accounts, read-only fan-out, write-tool account requirement, `list_accounts`
diff --git a/openspec/config.yaml b/openspec/config.yaml
deleted file mode 100644
index 392946c..0000000
--- a/openspec/config.yaml
+++ /dev/null
@@ -1,20 +0,0 @@
-schema: spec-driven
-
-# Project context (optional)
-# This is shown to AI when creating artifacts.
-# Add your tech stack, conventions, style guides, domain knowledge, etc.
-# Example:
-#   context: |
-#     Tech stack: TypeScript, React, Node.js
-#     We use conventional commits
-#     Domain: e-commerce platform
-
-# Per-artifact rules (optional)
-# Add custom rules for specific artifacts.
-# Example:
-#   rules:
-#     proposal:
-#       - Keep proposals under 500 words
-#       - Always include a "Non-goals" section
-#     tasks:
-#       - Break tasks into chunks of max 2 hours

From d295d6ca8babd774f25b4373bba8c7eedbd858ac Mon Sep 17 00:00:00 2001
From: Daniil Svetlov <svetlov@bpcbt.com>
Date: Fri, 24 Apr 2026 00:31:20 +0300
Subject: [PATCH 5/5] style: apply black formatting after merge

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 main.py | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/main.py b/main.py
index 38e2fda..bd9f388 100644
--- a/main.py
+++ b/main.py
@@ -208,7 +208,6 @@ async def _call_for(label):
     return decorator
 
 
-
 _last_conn_verified: dict[int, float] = {}
 _CONN_VERIFY_INTERVAL: float = 30.0  # seconds between live pings
 
@@ -1112,9 +1111,7 @@ async def delete_scheduled_message(
         if not message_ids:
             return "message_ids must be a non-empty list."
         entity = await resolve_entity(chat_id, cl)
-        await cl(
-            functions.messages.DeleteScheduledMessagesRequest(peer=entity, id=message_ids)
-        )
+        await cl(functions.messages.DeleteScheduledMessagesRequest(peer=entity, id=message_ids))
         return f"Deleted {len(message_ids)} scheduled message(s) from chat {chat_id}."
     except telethon.errors.rpcerrorlist.ChatAdminRequiredError as e:
         return log_and_format_error(
@@ -1792,14 +1789,10 @@ async def list_chats(
                 about_text = ""
                 try:
                     if isinstance(entity, Channel):
-                        full = await cl(
-                            functions.channels.GetFullChannelRequest(channel=entity)
-                        )
+                        full = await cl(functions.channels.GetFullChannelRequest(channel=entity))
                         about_text = getattr(full.full_chat, "about", "") or ""
                     elif isinstance(entity, Chat):
-                        full = await cl(
-                            functions.messages.GetFullChatRequest(chat_id=entity.id)
-                        )
+                        full = await cl(functions.messages.GetFullChatRequest(chat_id=entity.id))
                         about_text = getattr(full.full_chat, "about", "") or ""
                     elif isinstance(entity, User):
                         full = await cl(functions.users.GetFullUserRequest(id=entity))
@@ -3463,9 +3456,7 @@ async def set_default_chat_permissions(
 )
 @with_account(readonly=False)
 @validate_id("chat_id")
-async def toggle_slow_mode(
-    chat_id: Union[int, str], seconds: int = 0, account: str = None
-) -> str:
+async def toggle_slow_mode(chat_id: Union[int, str], seconds: int = 0, account: str = None) -> str:
     """
     Enable or disable slow mode for a supergroup.