python-vk-bot 0.1.0__py3-none-any.whl

python_vk_bot/.agents/skills/telegram-to-vk/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: telegram-to-vk
+description: Migrate python-telegram-bot applications to VK community bots with python-vk-bot, preserving business logic while adapting handlers, state, messaging and delivery to supported VK interfaces.
+---
+
+# Migrate a Telegram bot to VK
+
+Work in the user's bot project. Read its `AGENTS.md` and approval rules before changing files.
+Do not modify python-vk-bot itself unless explicitly requested.
+
+1. Inspect the source project's installed/locked python-telegram-bot version, initialization,
+   configuration, handlers, filters, conversations, context/state, scheduled jobs, media,
+   error handling, integrations and business services. Do not assume the source uses current PTB.
+2. Inspect the installed or checked-out python-vk-bot version and its public interfaces.
+   Read [the migration mapping](references/migration-mapping.md), then verify each relevant
+   mapping against that version's sources. The reference is a baseline, not permission to
+   invent classes, methods, filters or features.
+3. Build a source-to-target inventory with supported equivalents, behavior differences,
+   unsupported functionality and manual configuration. Verify version-dependent VK claims
+   against current official documentation; cite sources and label uncertainties. Distinguish
+   the library's missing wrapper from a capability absent on the platform.
+4. Propose a migration that keeps platform-independent business logic and adapts the actual
+   Telegram integration points. Address peers/users/communities, message IDs, commands,
+   keyboards, button events, media, editing/deletion, permissions, limits, state and delivery.
+   Avoid speculative shared-platform abstractions; migration is more than import replacement.
+5. Obtain required approval for the migration, affected files and intentional behavior changes.
+   Follow local approval gates; test changes require approval of the corresponding main code
+   and separate test-edit authorization. Never silently remove unsupported functionality.
+6. Implement the approved scope with supported interfaces, explicit configuration and safe
+   token handling. Preserve async behavior, cancellation and owned-resource cleanup. Keep
+   Long Poll and Callback HTTP delivery distinct from interactive message-event handling.
+7. Verify initialization, commands/messages, button events, state, errors and graceful shutdown
+   as applicable. Run existing checks; use mocked VK responses for automated verification.
+   Do not require live credentials or send messages as part of ordinary verification.
+
+Report original components, implemented VK replacements, unsupported functionality,
+behavior differences, required manual configuration and verification results. Explain
+what remains blocked or unverified. Identical behavior across platforms is not guaranteed.

python_vk_bot/.agents/skills/telegram-to-vk/references/migration-mapping.md

@@ -0,0 +1,159 @@
+# Telegram to VK migration mapping
+
+Baseline inspected on **2026-10-31**: python-vk-bot **0.1.0** source tree and
+[PTB 22.8](https://docs.python-telegram-bot.org/en/v22.8/telegram.ext.html).
+Inspect the user's actual installed versions before applying this mapping. This file travels
+with the Python package and does not require repository documentation to be installed.
+
+## Components
+
+| PTB component | Current python-vk-bot interface | Adaptation |
+| --- | --- | --- |
+| Application / ApplicationBuilder | `Application(bot, group_id)` | Direct construction; no builder. `run_polling()` must be awaited. |
+| Bot | `Bot(token, api_version=..., timeout=...)` | Community token; async context manager; methods use VK identifiers. |
+| Configuration | `BotSettings()` | Reads VK_TOKEN and VK_GROUP_ID; optional explicit dotenv loading. Pass values to constructors. |
+| Update | `Update.message`, `Update.message_event`, `Update.object` | VK events; unknown objects retained. No effective_message/chat aliases. |
+| CallbackContext | `Context` | user_data, peer_data, bot_data; process-local state, no chat_data or args. |
+| CommandHandler | `CommandHandler("start", callback)` | Exact /start token; no Telegram mention parsing. Parse arguments explicitly. |
+| MessageHandler | `MessageHandler(callback, predicate=...)` | Callback comes first; only message-bearing updates. |
+| filters | `filters.ALL`, `TEXT`, `LOCATION`, `Regex`, `Filter` | Small synchronous subset; supports &, \| and ~. No COMMAND filter. |
+| CallbackQueryHandler | `MessageEventHandler(callback, predicate=...)` | Handles VK message_event; payload shape and answer identifiers differ. |
+| ConversationHandler | No built-in equivalent | Explicit state transitions in the bot project; design persistence if required. |
+| JobQueue | No built-in scheduler | Reuse an existing scheduler or propose one; manage task lifetime explicitly. |
+| Persistence | No built-in backend | In-memory context does not survive restart; adapt the application's storage. |
+| Error callbacks | `Application.add_error_handler(callback)` | Async `(update, context)`; update may be None, exception is context.error; errors propagate. |
+| Updater / webhook delivery | `LongPoll` / `Callback` | Different VK delivery/acknowledgement semantics; choose one mode per Application. |
+| Inline/reply keyboard | `Keyboard(buttons=..., inline=...)` | VK action dictionaries, not Telegram button objects. |
+| send_message / reply_text | `Bot.send_message(peer_id, text, ...)` | Returns an integer ID; Message has no reply_text method. |
+| Edit / forward | `Bot.edit_message` / `Bot.forward_message` | Explicit peer and correct identifier scope; forwarding uses the source peer. |
+| Media / deletion | Attachment references supported; no upload/delete wrappers | Do not promise uploads or delete_message; raw Bot.request needs separately verified VK methods. |
+
+For implementation details inspect the installed package's `__init__.py`, `application.py`,
+`handlers.py`, `context.py`, `filters.py`, `bot.py`, `models/` and `callback.py`.
+
+## Working command and message example
+
+Run with Python 3.14 and VK_TOKEN/VK_GROUP_ID configured. Enable community messaging, Bots
+Long Poll and message_new first. This example replies only to received messages.
+
+```python
+import asyncio
+
+from python_vk_bot import (
+    Application,
+    Bot,
+    BotSettings,
+    CommandHandler,
+    Context,
+    MessageHandler,
+    Update,
+    filters,
+)
+
+
+def make_reply(text: str) -> str:
+    # Keep platform-independent business logic outside handlers.
+    return f"You said: {text}"
+
+
+async def start(update: Update, context: Context) -> None:
+    if update.message is not None:
+        await context.bot.send_message(update.message.peer_id, "Send some text.")
+
+
+async def echo(update: Update, context: Context) -> None:
+    if update.message is not None:
+        reply = make_reply(update.message.text)
+        await context.bot.send_message(update.message.peer_id, reply)
+
+
+async def main() -> None:
+    settings = BotSettings()
+    bot = Bot(settings.token, api_version=settings.api_version, timeout=settings.timeout)
+    app = Application(bot, settings.group_id)
+    app.add_handler(CommandHandler("start", start))
+    app.add_handler(MessageHandler(echo, predicate=filters.TEXT))
+    await app.run_polling(wait=settings.polling_wait)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Handlers run serially, taking the first match in each numeric group. Registration order
+above prevents /start from also reaching echo in the same group. Other slash commands
+still reach echo: add explicit command policy if the source bot excluded all commands.
+In an existing event loop, await `main()` instead of calling `asyncio.run()`.
+
+## Button-event answer
+
+This registration helper operates on an existing Application. Enable message_event for
+the chosen delivery mode and supply valid VK callback buttons separately.
+
+```python
+from python_vk_bot import Application, Context, MessageEventHandler, Update
+
+
+async def answer_button(update: Update, context: Context) -> None:
+    event = update.message_event
+    if event is not None:
+        await context.bot.send_message_event_answer(event.event_id, event.user_id, event.peer_id)
+
+
+def register_button_handler(app: Application) -> None:
+    app.add_handler(MessageEventHandler(answer_button))
+```
+
+Use the object's `event.event_id` for the answer, not the envelope `update.event_id`.
+The library preserves `event.payload` as JSON, including strings; validate the application's
+expected shape before routing actions. Do not assume Telegram callback_data semantics.
+
+## Platform and lifecycle pitfalls
+
+- A message's `peer_id` identifies the destination conversation; `from_id` identifies its
+  author. Keep VK identities separate from Telegram IDs and explicitly map existing users.
+- `id` and `conversation_message_id` have different scopes. `edit_message` takes exactly one
+  of `message_id` or `conversation_message_id`; the latter is serialized as VK's `cmid`.
+- Keyboard action dictionaries and media attachment references are VK data. Telegram file
+  IDs, entities and parse modes cannot be copied as working VK structures.
+- Community tokens require appropriate permissions and conversation access. Do not assume
+  the bot can initiate arbitrary conversations or that Telegram recipients opted into VK.
+- Long Poll consumes batches and can lose remaining events on cancellation/crash. Callback
+  acknowledges successful processing and can redeliver after failures. Bounded in-memory
+  deduplication does not prevent repeated partial side effects or survive restarts.
+- API mutations are not automatically retried. For a deliberate send retry, preserve the
+  operation's nonzero int32 random_id and account for VK's documented deduplication limits.
+  Polling backoff settings are not platform rate limits.
+- Application owns Bot's lifecycle; an injected HTTPX client remains caller-owned. Await
+  cancellation/cleanup and ensure application-owned scheduler tasks end before resources close.
+- Context state is process-local. Choose per-user, per-peer or compound keys deliberately;
+  durable conversations and multi-worker consistency require application-level design.
+- Callback HTTP delivery is distinct from message_event button handling. The optional ASGI
+  receiver requires the callback extra, secret, confirmation code and HTTPS deployment.
+- Do not log tokens, context dictionaries, raw exceptions or complete updates. Use harmless
+  placeholders and mocked HTTP/event delivery in verification.
+
+## Shared logic and migration report
+
+Keep business services independent of platform Update/Context objects. Adapt input and output
+at existing handler boundaries, preserve integrations, and introduce shared adapters only if
+both applications need them. Record explicit decisions for unsupported workflows, scheduling,
+uploads, persistence and Telegram-only features instead of silently dropping them.
+
+For each migrated component report its source version/interface, VK replacement, differences,
+manual setup, checks and remaining work. Verify shutdown and error paths as well as happy paths.
+
+## Official references
+
+- [PTB Application](https://docs.python-telegram-bot.org/en/v22.8/telegram.ext.application.html)
+- [PTB CallbackContext](https://docs.python-telegram-bot.org/en/v22.8/telegram.ext.callbackcontext.html)
+- [VK API versions](https://dev.vk.com/ru/reference/versions)
+- [VK messages.send](https://dev.vk.com/ru/method/messages.send)
+- [VK messages.edit](https://dev.vk.com/ru/method/messages.edit)
+- [VK message-event answers](https://dev.vk.com/ru/method/messages.sendMessageEventAnswer)
+- [Bots Long Poll](https://dev.vk.com/ru/api/bots-long-poll/getting-started)
+- [Callback API](https://dev.vk.com/ru/api/callback/getting-started)
+
+Recheck applicable official VK documentation before version-dependent migration work.
+This mapping describes library interfaces, not a guarantee of live-token permissions or
+complete VK API coverage.

python_vk_bot/__init__.py

@@ -0,0 +1,30 @@
+"""An async framework for VK community bots."""
+
+from . import filters
+from .application import Application
+from .bot import Bot
+from .callback import Callback
+from .context import Context
+from .handlers import CommandHandler, Handler, MessageEventHandler, MessageHandler
+from .long_poll import LongPoll
+from .models import Keyboard, Message, MessageEvent, Update, User
+from .settings import BotSettings
+
+__all__ = [
+    "Application",
+    "Bot",
+    "BotSettings",
+    "Callback",
+    "CommandHandler",
+    "Context",
+    "Handler",
+    "Keyboard",
+    "LongPoll",
+    "Message",
+    "MessageEvent",
+    "MessageEventHandler",
+    "MessageHandler",
+    "Update",
+    "User",
+    "filters",
+]

python_vk_bot/_config.py

@@ -0,0 +1,22 @@
+"""Shared constraints for explicit configuration and environment-backed settings."""
+
+from typing import Annotated
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+DEFAULT_API_VERSION = "5.199"
+DEFAULT_TIMEOUT = 40.0
+
+type Token = Annotated[SecretStr, Field(min_length=1)]
+type APIVersion = Annotated[str, Field(pattern=r"^\d+\.\d+$")]
+type RequestTimeout = Annotated[float, Field(gt=0, allow_inf_nan=False)]
+
+
+class TransportConfig(BaseModel):
+    """Explicit transport values; never read environment variables or files."""
+
+    model_config = ConfigDict(frozen=True, hide_input_in_errors=True)
+
+    token: Token = Field(repr=False)
+    api_version: APIVersion = DEFAULT_API_VERSION
+    timeout: RequestTimeout = DEFAULT_TIMEOUT

python_vk_bot/application.py

@@ -0,0 +1,221 @@
+"""Serial dispatch with explicit lifecycle and bounded duplicate suppression."""
+
+import asyncio
+import logging
+from collections import OrderedDict
+from collections.abc import Awaitable, Callable
+from contextlib import aclosing
+from types import TracebackType
+from typing import Self
+
+from .bot import Bot
+from .context import Context
+from .errors import LifecycleError
+from .handlers import Handler
+from .long_poll import LongPoll
+from .models import Update
+
+type ErrorCallback = Callable[[Update | None, Context], Awaitable[None]]
+type LifecycleHook = Callable[[Application], Awaitable[None]]
+
+logger = logging.getLogger(__name__)
+
+
+class Application:
+    def __init__(
+        self,
+        bot: Bot,
+        group_id: int,
+        *,
+        deduplication_size: int = 4096,
+        post_init: LifecycleHook | None = None,
+        post_shutdown: LifecycleHook | None = None,
+    ) -> None:
+        if group_id <= 0 or deduplication_size < 0:
+            raise ValueError("group_id must be positive and deduplication_size nonnegative")
+        self.bot = bot
+        self.group_id = group_id
+        self.bot_data: dict[str, object] = {}
+        self.user_data: dict[int, dict[str, object]] = {}
+        self.peer_data: dict[int, dict[str, object]] = {}
+        self._handlers: dict[int, list[Handler]] = {}
+        self._error_handlers: list[ErrorCallback] = []
+        self._seen: OrderedDict[str, None] = OrderedDict()
+        self._deduplication_size = deduplication_size
+        self._post_init = post_init
+        self._post_shutdown = post_shutdown
+        self._dispatch_lock = asyncio.Lock()
+        self._lifecycle_lock = asyncio.Lock()
+        self._initialized = False
+        self._context_active = False
+        self._running = False
+        self._polling_task: asyncio.Task[None] | None = None
+        self._processing_task: asyncio.Task[object] | None = None
+
+    @property
+    def running(self) -> bool:
+        return self._running
+
+    def add_handler(self, handler: Handler, *, group: int = 0) -> None:
+        if self._running:
+            raise LifecycleError("Register handlers before starting the application")
+        self._handlers.setdefault(group, []).append(handler)
+
+    def add_error_handler(self, callback: ErrorCallback) -> None:
+        if self._running:
+            raise LifecycleError("Register error handlers before starting the application")
+        self._error_handlers.append(callback)
+
+    async def initialize(self) -> None:
+        async with self._lifecycle_lock:
+            if self._initialized:
+                return
+            try:
+                await self.bot.initialize()
+                if self._post_init is not None:
+                    await self._post_init(self)
+            except BaseException:
+                await self.bot.shutdown()
+                raise
+            self._initialized = True
+
+    async def start(self) -> None:
+        if not self._initialized:
+            raise LifecycleError("Initialize the application before starting it")
+        self._running = True
+
+    async def stop(self) -> None:
+        """Stop intake, cancel owned polling, and wait for active dispatch to finish.
+
+        A handler may call stop: its current dispatch completes before polling exits.
+        """
+        self._running = False
+        task = self._polling_task
+        current = asyncio.current_task()
+        if task is not None and task is not current:
+            task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+        if self._processing_task is not current:
+            async with self._dispatch_lock:
+                pass
+
+    async def shutdown(self) -> None:
+        if self._processing_task is asyncio.current_task():
+            raise LifecycleError("Use stop() inside a handler; shutdown belongs to the owner")
+        await self.stop()
+        async with self._lifecycle_lock:
+            if not self._initialized:
+                return
+            try:
+                await self.bot.shutdown()
+            finally:
+                self._initialized = False
+            if self._post_shutdown is not None:
+                await self._post_shutdown(self)
+
+    async def __aenter__(self) -> Self:
+        if self._initialized or self._context_active:
+            raise LifecycleError("Application context managers cannot be nested")
+        self._context_active = True
+        try:
+            await self.initialize()
+            await self.start()
+        except BaseException:
+            self._context_active = False
+            raise
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        try:
+            await self.shutdown()
+        finally:
+            self._context_active = False
+
+    def _context(self, update: Update | None, error: Exception | None = None) -> Context:
+        user_id = update.user_id if update is not None else None
+        peer_id = update.peer_id if update is not None else None
+        return Context(
+            application=self,
+            bot=self.bot,
+            user_data=self.user_data.setdefault(user_id, {}) if user_id is not None else {},
+            peer_data=self.peer_data.setdefault(peer_id, {}) if peer_id is not None else {},
+            bot_data=self.bot_data,
+            error=error,
+        )
+
+    async def _report_error(self, update: Update | None, error: Exception) -> None:
+        context = self._context(update, error)
+        logger.error("Update processing failed (%s)", type(error).__name__)
+        for callback in self._error_handlers:
+            try:
+                await callback(update, context)
+            except Exception as callback_error:
+                logger.error("Error handler failed (%s)", type(callback_error).__name__)
+
+    async def process_update(self, update: Update) -> bool:
+        """Return False for a duplicate, True after dispatch; propagate handler errors."""
+        if self._processing_task is asyncio.current_task():
+            raise LifecycleError("Recursive update dispatch is not supported")
+        async with self._dispatch_lock:
+            if not self._running:
+                raise LifecycleError("Application is not running")
+            if update.group_id != self.group_id:
+                raise ValueError("Update belongs to another community")
+            if update.event_id in self._seen:
+                return False
+            self._processing_task = asyncio.current_task()
+            try:
+                context = self._context(update)
+                for group in sorted(self._handlers):
+                    for handler in self._handlers[group]:
+                        if handler.check_update(update):
+                            await handler.handle_update(update, context)
+                            break
+            except Exception as error:
+                await self._report_error(update, error)
+                raise
+            finally:
+                self._processing_task = None
+            if self._deduplication_size:
+                self._seen[update.event_id] = None
+                if len(self._seen) > self._deduplication_size:
+                    self._seen.popitem(last=False)
+            return True
+
+    async def _poll(self, long_poll: LongPoll) -> None:
+        async with aclosing(long_poll.listen()) as updates:
+            async for update in updates:
+                if not self._running:
+                    break
+                try:
+                    await self.process_update(update)
+                except Exception:
+                    # Dispatch already reported the error; never replay partial side effects.
+                    logger.warning("Skipping failed update in polling mode")
+                if not self._running:
+                    break
+
+    async def run_polling(self, *, wait: int = 25) -> None:
+        """Run until stop or cancellation; own startup and shutdown, not the event loop."""
+        if self._polling_task is not None:
+            raise LifecycleError("Polling is already running")
+        long_poll = LongPoll(self.bot, self.group_id, wait=wait)
+        async with self:
+            task = asyncio.create_task(self._poll(long_poll), name="vk-long-poll")
+            self._polling_task = task
+            try:
+                await task
+            except asyncio.CancelledError:
+                current = asyncio.current_task()
+                if current is not None and current.cancelling():
+                    raise
+            except Exception as error:
+                await self._report_error(None, error)
+                raise
+            finally:
+                self._polling_task = None

python_vk_bot/bot.py

@@ -0,0 +1,184 @@
+"""Typed wrappers for supported VK community bot methods."""
+
+import json
+import secrets
+from collections.abc import Mapping
+from types import TracebackType
+from typing import Self
+
+import httpx
+from pydantic import BaseModel, JsonValue, SecretStr, TypeAdapter, ValidationError
+
+from ._config import DEFAULT_API_VERSION, DEFAULT_TIMEOUT, TransportConfig
+from .errors import InvalidResponseError
+from .models.api import LongPollServer
+from .models.messages import Keyboard, Message, MessagePage, User
+from .transport import HTTPTransport, Parameter
+
+
+def _parse[T: BaseModel](model: type[T], payload: JsonValue) -> T:
+    try:
+        return model.model_validate(payload)
+    except ValidationError:
+        raise InvalidResponseError(f"Invalid {model.__name__} response") from None
+
+
+def _integer(payload: JsonValue) -> int:
+    if type(payload) is not int:
+        raise InvalidResponseError("Expected an integer VK response")
+    return payload
+
+
+def _random_id(value: int | None) -> int:
+    if value is None:
+        return secrets.randbelow(2**31 - 1) + 1
+    if type(value) is not int or not -(2**31) <= value < 2**31 or value == 0:
+        raise ValueError("random_id must be a nonzero signed 32-bit integer")
+    return value
+
+
+class Bot:
+    def __init__(
+        self,
+        token: str | SecretStr,
+        *,
+        api_version: str = DEFAULT_API_VERSION,
+        timeout: float = DEFAULT_TIMEOUT,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        config = TransportConfig(
+            token=token if isinstance(token, SecretStr) else SecretStr(token),
+            api_version=api_version,
+            timeout=timeout,
+        )
+        self.transport = HTTPTransport(config, client=client)
+
+    async def initialize(self) -> None:
+        await self.transport.initialize()
+
+    async def shutdown(self) -> None:
+        await self.transport.shutdown()
+
+    async def __aenter__(self) -> Self:
+        await self.initialize()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.shutdown()
+
+    async def request(self, method: str, parameters: Mapping[str, Parameter]) -> JsonValue:
+        """Access a raw VK result. Nested parameters must be explicitly JSON encoded."""
+        return await self.transport.call(method, parameters)
+
+    async def get_long_poll_server(self, group_id: int) -> LongPollServer:
+        if group_id <= 0:
+            raise ValueError("group_id must be positive")
+        result = await self.request("groups.getLongPollServer", {"group_id": group_id})
+        return _parse(LongPollServer, result)
+
+    async def get_user_info(self, user_id: int) -> User | None:
+        result = await self.request("users.get", {"user_ids": user_id, "fields": "screen_name"})
+        try:
+            users = TypeAdapter(list[User]).validate_python(result)
+        except ValidationError:
+            raise InvalidResponseError("Invalid users.get response") from None
+        return users[0] if users else None
+
+    async def get_message(self, peer_id: int, conversation_message_id: int) -> Message | None:
+        result = await self.request(
+            "messages.getByConversationMessageId",
+            {"peer_id": peer_id, "conversation_message_ids": conversation_message_id},
+        )
+        page = _parse(MessagePage, result)
+        return page.items[0] if page.items else None
+
+    async def send_message(
+        self,
+        peer_id: int,
+        text: str = "",
+        *,
+        random_id: int | None = None,
+        keyboard: Keyboard | None = None,
+        attachment: str | None = None,
+        dont_parse_links: bool = False,
+    ) -> int:
+        if not text and not attachment:
+            raise ValueError("Provide text or an attachment")
+        result = await self.request(
+            "messages.send",
+            {
+                "peer_id": peer_id,
+                "message": text,
+                "random_id": _random_id(random_id),
+                "keyboard": keyboard.model_dump_json(exclude_none=True) if keyboard else None,
+                "attachment": attachment,
+                "dont_parse_links": dont_parse_links,
+            },
+        )
+        return _integer(result)
+
+    async def edit_message(
+        self,
+        peer_id: int,
+        text: str,
+        *,
+        message_id: int | None = None,
+        conversation_message_id: int | None = None,
+        keyboard: Keyboard | None = None,
+        dont_parse_links: bool = False,
+    ) -> bool:
+        if (message_id is None) == (conversation_message_id is None):
+            raise ValueError("Provide exactly one message identifier")
+        result = await self.request(
+            "messages.edit",
+            {
+                "peer_id": peer_id,
+                "message": text,
+                "message_id": message_id,
+                "cmid": conversation_message_id,
+                "keyboard": keyboard.model_dump_json(exclude_none=True) if keyboard else None,
+                "dont_parse_links": dont_parse_links,
+            },
+        )
+        return _integer(result) == 1
+
+    async def forward_message(
+        self, peer_id: int, message: Message, *, random_id: int | None = None
+    ) -> int:
+        # The source is the conversation, which need not be the author's user ID.
+        forward = {
+            "peer_id": message.peer_id,
+            "conversation_message_ids": [message.conversation_message_id],
+        }
+        result = await self.request(
+            "messages.send",
+            {
+                "peer_id": peer_id,
+                "random_id": _random_id(random_id),
+                "forward": json.dumps(forward),
+            },
+        )
+        return _integer(result)
+
+    async def send_message_event_answer(
+        self,
+        event_id: str,
+        user_id: int,
+        peer_id: int,
+        event_data: Mapping[str, JsonValue] | None = None,
+    ) -> bool:
+        result = await self.request(
+            "messages.sendMessageEventAnswer",
+            {
+                "event_id": event_id,
+                "user_id": user_id,
+                "peer_id": peer_id,
+                "event_data": json.dumps(dict(event_data)) if event_data is not None else None,
+            },
+        )
+        return _integer(result) == 1