commit 343169a973fe0ea7ea45229e26cbb4c1c5a8b312
Author: Arthur K. <me@wzray.com>
Date:   Mon May 4 23:12:53 2026 +0300

    init

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..1d25839
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+__pycache__/
+.ruff_cache
+.venv
+/session/
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..13014e2
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+COPY --from=ghcr.io/astral-sh/uv:0.10.11 /uv /bin/uv
+
+WORKDIR /app
+
+ENV UV_PROJECT_ENVIRONMENT=/usr/local
+
+COPY pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-dev
+
+COPY proxy.py .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "proxy:app", "--host", "0.0.0.0", "--port", "8000"]
diff --git a/create_session.py b/create_session.py
new file mode 100644
index 0000000..c63da1c
--- /dev/null
+++ b/create_session.py
@@ -0,0 +1,12 @@
+import os
+
+from pyrogram.client import Client
+
+API_ID = int(os.getenv("API_ID", "0"))
+API_HASH = os.getenv("API_HASH", "")
+
+client = Client("tg_proxy", api_id=API_ID, api_hash=API_HASH, workdir="session")
+
+with client:
+    me = client.get_me()
+    print(me)
diff --git a/proxy.py b/proxy.py
new file mode 100644
index 0000000..d80907c
--- /dev/null
+++ b/proxy.py
@@ -0,0 +1,1026 @@
+import json
+import logging
+import os
+import time
+import traceback
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from typing import Any, cast
+
+from fastapi import FastAPI, HTTPException, Query, Request
+from pydantic import BaseModel, Field
+from pyrogram.client import Client
+from pyrogram.raw.functions.account.get_notify_exceptions import GetNotifyExceptions
+from pyrogram.raw.functions.account.get_notify_settings import GetNotifySettings
+from pyrogram.raw.functions.messages.get_dialog_filters import GetDialogFilters
+from pyrogram.raw.types.input_notify_broadcasts import InputNotifyBroadcasts
+from pyrogram.raw.types.input_notify_chats import InputNotifyChats
+from pyrogram.raw.types.input_notify_users import InputNotifyUsers
+from pyrogram.types import Dialog
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.responses import JSONResponse, PlainTextResponse
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+)
+logger = logging.getLogger(__name__)
+logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
+
+
+API_ID = int(os.getenv("API_ID", "0"))
+API_HASH = os.getenv("API_HASH", "")
+
+MAX_LIMIT = 100
+DIALOGS_CACHE_TTL = 300
+MESSAGES_CACHE_TTL = 1200
+HEAD_REFRESH_LIMIT = 20
+
+client = Client("tg_proxy", api_id=API_ID, api_hash=API_HASH, workdir="session")
+
+_dialogs_cache: list[Dialog] = []
+_dialogs_cache_time: float = 0
+_dialog_filters_cache: list[Any] = []
+_dialog_filters_cache_time: float = 0
+_folder_membership_cache: dict[int, list[int]] = {}
+_folder_membership_cache_time: float = 0
+_global_notify_settings: dict[str, int] = {}
+_notify_exceptions_cache: dict[int, int] = {}
+_raw_message_cache: dict[int, dict[int, tuple[Any, float]]] = {}
+_history_page_cache: dict[
+    tuple[int, int, int], tuple[int | None, list[Any], float]
+] = {}
+_delta_cache: dict[tuple[int, str], tuple[int | None, list[Any], float]] = {}
+
+
+class Chat(BaseModel):
+    id: int
+    title: str | None
+    type: str
+    chat_type: str
+    username: str | None = None
+    members_count: int | None = None
+    is_pinned: bool = False
+    pinned: bool = False
+    last_message_date: datetime | None = None
+    unread_count: int = 0
+    is_muted: bool = False
+    muted: bool = False
+    archived: bool = False
+    folder_id: int | None = None
+    folder_ids: list[int] | None = None
+    last_online_at: datetime | None = None
+
+
+class DialogFolder(BaseModel):
+    id: int
+    title: str | None = None
+    type: str
+    icon_emoji: str | None = None
+    pinned_chat_ids: list[int] = Field(default_factory=list)
+    include_chat_ids: list[int] = Field(default_factory=list)
+    exclude_chat_ids: list[int] = Field(default_factory=list)
+    contacts: bool = False
+    non_contacts: bool = False
+    groups: bool = False
+    broadcasts: bool = False
+    bots: bool = False
+    exclude_muted: bool = False
+    exclude_read: bool = False
+    exclude_archived: bool = False
+    has_my_invites: bool | None = None
+
+
+class Attachment(BaseModel):
+    type: str
+    filename: str | None = None
+    mime: str | None = None
+    duration: int | None = None
+    size: int | None = None
+
+
+class Message(BaseModel):
+    id: int
+    date: datetime | None
+    text: str | None
+    from_user: str | None
+    chat_id: int
+    from_me: bool | None = None
+    is_outgoing: bool | None = None
+    reply_to_message_id: int | None = None
+    quoted_text: str | None = None
+    reply_snippet: str | None = None
+    edited_at: datetime | None = None
+    is_read: bool | None = None
+    attachments: list[Attachment] | None = None
+
+
+class PaginatedChats(BaseModel):
+    items: list[Chat]
+    limit: int
+    offset: int
+    has_more: bool
+    remaining_count: int | None = None
+
+
+class PaginatedMessages(BaseModel):
+    chat: Chat | None = None
+    items: list[Message]
+    limit: int
+    offset: int
+    has_more: bool
+    remaining_count: int | None = None
+
+
+class AccessLogMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        response = await call_next(request)
+        xff = request.headers.get("x-forwarded-for", "")
+        client_ip = (
+            xff.split(",")[0].strip()
+            if xff
+            else request.client.host
+            if request.client
+            else "-"
+        )
+        logger.info(
+            f'{client_ip} - "{request.method} {request.url.path}" {response.status_code}'
+        )
+        return response
+
+
+class PrettyJSONResponse(JSONResponse):
+    def render(self, content) -> bytes:
+        return json.dumps(
+            content,
+            ensure_ascii=False,
+            allow_nan=False,
+            indent=2,
+        ).encode("utf-8")
+
+
+def validate_limit(limit: int) -> int:
+    if limit > MAX_LIMIT:
+        raise HTTPException(status_code=400, detail=f"Limit cannot exceed {MAX_LIMIT}")
+    return limit
+
+
+def normalize_chat_type(chat_type: str) -> str:
+    if chat_type in ("private", "bot", "direct"):
+        return "direct"
+    if chat_type in ("group", "supergroup", "forum"):
+        return "group"
+    if chat_type == "channel":
+        return "channel"
+    return chat_type
+
+
+def matches_chat_type_filter(chat: Chat, chat_type_filter: str | None) -> bool:
+    if chat_type_filter is None:
+        return True
+
+    normalized_filter = chat_type_filter.strip().lower()
+    if normalized_filter == "direct":
+        return chat.type in ("private", "direct")
+    if normalized_filter == "bot":
+        return chat.type == "bot"
+    if normalized_filter == "group":
+        return chat.type in ("group", "supergroup", "forum")
+    if normalized_filter == "channel":
+        return chat.type == "channel"
+
+    return False
+
+
+def normalize_int(value) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def normalize_datetime(value: datetime | None) -> datetime | None:
+    if value is None:
+        return None
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)
+
+
+def raw_peer_to_chat_id(peer: Any) -> int | None:
+    if peer is None:
+        return None
+
+    if hasattr(peer, "user_id"):
+        return normalize_int(getattr(peer, "user_id", None))
+
+    if hasattr(peer, "chat_id"):
+        chat_id = normalize_int(getattr(peer, "chat_id", None))
+        return -chat_id if chat_id is not None else None
+
+    if hasattr(peer, "channel_id"):
+        channel_id = normalize_int(getattr(peer, "channel_id", None))
+        if channel_id is None:
+            return None
+        return int(f"-100{channel_id}")
+
+    nested_peer = getattr(peer, "peer", None)
+    if nested_peer is not None and nested_peer is not peer:
+        return raw_peer_to_chat_id(nested_peer)
+
+    return None
+
+
+def extract_filter_title(raw_filter: Any) -> str | None:
+    title = getattr(raw_filter, "title", None)
+    if title is None:
+        return None
+    if isinstance(title, str):
+        return title
+
+    text = getattr(title, "text", None)
+    if isinstance(text, str):
+        return text
+
+    return str(title)
+
+
+def collect_filter_chat_ids(peers: list[Any] | None) -> list[int]:
+    chat_ids: list[int] = []
+    if not peers:
+        return chat_ids
+
+    for peer in peers:
+        chat_id = raw_peer_to_chat_id(peer)
+        if chat_id is not None:
+            chat_ids.append(chat_id)
+
+    return sorted(set(chat_ids))
+
+
+def build_dialog_folder(raw_filter: Any) -> DialogFolder | None:
+    folder_id = normalize_int(getattr(raw_filter, "id", None))
+    if folder_id is None:
+        return None
+
+    filter_name = raw_filter.__class__.__name__
+    if filter_name == "DialogFilterDefault":
+        return None
+
+    folder_type = "chatlist" if filter_name == "DialogFilterChatlist" else "folder"
+
+    return DialogFolder(
+        id=folder_id,
+        title=extract_filter_title(raw_filter),
+        type=folder_type,
+        icon_emoji=getattr(raw_filter, "emoticon", None),
+        pinned_chat_ids=collect_filter_chat_ids(
+            getattr(raw_filter, "pinned_peers", None)
+        ),
+        include_chat_ids=collect_filter_chat_ids(
+            getattr(raw_filter, "include_peers", None)
+        ),
+        exclude_chat_ids=collect_filter_chat_ids(
+            getattr(raw_filter, "exclude_peers", None)
+        ),
+        contacts=bool(getattr(raw_filter, "contacts", False)),
+        non_contacts=bool(getattr(raw_filter, "non_contacts", False)),
+        groups=bool(getattr(raw_filter, "groups", False)),
+        broadcasts=bool(getattr(raw_filter, "broadcasts", False)),
+        bots=bool(getattr(raw_filter, "bots", False)),
+        exclude_muted=bool(getattr(raw_filter, "exclude_muted", False)),
+        exclude_read=bool(getattr(raw_filter, "exclude_read", False)),
+        exclude_archived=bool(getattr(raw_filter, "exclude_archived", False)),
+        has_my_invites=getattr(raw_filter, "has_my_invites", None),
+    )
+
+
+def dialog_is_read(dialog: Dialog) -> bool:
+    return (getattr(dialog, "unread_messages_count", 0) or 0) == 0
+
+
+def dialog_matches_folder(dialog: Dialog, chat: Chat, raw_filter: Any) -> bool:
+    filter_name = raw_filter.__class__.__name__
+    if filter_name == "DialogFilterDefault":
+        return False
+
+    folder = build_dialog_folder(raw_filter)
+    if folder is None:
+        return False
+
+    explicit_include_ids = set(folder.pinned_chat_ids) | set(folder.include_chat_ids)
+    explicit_exclude_ids = set(folder.exclude_chat_ids)
+
+    if chat.id in explicit_exclude_ids:
+        return False
+
+    matches_positive_rule = chat.id in explicit_include_ids
+
+    if filter_name == "DialogFilterChatlist":
+        return matches_positive_rule
+
+    chat_type = chat.type
+    is_bot = chat_type == "bot" or bool(getattr(dialog.chat, "is_bot", False))
+    is_group = chat_type in ("group", "supergroup", "forum")
+    is_broadcast = chat_type == "channel"
+    is_contact = bool(getattr(dialog.chat, "is_contact", False))
+    is_private = chat_type in ("private", "direct")
+    is_non_contact = is_private and not is_contact and not is_bot
+
+    if folder.contacts and is_contact:
+        matches_positive_rule = True
+    if folder.non_contacts and is_non_contact:
+        matches_positive_rule = True
+    if folder.groups and is_group:
+        matches_positive_rule = True
+    if folder.broadcasts and is_broadcast:
+        matches_positive_rule = True
+    if folder.bots and is_bot:
+        matches_positive_rule = True
+
+    if not matches_positive_rule:
+        return False
+
+    if folder.exclude_muted and chat.is_muted:
+        return False
+    if folder.exclude_read and dialog_is_read(dialog):
+        return False
+    if folder.exclude_archived and chat.archived:
+        return False
+
+    return True
+
+
+def build_folder_membership_map(
+    dialogs: list[Dialog], raw_filters: list[Any]
+) -> dict[int, list[int]]:
+    memberships: dict[int, list[int]] = {}
+
+    for dialog in dialogs:
+        chat = build_chat(dialog)
+        matched_folder_ids: list[int] = []
+
+        for raw_filter in raw_filters:
+            folder = build_dialog_folder(raw_filter)
+            if folder is None:
+                continue
+            if dialog_matches_folder(dialog, chat, raw_filter):
+                matched_folder_ids.append(folder.id)
+
+        memberships[chat.id] = sorted(set(matched_folder_ids))
+
+    return memberships
+
+
+def extract_message_snippet(message) -> str | None:
+    if not message:
+        return None
+
+    for attr in ("text", "caption"):
+        value = getattr(message, attr, None)
+        if value:
+            return value[:200]
+
+    media = getattr(message, "media", None)
+    if media:
+        media_value = getattr(media, "value", None) or str(media)
+        return f"[{media_value}]"
+
+    return None
+
+
+def build_attachments(message) -> list[Attachment] | None:
+    attachments: list[Attachment] = []
+    media_type = getattr(getattr(message, "media", None), "value", None)
+
+    if media_type == "photo":
+        photo = getattr(message, "photo", None)
+        attachments.append(
+            Attachment(
+                type="photo",
+                mime=getattr(photo, "mime_type", None),
+                size=normalize_int(getattr(photo, "file_size", None)),
+            )
+        )
+    elif media_type == "document":
+        document = getattr(message, "document", None)
+        attachments.append(
+            Attachment(
+                type="document",
+                filename=getattr(document, "file_name", None),
+                mime=getattr(document, "mime_type", None),
+                size=normalize_int(getattr(document, "file_size", None)),
+            )
+        )
+    elif media_type == "video":
+        video = getattr(message, "video", None)
+        attachments.append(
+            Attachment(
+                type="video",
+                filename=getattr(video, "file_name", None),
+                mime=getattr(video, "mime_type", None),
+                duration=normalize_int(getattr(video, "duration", None)),
+                size=normalize_int(getattr(video, "file_size", None)),
+            )
+        )
+    elif media_type == "audio":
+        audio = getattr(message, "audio", None)
+        attachments.append(
+            Attachment(
+                type="audio",
+                filename=getattr(audio, "file_name", None),
+                mime=getattr(audio, "mime_type", None),
+                duration=normalize_int(getattr(audio, "duration", None)),
+                size=normalize_int(getattr(audio, "file_size", None)),
+            )
+        )
+    elif media_type == "voice":
+        voice = getattr(message, "voice", None)
+        attachments.append(
+            Attachment(
+                type="voice",
+                mime=getattr(voice, "mime_type", None),
+                duration=normalize_int(getattr(voice, "duration", None)),
+                size=normalize_int(getattr(voice, "file_size", None)),
+            )
+        )
+    elif media_type == "animation":
+        animation = getattr(message, "animation", None)
+        attachments.append(
+            Attachment(
+                type="animation",
+                filename=getattr(animation, "file_name", None),
+                mime=getattr(animation, "mime_type", None),
+                duration=normalize_int(getattr(animation, "duration", None)),
+                size=normalize_int(getattr(animation, "file_size", None)),
+            )
+        )
+    elif media_type == "sticker":
+        sticker = getattr(message, "sticker", None)
+        attachments.append(
+            Attachment(
+                type="sticker",
+                filename=getattr(sticker, "file_name", None),
+                mime=getattr(sticker, "mime_type", None),
+                size=normalize_int(getattr(sticker, "file_size", None)),
+            )
+        )
+    elif media_type == "video_note":
+        video_note = getattr(message, "video_note", None)
+        attachments.append(
+            Attachment(
+                type="video_note",
+                duration=normalize_int(getattr(video_note, "duration", None)),
+                size=normalize_int(getattr(video_note, "file_size", None)),
+            )
+        )
+
+    return attachments or None
+
+
+async def get_cached_dialogs() -> list[Dialog]:
+    global \
+        _dialogs_cache, \
+        _dialogs_cache_time, \
+        _global_notify_settings, \
+        _notify_exceptions_cache
+
+    now = time.time()
+    if _dialogs_cache and (now - _dialogs_cache_time) < DIALOGS_CACHE_TTL:
+        logger.info("Returning dialogs from cache")
+        return _dialogs_cache
+
+    logger.info("Fetching dialogs from Telegram...")
+    dialogs = []
+    async for dialog in client.get_dialogs():
+        dialogs.append(dialog)
+    _dialogs_cache = dialogs
+    _dialogs_cache_time = now
+    logger.info(f"Cached {len(dialogs)} dialogs")
+
+    logger.info("Fetching global notify settings...")
+    global_settings: dict[str, int] = {}
+    try:
+        for name, input_notify in [
+            ("users", InputNotifyUsers()),
+            ("chats", InputNotifyChats()),
+            ("broadcasts", InputNotifyBroadcasts()),
+        ]:
+            result = await client.invoke(GetNotifySettings(peer=input_notify))
+            mute_until = getattr(result, "mute_until", 0) or 0
+            global_settings[name] = mute_until
+            logger.info(f"Global {name} mute_until: {mute_until}")
+    except Exception as e:
+        logger.warning(f"Failed to fetch global notify settings: {e}")
+    _global_notify_settings = global_settings
+
+    logger.info("Fetching notify exceptions...")
+    exceptions: dict[int, int] = {}
+    try:
+        for input_notify in [
+            InputNotifyUsers(),
+            InputNotifyChats(),
+            InputNotifyBroadcasts(),
+        ]:
+            result = await client.invoke(GetNotifyExceptions(peer=input_notify))
+            updates = cast(list[Any], getattr(result, "updates", []))
+            for update in updates:
+                notify_peer = getattr(update, "peer", None)
+                notify_settings = getattr(update, "notify_settings", None)
+                if notify_peer is None or notify_settings is None:
+                    continue
+
+                peer = getattr(notify_peer, "peer", notify_peer)
+                chat_id = None
+                if hasattr(peer, "user_id"):
+                    chat_id = peer.user_id
+                elif hasattr(peer, "chat_id"):
+                    chat_id = peer.chat_id
+                elif hasattr(peer, "channel_id"):
+                    chat_id = -100 - peer.channel_id
+
+                if chat_id is not None:
+                    mute_until = getattr(notify_settings, "mute_until", 0) or 0
+                    exceptions[chat_id] = mute_until
+    except Exception as e:
+        logger.warning(f"Failed to fetch notify exceptions: {e}")
+    _notify_exceptions_cache = exceptions
+    logger.info(f"Cached {len(exceptions)} notify exceptions")
+
+    return dialogs
+
+
+async def get_cached_dialog_filters() -> list[Any]:
+    global _dialog_filters_cache, _dialog_filters_cache_time
+
+    now = time.time()
+    if _dialog_filters_cache and (now - _dialog_filters_cache_time) < DIALOGS_CACHE_TTL:
+        logger.info("Returning dialog filters from cache")
+        return _dialog_filters_cache
+
+    logger.info("Fetching dialog filters from Telegram...")
+    try:
+        result = await client.invoke(GetDialogFilters())
+        filters = list(cast(list[Any], getattr(result, "filters", [])))
+    except Exception as e:
+        logger.warning(f"Failed to fetch dialog filters: {e}")
+        return []
+
+    _dialog_filters_cache = filters
+    _dialog_filters_cache_time = now
+    logger.info(f"Cached {len(filters)} dialog filters")
+    return filters
+
+
+async def get_cached_folder_memberships() -> dict[int, list[int]]:
+    global _folder_membership_cache, _folder_membership_cache_time
+
+    now = time.time()
+    if (
+        _folder_membership_cache
+        and (now - _folder_membership_cache_time) < DIALOGS_CACHE_TTL
+    ):
+        logger.info("Returning folder memberships from cache")
+        return _folder_membership_cache
+
+    dialogs = await get_cached_dialogs()
+    raw_filters = await get_cached_dialog_filters()
+    memberships = build_folder_membership_map(dialogs, raw_filters)
+    _folder_membership_cache = memberships
+    _folder_membership_cache_time = now
+    logger.info(f"Cached folder memberships for {len(memberships)} chats")
+    return memberships
+
+
+def gc_message_caches() -> None:
+    now = time.time()
+
+    for chat_id in list(_raw_message_cache.keys()):
+        messages = _raw_message_cache[chat_id]
+        stale_ids = [
+            message_id
+            for message_id, (_, fetched_at) in messages.items()
+            if (now - fetched_at) >= MESSAGES_CACHE_TTL
+        ]
+        for message_id in stale_ids:
+            del messages[message_id]
+        if not messages:
+            del _raw_message_cache[chat_id]
+
+    stale_history_keys = [
+        key
+        for key, (_, _, fetched_at) in _history_page_cache.items()
+        if (now - fetched_at) >= MESSAGES_CACHE_TTL
+    ]
+    for key in stale_history_keys:
+        del _history_page_cache[key]
+
+    stale_delta_keys = [
+        key
+        for key, (_, _, fetched_at) in _delta_cache.items()
+        if (now - fetched_at) >= MESSAGES_CACHE_TTL
+    ]
+    for key in stale_delta_keys:
+        del _delta_cache[key]
+
+
+def cache_raw_messages(chat_id: int, messages: list[Any]) -> None:
+    if not messages:
+        return
+
+    now = time.time()
+    chat_cache = _raw_message_cache.setdefault(chat_id, {})
+    for message in messages:
+        chat_cache[message.id] = (message, now)
+
+
+def get_cached_raw_message(chat_id: int, message_id: int) -> Any | None:
+    chat_cache = _raw_message_cache.get(chat_id)
+    if not chat_cache:
+        return None
+
+    cached_entry = chat_cache.get(message_id)
+    if not cached_entry:
+        return None
+
+    message, fetched_at = cached_entry
+    if (time.time() - fetched_at) >= MESSAGES_CACHE_TTL:
+        del chat_cache[message_id]
+        if not chat_cache:
+            del _raw_message_cache[chat_id]
+        return None
+
+    return message
+
+
+async def fetch_raw_messages(chat_id: int, limit: int, offset: int = 0) -> list[Any]:
+    messages = []
+    async for message in client.get_chat_history(chat_id, limit=limit, offset=offset):
+        messages.append(message)
+    cache_raw_messages(chat_id, messages)
+    return messages
+
+
+async def refresh_chat_head(chat_id: int) -> tuple[int | None, list[Any]]:
+    fresh_messages = await fetch_raw_messages(chat_id, HEAD_REFRESH_LIMIT)
+    head_id = fresh_messages[0].id if fresh_messages else None
+    return head_id, fresh_messages
+
+
+async def get_cached_or_fetch_history_page(
+    chat_id: int,
+    limit: int,
+    offset: int,
+) -> list[Any]:
+    gc_message_caches()
+    head_id, _ = await refresh_chat_head(chat_id)
+    cache_key = (chat_id, limit, offset)
+    cached_entry = _history_page_cache.get(cache_key)
+
+    if cached_entry is not None:
+        cached_head_id, cached_messages, fetched_at = cached_entry
+        if (
+            cached_head_id == head_id
+            and (time.time() - fetched_at) < MESSAGES_CACHE_TTL
+        ):
+            cache_raw_messages(chat_id, cached_messages)
+            return cached_messages
+
+    messages = await fetch_raw_messages(chat_id, limit + 1, offset)
+    _history_page_cache[cache_key] = (head_id, messages, time.time())
+    return messages
+
+
+async def get_cached_or_fetch_delta_messages(
+    chat_id: int, since: datetime
+) -> list[Any]:
+    gc_message_caches()
+    head_id, _ = await refresh_chat_head(chat_id)
+    normalized_since = normalize_datetime(since)
+    since_key = normalized_since.isoformat() if normalized_since else "none"
+    cache_key = (chat_id, since_key)
+    cached_entry = _delta_cache.get(cache_key)
+
+    if cached_entry is not None:
+        cached_head_id, cached_messages, fetched_at = cached_entry
+        if (
+            cached_head_id == head_id
+            and (time.time() - fetched_at) < MESSAGES_CACHE_TTL
+        ):
+            cache_raw_messages(chat_id, cached_messages)
+            return cached_messages
+
+    messages: list[Any] = []
+    async for message in client.get_chat_history(chat_id):
+        message_date = normalize_datetime(message.date)
+        if message_date and normalized_since and message_date < normalized_since:
+            break
+        messages.append(message)
+
+    messages.reverse()
+    cache_raw_messages(chat_id, messages)
+    _delta_cache[cache_key] = (head_id, messages, time.time())
+    return messages
+
+
+async def get_dialog_by_chat_id(chat_id: int) -> Dialog | None:
+    dialogs = await get_cached_dialogs()
+    for dialog in dialogs:
+        if dialog.chat.id == chat_id:
+            return dialog
+    return None
+
+
+def build_chat(dialog: Dialog, folder_ids: list[int] | None = None) -> Chat:
+    chat = dialog.chat
+    chat_type = str(chat.type.value) if chat.type else "unknown"
+
+    if chat.id in _notify_exceptions_cache:
+        muted_until = _notify_exceptions_cache[chat.id]
+    elif chat_type in ("private", "bot", "direct"):
+        muted_until = _global_notify_settings.get("users", 0)
+    elif chat_type in ("group", "supergroup", "forum"):
+        muted_until = _global_notify_settings.get("chats", 0)
+    elif chat_type == "channel":
+        muted_until = _global_notify_settings.get("broadcasts", 0)
+    else:
+        muted_until = 0
+
+    return Chat(
+        id=chat.id or 0,
+        title=chat.title or chat.first_name,
+        type=chat_type,
+        chat_type=normalize_chat_type(chat_type),
+        username=chat.username,
+        members_count=chat.members_count,
+        is_pinned=dialog.is_pinned or False,
+        pinned=dialog.is_pinned or False,
+        last_message_date=dialog.top_message.date if dialog.top_message else None,
+        unread_count=dialog.unread_messages_count or 0,
+        is_muted=muted_until != 0,
+        muted=muted_until != 0,
+        archived=bool(dialog.folder_id),
+        folder_id=getattr(dialog, "folder_id", None),
+        folder_ids=folder_ids,
+        last_online_at=getattr(chat, "last_online_date", None),
+    )
+
+
+def build_message(message, chat_id: int, dialog: Dialog | None = None) -> Message:
+    from_me = getattr(message, "outgoing", None)
+    if dialog is None:
+        is_read = None
+    elif from_me:
+        read_max_id = getattr(dialog, "read_outbox_max_id", None)
+        is_read = None if read_max_id is None else message.id <= read_max_id
+    else:
+        read_max_id = getattr(dialog, "read_inbox_max_id", None)
+        is_read = None if read_max_id is None else message.id <= read_max_id
+
+    return Message(
+        id=message.id,
+        date=message.date,
+        text=message.text,
+        from_user=message.from_user.first_name if message.from_user else None,
+        chat_id=chat_id,
+        from_me=from_me,
+        is_outgoing=from_me,
+        reply_to_message_id=getattr(message, "reply_to_message_id", None),
+        quoted_text=None,
+        reply_snippet=None,
+        edited_at=getattr(message, "edit_date", None),
+        is_read=is_read,
+        attachments=build_attachments(message),
+    )
+
+
+async def enrich_reply_fields(
+    messages: list[Message],
+    chat_id: int,
+    reply_cache: dict[int, str | None],
+) -> list[Message]:
+    messages_by_id: dict[int, Message] = {message.id: message for message in messages}
+    missing_reply_ids: list[int] = []
+
+    for message in messages:
+        reply_to_message_id = message.reply_to_message_id
+        if not reply_to_message_id:
+            continue
+        if reply_to_message_id in messages_by_id:
+            continue
+        if reply_to_message_id in reply_cache:
+            continue
+        cached_reply = get_cached_raw_message(chat_id, reply_to_message_id)
+        if cached_reply is not None:
+            reply_cache[reply_to_message_id] = extract_message_snippet(cached_reply)
+            continue
+        if reply_to_message_id not in missing_reply_ids:
+            missing_reply_ids.append(reply_to_message_id)
+
+    for i in range(0, len(missing_reply_ids), 200):
+        batch_ids = missing_reply_ids[i : i + 200]
+        fetched_replies = await client.get_messages(chat_id, batch_ids)
+        fetched_replies_list = list(fetched_replies)
+        cache_raw_messages(chat_id, fetched_replies_list)
+        for reply in fetched_replies_list:
+            reply_cache[reply.id] = extract_message_snippet(reply)
+        for reply_id in batch_ids:
+            reply_cache.setdefault(reply_id, None)
+
+    for message in messages:
+        reply_to_message_id = message.reply_to_message_id
+        if not reply_to_message_id:
+            continue
+
+        reply_message = messages_by_id.get(reply_to_message_id)
+        if reply_message is not None:
+            reply_snippet = extract_message_snippet(reply_message)
+        else:
+            reply_snippet = reply_cache.get(reply_to_message_id)
+
+        message.quoted_text = reply_snippet
+        message.reply_snippet = reply_snippet
+
+    return messages
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    os.makedirs("session", exist_ok=True)
+    logger.info("Starting Telegram client...")
+    await client.start()
+    logger.info("Telegram client started")
+    yield
+    logger.info("Stopping Telegram client...")
+    await client.stop()
+    logger.info("Telegram client stopped")
+
+
+app = FastAPI(lifespan=lifespan, default_response_class=PrettyJSONResponse)
+app.add_middleware(AccessLogMiddleware)
+
+
+@app.exception_handler(Exception)
+async def unhandled_exception_handler(_: Request, exc: Exception):
+    details = "".join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+    logger.exception("Unhandled exception")
+    return PlainTextResponse(details, status_code=500)
+
+
+@app.get(
+    "/folders", response_model=list[DialogFolder], response_model_exclude_none=True
+)
+async def get_folders() -> list[DialogFolder]:
+    raw_filters = await get_cached_dialog_filters()
+    folders: list[DialogFolder] = []
+
+    for raw_filter in raw_filters:
+        folder = build_dialog_folder(raw_filter)
+        if folder is not None:
+            folders.append(folder)
+
+    return sorted(folders, key=lambda folder: folder.id)
+
+
+@app.get("/chats", response_model_exclude_none=True)
+async def get_chats(
+    limit: int = Query(default=50, ge=1),
+    offset: int = Query(default=0, ge=0),
+    archived: bool | None = Query(default=None),
+    chat_type: str | None = Query(default=None),
+    folder_id: int | None = Query(default=None),
+) -> PaginatedChats:
+    validate_limit(limit)
+    dialogs = await get_cached_dialogs()
+    folder_memberships = (
+        await get_cached_folder_memberships() if folder_id is not None else {}
+    )
+
+    if folder_id is not None:
+        folders = await get_folders()
+        valid_folder_ids = {folder.id for folder in folders}
+        if folder_id not in valid_folder_ids:
+            raise HTTPException(
+                status_code=400, detail=f"Unknown folder_id: {folder_id}"
+            )
+
+    chats = []
+    matched_count = 0
+
+    for dialog in dialogs:
+        dialog_chat_id = dialog.chat.id or 0
+        chat = build_chat(dialog, folder_memberships.get(dialog_chat_id))
+
+        if archived is not None and chat.archived != archived:
+            continue
+
+        if not matches_chat_type_filter(chat, chat_type):
+            continue
+
+        if folder_id is not None and folder_id not in (chat.folder_ids or []):
+            continue
+
+        if matched_count < offset:
+            matched_count += 1
+            continue
+
+        chats.append(chat)
+        if len(chats) >= limit + 1:
+            break
+
+    has_more = len(chats) > limit
+
+    total_matching = 0
+    for dialog in dialogs:
+        dialog_chat_id = dialog.chat.id or 0
+        chat = build_chat(dialog, folder_memberships.get(dialog_chat_id))
+        if archived is not None and chat.archived != archived:
+            continue
+        if not matches_chat_type_filter(chat, chat_type):
+            continue
+        if folder_id is not None and folder_id not in (chat.folder_ids or []):
+            continue
+        total_matching += 1
+
+    remaining_count = max(0, total_matching - offset - len(chats[:limit]))
+    return PaginatedChats(
+        items=chats[:limit],
+        limit=limit,
+        offset=offset,
+        has_more=has_more,
+        remaining_count=remaining_count,
+    )
+
+
+@app.get("/chats/{chat_id}/messages", response_model_exclude_none=True)
+async def get_chat_messages(
+    chat_id: int,
+    limit: int = Query(default=50, ge=1),
+    offset: int = Query(default=0, ge=0),
+) -> PaginatedMessages:
+    validate_limit(limit)
+    dialog = await get_dialog_by_chat_id(chat_id)
+    messages: list[Message] = []
+    folder_memberships = await get_cached_folder_memberships()
+
+    raw_messages = await get_cached_or_fetch_history_page(chat_id, limit, offset)
+    for msg in raw_messages:
+        messages.append(build_message(msg, chat_id, dialog))
+
+    reply_cache: dict[int, str | None] = {}
+    messages = await enrich_reply_fields(messages, chat_id, reply_cache)
+    has_more = len(messages) > limit
+    chat = build_chat(dialog, folder_memberships.get(chat_id)) if dialog else None
+
+    return PaginatedMessages(
+        chat=chat,
+        items=messages[:limit],
+        limit=limit,
+        offset=offset,
+        has_more=has_more,
+    )
+
+
+@app.get("/chats/{chat_id}/delta", response_model_exclude_none=True)
+async def get_chat_messages_delta(
+    chat_id: int,
+    since: datetime = Query(...),
+    limit: int = Query(default=50, ge=0),
+    offset: int = Query(default=0, ge=0),
+) -> PaginatedMessages:
+    validate_limit(limit)
+    dialog = await get_dialog_by_chat_id(chat_id)
+    messages: list[Message] = []
+    folder_memberships = await get_cached_folder_memberships()
+
+    raw_messages = await get_cached_or_fetch_delta_messages(chat_id, since)
+    for msg in raw_messages:
+        messages.append(build_message(msg, chat_id, dialog))
+
+    reply_cache: dict[int, str | None] = {}
+    messages = await enrich_reply_fields(messages, chat_id, reply_cache)
+
+    if limit == 0:
+        paginated_messages = messages[offset:]
+        has_more = False
+        remaining_count = 0
+    else:
+        paginated_messages = messages[offset : offset + limit + 1]
+        has_more = len(paginated_messages) > limit
+        remaining_count = max(
+            0, len(messages) - offset - len(paginated_messages[:limit])
+        )
+
+    chat = build_chat(dialog, folder_memberships.get(chat_id)) if dialog else None
+    items = paginated_messages if limit == 0 else paginated_messages[:limit]
+    return PaginatedMessages(
+        chat=chat,
+        items=items,
+        limit=limit,
+        offset=offset,
+        has_more=has_more,
+        remaining_count=remaining_count,
+    )
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..1780054
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,12 @@
+[project]
+name = "tg-proxy"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi",
+    "kurigram",
+    "uvicorn",
+]
+
+[tool.uv]
+package = false
diff --git a/skill/client.js b/skill/client.js
new file mode 100644
index 0000000..b154f45
--- /dev/null
+++ b/skill/client.js
@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+/**
+ * Telegram Reader Client — удобный JS интерфейс к tg-proxy.wzray.com
+ *
+ * Usage:
+ *   node tg-client.js get-folders
+ *   node tg-client.js get-chats [--limit 50] [--offset 0] [--archived true|false] [--chat-type direct|bot|group|channel] [--folder-id N]
+ *   node tg-client.js get-messages <chat_id> [--limit 50] [--offset 0]
+ *   node tg-client.js delta <chat_id> <since> [--limit 50] [--offset 0]
+ *
+ * Examples:
+ *   node tg-client.js get-folders
+ *   node tg-client.js get-chats --limit 100 --chat-type group --folder-id 2
+ *   node tg-client.js get-messages 5880803391 --limit 10
+ *   node tg-client.js delta 5880803391 "2026-02-16T09:00:00Z"
+ */
+
+const https = require('https');
+
+const BASE_URL = 'tg-proxy.wzray.com';
+
+function request(path, query = {}) {
+  const queryString = new URLSearchParams(query).toString();
+  const url = `${path}${queryString ? '?' + queryString : ''}`;
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(
+      {
+        hostname: BASE_URL,
+        path: url,
+        method: 'GET',
+        headers: { 'User-Agent': 'openclaw-telegram-reader/1.0' }
+      },
+      (res) => {
+        let data = '';
+        res.on('data', (chunk) => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error(`JSON parse error: ${e.message}`));
+          }
+        });
+      }
+    );
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function getFlagValue(args, flag, fallback) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return fallback;
+  const parsed = parseInt(args[idx + 1], 10);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+
+function getStringFlagValue(args, flag, fallback = undefined) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return fallback;
+  return args[idx + 1];
+}
+
+function getBooleanFlagValue(args, flag, fallback = undefined) {
+  const value = getStringFlagValue(args, flag, undefined);
+  if (value === undefined) return fallback;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return fallback;
+}
+
+/**
+ * Get list of chats
+ */
+async function getChats(limit = 50, offset = 0, options = {}) {
+  const query = { limit, offset };
+  if (options.archived !== undefined) query.archived = String(options.archived);
+  if (options.chatType) query.chat_type = options.chatType;
+  if (options.folderId !== undefined) query.folder_id = String(options.folderId);
+  const result = await request('/chats', query);
+  return result;
+}
+
+/**
+ * Get list of folders
+ */
+async function getFolders() {
+  const result = await request('/folders');
+  return result;
+}
+
+/**
+ * Get messages in a specific chat
+ */
+async function getChatMessages(chatId, limit = 50, offset = 0) {
+  const result = await request(`/chats/${chatId}/messages`, { limit, offset });
+  return result;
+}
+
+/**
+ * Get messages delta since timestamp for one chat
+ */
+async function getChatDelta(chatId, since, limit = 50, offset = 0) {
+  const result = await request(`/chats/${chatId}/delta`, {
+    since,
+    limit,
+    offset
+  });
+  return result;
+}
+
+/**
+ * Filter chats by criteria
+ */
+function filterChats(chats, criteria) {
+  const now = new Date();
+  const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+  return chats.filter(chat => {
+    // Not muted
+    if (criteria.notMuted && chat.is_muted) return false;
+
+    // Pinned
+    if (criteria.pinned && !chat.is_pinned) return false;
+
+    // Active last week
+    if (criteria.activeLastWeek) {
+      if (!chat.last_message_date) return false;
+      const lastMsg = new Date(chat.last_message_date);
+      if (lastMsg < weekAgo) return false;
+    }
+
+    // Inactive (no messages in last week)
+    if (criteria.inactiveLastWeek) {
+      if (!chat.last_message_date) return true; // no messages = inactive
+      const lastMsg = new Date(chat.last_message_date);
+      if (lastMsg >= weekAgo) return false; // has recent messages, skip
+    }
+
+    // Type filter
+    if (criteria.type) {
+      if (criteria.type === 'direct' && chat.type !== 'private') return false;
+      else if (criteria.type === 'bot' && chat.type !== 'bot') return false;
+      else if (criteria.type === 'group' && !['group', 'supergroup', 'forum'].includes(chat.type)) return false;
+      else if (criteria.type === 'channel' && chat.type !== 'channel') return false;
+    }
+
+    // Archived filter
+    if (criteria.archived !== undefined && chat.archived !== criteria.archived) return false;
+
+    // Folder filter
+    if (criteria.folderId !== undefined && !(chat.folder_ids || []).includes(criteria.folderId)) return false;
+
+    // Has unread
+    if (criteria.hasUnread && chat.unread_count === 0) return false;
+
+    return true;
+  });
+}
+
+/**
+ * Filter messages by importance
+ */
+function filterImportantMessages(messages) {
+  const keywords = ['важно', 'срочно', 'deadline', 'сегодня', '@wzray', 'визирей'];
+  const lowerKeywords = keywords.map(k => k.toLowerCase());
+
+  return messages.filter(msg => {
+    if (!msg.text) return false;
+
+    const text = msg.text.toLowerCase();
+
+    // Check for keywords
+    if (lowerKeywords.some(kw => text.includes(kw))) return true;
+
+    // Mentions (basic check)
+    if (text.includes('@')) return true;
+
+    return false;
+  });
+}
+
+/**
+ * CLI
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.log('Usage:');
+      console.log('  node tg-client.js get-folders');
+      console.log('  node tg-client.js get-chats [--limit N] [--offset N] [--archived true|false] [--chat-type direct|bot|group|channel] [--folder-id N]');
+    console.log('  node tg-client.js get-messages <chat_id> [--limit N] [--offset N]');
+    console.log('  node tg-client.js delta <chat_id> <since> [--limit N] [--offset N]');
+    console.log('  node tg-client.js filter-chats [--pinned] [--not-muted] [--active-last-week]');
+    console.log('');
+    console.log('Examples:');
+      console.log('  node tg-client.js get-folders');
+      console.log('  node tg-client.js get-chats --limit 100 --chat-type group --folder-id 2');
+    console.log('  node tg-client.js get-messages 5880803391 --limit 10');
+    console.log('  node tg-client.js delta 5880803391 "2026-02-16T09:00:00Z"');
+    console.log('  node tg-client.js filter-chats --pinned --not-muted --type=direct');
+    process.exit(0);
+  }
+
+  try {
+      const [command] = args;
+
+      switch (command) {
+      case 'get-folders': {
+        const result = await getFolders();
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'get-chats': {
+        const limit = getFlagValue(args, '--limit', 50);
+        const offset = getFlagValue(args, '--offset', 0);
+        const archived = getBooleanFlagValue(args, '--archived', undefined);
+        const chatType = getStringFlagValue(args, '--chat-type', undefined);
+        const folderId = getFlagValue(args, '--folder-id', undefined);
+        const result = await getChats(limit, offset, { archived, chatType, folderId });
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'get-messages': {
+        const chatId = args[1];
+        if (!chatId) throw new Error('chat_id is required');
+        const limit = getFlagValue(args, '--limit', 50);
+        const offset = getFlagValue(args, '--offset', 0);
+        const result = await getChatMessages(chatId, limit, offset);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'delta': {
+        const chatId = args[1];
+        const since = args[2];
+        if (!chatId || !since) throw new Error('chat_id and since are required');
+        const limit = getFlagValue(args, '--limit', 50);
+        const offset = getFlagValue(args, '--offset', 0);
+        const result = await getChatDelta(chatId, since, limit, offset);
+        console.log(JSON.stringify(result, null, 2));
+        break;
+      }
+
+      case 'filter-chats': {
+        const limit = getFlagValue(args, '--limit', 100);
+        const result = await getChats(limit);
+
+        if (!result || !result.items) {
+          throw new Error('Invalid response from API');
+        }
+
+        const criteria = {
+          pinned: args.includes('--pinned'),
+          notMuted: args.includes('--not-muted'),
+          activeLastWeek: args.includes('--active-last-week'),
+          inactiveLastWeek: args.includes('--inactive-last-week'),
+          hasUnread: args.includes('--has-unread'),
+          type: args.find(a => a.startsWith('--type='))?.split('=')[1],
+          folderId: args.find(a => a.startsWith('--folder-id='))
+            ? parseInt(args.find(a => a.startsWith('--folder-id='))?.split('=')[1], 10)
+            : undefined,
+          archived: args.find(a => a.startsWith('--archived='))?.split('=')[1] === 'true'
+            ? true
+            : args.find(a => a.startsWith('--archived='))?.split('=')[1] === 'false'
+              ? false
+              : undefined
+        };
+
+        const filtered = filterChats(result.items, criteria);
+        console.log(JSON.stringify(filtered, null, 2));
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown command: ${command}`);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// Run CLI if called directly
+if (require.main === module) {
+  main();
+}
+
+// Export for use as a module
+module.exports = {
+  getFolders,
+  getChats,
+  getChatMessages,
+  getChatDelta,
+  filterChats,
+  filterImportantMessages
+};
diff --git a/skill/skill.md b/skill/skill.md
new file mode 100644
index 0000000..b8cd7bb
--- /dev/null
+++ b/skill/skill.md
@@ -0,0 +1,118 @@
+---
+name: telegram-reader
+description: Read-only access to Telegram via tg-proxy API. Use when the user asks about recent messages, wants to search chats, or needs inbox summary.
+---
+
+# Telegram Reader
+
+Read-only interface to wzray's Telegram via `https://tg-proxy.wzray.com`.
+
+## Endpoints
+
+Base URL: `https://tg-proxy.wzray.com`
+
+### 1. Get Chats
+```bash
+curl -s "https://tg-proxy.wzray.com/chats?limit=50&offset=0"
+```
+Returns: `{"items": [{id, title, type, chat_type, muted, archived, folder_id, folder_ids, pinned, ...}], "limit", "offset", "has_more", "remaining_count"}`
+
+Supported query params:
+- `limit`
+- `offset`
+- `archived=true|false`
+- `chat_type=direct|bot|group|channel`
+- `folder_id` — filter chats by Telegram folder/dialog filter id (get list from `/folders`)
+
+### 2. Get Folders
+```bash
+curl -s "https://tg-proxy.wzray.com/folders"
+```
+Returns: `[{id, title, type, icon_emoji, pinned_chat_ids, include_chat_ids, exclude_chat_ids, contacts, non_contacts, groups, broadcasts, bots, exclude_muted, exclude_read, exclude_archived, has_my_invites}]`
+
+### 3. Get Messages in Chat
+```bash
+curl -s "https://tg-proxy.wzray.com/chats/{chat_id}/messages?limit=50&offset=0"
+```
+Returns: `{"chat": {...}, "items": [{id, date, text, from_user, chat_id, from_me, is_outgoing, reply_to_message_id, quoted_text, reply_snippet, edited_at, is_read, attachments}], "limit", "offset", "has_more"}`
+
+### 4. Get Messages Delta
+```bash
+curl -s "https://tg-proxy.wzray.com/chats/{chat_id}/delta?since=2026-02-16T06:00:00Z&limit=50&offset=0"
+```
+Returns: `{"chat": {...}, "items": [...], "limit", "offset", "has_more", "remaining_count"}`
+
+Notes:
+- `since` is required for `delta`
+- `delta` returns messages in chronological order
+- `offset` is applied inside the filtered `since` window
+- `remaining_count` is present where the server can compute it cheaply and accurately
+- `null` fields are omitted from JSON output
+- responses are pretty-printed JSON
+
+## State
+
+State stored in: `runtime/telegram-reader/state.json` (gitignored, persists locally)
+
+```json
+{
+  "last_check": "2026-02-16T10:30:00Z",
+  "watched_chats": [-1003680985286, ...],
+  "watched_names": {"-1003680985286": "is-tech-y28", ...},
+  "last_message_ids": {}
+}
+```
+
+## JS Client
+
+`skills/scripts/telegram-reader/tg-client.js` — удобный CLI для API:
+
+```bash
+# List folders
+node skills/scripts/telegram-reader/tg-client.js get-folders
+
+# List chats
+node skills/scripts/telegram-reader/tg-client.js get-chats --limit 50
+
+# Only archived groups
+node skills/scripts/telegram-reader/tg-client.js get-chats --archived true --chat-type group
+
+# Filter chats by folder
+node skills/scripts/telegram-reader/tg-client.js get-chats --folder-id 2
+
+# Filter chats (client-side)
+node skills/scripts/telegram-reader/tg-client.js filter-chats --active-last-week --not-muted --type=direct
+
+# Get delta
+node skills/scripts/telegram-reader/tg-client.js delta 5880803391 "2026-02-16T00:00:00Z"
+```
+
+## Behavior
+
+### On Heartbeat (hourly)
+1. Load state
+2. For each watched chat, get delta since `last_check`
+3. Filter important messages:
+   - Mentions (@wzray)
+   - Keywords: "важно", "срочно", "deadline", "сегодня"
+   - Unread DMs
+4. Summarize and notify if significant
+5. Update `last_check` to now
+
+### When User Asks
+- "Что нового?" → run delta since last_check, summarize
+- "Что писал [кто-то]?" → search in recent messages
+- "Покажи чаты" → list chats from API
+
+## Priority Filters
+
+For heartbeat summaries, prioritize:
+1. DMs with unread/unanswered messages
+2. Messages mentioning user
+3. Messages with urgency keywords
+4. Pinned/important chats
+
+Ignore:
+- Channels (unless user explicitly watches them)
+- Muted chats
+- Large groups with high traffic (unless mentioned)
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000..612b81b
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,293 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.135.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e7/7b/f8e0211e9380f7195ba3f3d40c292594fd81ba8ec4629e3854c353aaca45/fastapi-0.135.1.tar.gz", hash = "sha256:d04115b508d936d254cea545b7312ecaa58a7b3a0f84952535b4c9afae7668cd", size = 394962, upload-time = "2026-03-01T18:18:29.369Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/72/42e900510195b23a56bde950d26a51f8b723846bfcaa0286e90287f0422b/fastapi-0.135.1-py3-none-any.whl", hash = "sha256:46e2fc5745924b7c840f71ddd277382af29ce1cdb7d5eab5bf697e3fb9999c9e", size = 116999, upload-time = "2026-03-01T18:18:30.831Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "kurigram"
+version = "2.2.19"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyaes" },
+    { name = "pysocks" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/aa/3c/0c5469b66ea5ad887d7b877b08113726e6d67ef622442c8dd7adbcf9e352/kurigram-2.2.19.tar.gz", hash = "sha256:6d86a870834527e91c6308f8307796a985a437a39e8112e3bc7a649c6d1f7daa", size = 557685, upload-time = "2026-02-20T09:36:08.844Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/00/7b4354395f7adcbf862af968a989f45f690542c4f0b458dc4cc7c10d2a40/kurigram-2.2.19-py3-none-any.whl", hash = "sha256:fa255cfc1aaa4b9be9ed3120af612a460a3e1c78d872b6090717ea77ca31dbf8", size = 5494166, upload-time = "2026-02-20T09:36:07.095Z" },
+]
+
+[[package]]
+name = "pyaes"
+version = "1.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/44/66/2c17bae31c906613795711fc78045c285048168919ace2220daa372c7d72/pyaes-1.6.1.tar.gz", hash = "sha256:02c1b1405c38d3c370b085fb952dd8bea3fadcee6411ad99f312cc129c536d8f", size = 28536, upload-time = "2017-09-20T21:17:54.23Z" }
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pysocks"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/11/293dd436aea955d45fc4e8a35b6ae7270f5b8e00b53cf6c024c83b657a11/PySocks-1.7.1.tar.gz", hash = "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0", size = 284429, upload-time = "2019-09-20T02:07:35.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/59/b4572118e098ac8e46e399a1dd0f2d85403ce8bbaad9ec79373ed6badaf9/PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5", size = 16725, upload-time = "2019-09-20T02:06:22.938Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
+]
+
+[[package]]
+name = "tg-proxy"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "kurigram" },
+    { name = "uvicorn" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi" },
+    { name = "kurigram" },
+    { name = "uvicorn" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.42.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e3/ad/4a96c425be6fb67e0621e62d86c402b4a17ab2be7f7c055d9bd2f638b9e2/uvicorn-0.42.0.tar.gz", hash = "sha256:9b1f190ce15a2dd22e7758651d9b6d12df09a13d51ba5bf4fc33c383a48e1775", size = 85393, upload-time = "2026-03-16T06:19:50.077Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0a/89/f8827ccff89c1586027a105e5630ff6139a64da2515e24dafe860bd9ae4d/uvicorn-0.42.0-py3-none-any.whl", hash = "sha256:96c30f5c7abe6f74ae8900a70e92b85ad6613b745d4879eb9b16ccad15645359", size = 68830, upload-time = "2026-03-16T06:19:48.325Z" },
+]