pykabot 0.4.0__py3-none-any.whl

kabot/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,130 @@
+# Third-party notices
+
+The read-only chat pagination/title fields and TLS service-identity observations
+also reference [agent-messenger](https://github.com/agent-messenger/agent-messenger),
+commits `e58739d80305d5e8ddf72e9aad085c2069f4fd3c` and
+`f4990c8d6172d0b8c4e1523262ee94349c120ff7`. The Python algorithms were written
+independently with bounded cursors and explicit identity checks. For attribution:
+
+MIT License
+
+Copyright (c) 2026 Jeon Suyeol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## Initial LOCO implementation references
+
+The experimental LOCO framing, field identifiers, reference RSA public key and
+cryptographic handshake format, desktop-profile session requests and message
+envelopes in `src/kabot/loco/`
+were implemented with reference to the MIT-licensed project below. The Python
+implementation adds strict method validation, configurable bounded parsing,
+incremental decoding and authenticated-record checks.
+
+- Project: [openkakao-cli](https://github.com/JungHoonGhae/openkakao-cli)
+- Pinned source commit: `6ca6ea2fd05a6660c4a80c0b61b43b416653d1d5`
+- Sources: `src/loco/packet.rs`, `src/loco/crypto.rs`, `src/loco/client.rs`,
+  `src/loco/message.rs`, `src/commands/send.rs`
+- Reference format and public key are historical source observations; they
+  do not establish current live server compatibility or successful login.
+
+## openkakao-cli license
+
+MIT License
+
+Copyright (c) 2026 Lucas (JungHoonGhae)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## node-kakao open-chat profile protocol reference
+
+Open-chat profile serialization and switching use schemas described by
+[node-kakao](https://github.com/storycraft/node-kakao), pinned commit
+`8512e4699e2cd4c26516b80d38b57b2f85a6cc8a`. Relevant sources are
+`open-link-profile.ts`, `talk-open-channel-session.ts`, and
+`talk-open-link-session.ts`. Reference source scripts were not executed.
+
+MIT License
+
+Copyright (c) 2021 storycraft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## loco-wrapper protocol reference
+
+The independent Android authentication request builders and Android LOCO profile
+use protocol facts described in
+[loco-wrapper](https://github.com/NetRiceCake/loco-wrapper), pinned commit
+`1dec3b79e59f2776ebd1f03e60744162ff195b24` (2026-10-03), particularly
+`KakaoApi.java` and outbound login request models. The following notice is
+included for reference and attribution. Source scripts were not executed.
+
+MIT License
+
+Copyright (c) 2026 NetRiceCake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kabot/__init__.py

@@ -0,0 +1,37 @@
+"""Kabot: client-free Kakao channel bots and official personal message APIs."""
+
+from .bot import Bot, Context
+from .models import (
+    Response,
+    SkillRequest,
+    card,
+    image,
+    link_button,
+    message_button,
+    quick_reply,
+    text,
+)
+from .rest import KakaoAPIError, KakaoClient, OAuthTokens, authorization_url, validate_state
+from .server import create_app
+from .state import SQLiteStore
+
+__version__ = "0.4.0"
+__all__ = [
+    "Bot",
+    "Context",
+    "Response",
+    "SkillRequest",
+    "SQLiteStore",
+    "create_app",
+    "text",
+    "image",
+    "card",
+    "message_button",
+    "link_button",
+    "quick_reply",
+    "KakaoAPIError",
+    "KakaoClient",
+    "OAuthTokens",
+    "authorization_url",
+    "validate_state",
+]

kabot/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

kabot/bot.py

@@ -0,0 +1,132 @@
+"""Transport-independent command routing for Kakao channel skills."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import re
+from dataclasses import dataclass, field
+from typing import Any, Callable, Pattern
+
+from .models import Response, SkillRequest, text
+from .state import SQLiteStore
+
+
+@dataclass
+class Context:
+    request: SkillRequest
+    store: SQLiteStore | None = None
+    args: str = ""
+    match: re.Match | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def user_id(self) -> str:
+        return self.request.user_request.user.id
+
+    @property
+    def scope(self) -> str:
+        # Bot user keys are scoped to each bot, not global Kakao account IDs.
+        return f"{self.request.bot.get('id', 'local')}:{self.user_id}"
+
+    @property
+    def message(self) -> str:
+        return self.request.user_request.utterance
+
+    @property
+    def params(self) -> dict[str, Any]:
+        return self.request.action.params
+
+
+@dataclass
+class Route:
+    kind: str
+    value: str | Pattern
+    handler: Callable
+    deferred: bool = False
+
+
+async def invoke(function: Callable, *args: Any) -> Any:
+    if inspect.iscoroutinefunction(function):
+        return await function(*args)
+    result = await asyncio.to_thread(function, *args)
+    return await result if inspect.isawaitable(result) else result
+
+
+class Bot:
+    def __init__(
+        self,
+        *,
+        prefix: str = "/",
+        store: SQLiteStore | None = None,
+        fallback: str = "알 수 없는 명령입니다. /도움말을 입력해 주세요.",
+    ):
+        self.prefix, self.store, self.fallback = prefix, store, fallback
+        self.routes: list[Route] = []
+        self.before_hooks: list[Callable] = []
+
+    def _register(self, kind: str, value: str | Pattern, *, deferred: bool = False):
+        def decorator(function: Callable):
+            self.routes.append(Route(kind, value, function, deferred))
+            return function
+
+        return decorator
+
+    def command(self, name: str, *, deferred: bool = False):
+        if not name or any(c.isspace() for c in name):
+            raise ValueError("command name must be a non-empty single word")
+        return self._register("command", name, deferred=deferred)
+
+    def hears(self, pattern: str, *, deferred: bool = False):
+        return self._register("regex", re.compile(pattern), deferred=deferred)
+
+    def action(self, name: str, *, deferred: bool = False):
+        return self._register("action", name, deferred=deferred)
+
+    def on_message(self, *, deferred: bool = False):
+        return self._register("all", "", deferred=deferred)
+
+    def before(self, function: Callable):
+        """Return a response to stop routing, or None to continue."""
+        self.before_hooks.append(function)
+        return function
+
+    def resolve(self, request: SkillRequest) -> tuple[Route | None, Context]:
+        ctx = Context(request, self.store)
+        message = ctx.message.strip()
+        for route in self.routes:
+            if route.kind == "command":
+                parts = message.split(maxsplit=1)
+                if not parts or parts[0] != self.prefix + route.value:
+                    continue
+                ctx.args = parts[1] if len(parts) > 1 else ""
+            elif route.kind == "regex":
+                ctx.match = route.value.search(message)
+                if ctx.match is None:
+                    continue
+            elif route.kind == "action" and request.action.name != route.value:
+                continue
+            return route, ctx
+        return None, ctx
+
+    async def execute(self, route: Route | None, ctx: Context) -> Response:
+        for hook in self.before_hooks:
+            result = await invoke(hook, ctx)
+            if result is not None:
+                return self._response(result)
+        return self._response(await invoke(route.handler, ctx) if route else self.fallback)
+
+    @staticmethod
+    def _response(value: Response | str) -> Response:
+        result = text(value) if isinstance(value, str) else value
+        if not isinstance(result, Response):
+            raise TypeError("A bot handler must return a string or kabot.Response")
+        result.to_dict()
+        return result
+
+    async def handle(self, payload: dict | SkillRequest) -> Response:
+        """Local/test dispatch. Does not send messages or enforce HTTP deadlines."""
+        request = (
+            payload if isinstance(payload, SkillRequest) else SkillRequest.model_validate(payload)
+        )
+        return await self.execute(*self.resolve(request))

kabot/cli.py

@@ -0,0 +1,310 @@
+"""Local scaffold, simulator and server runner. Never reads Kakao desktop data."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import importlib
+import json
+import os
+import secrets
+import sys
+from pathlib import Path
+
+from .bot import Bot
+from .server import create_app
+
+SCAFFOLD = """from kabot import Bot, SQLiteStore, quick_reply, text
+
+bot = Bot(store=SQLiteStore("bot.sqlite3"))
+
+@bot.command("도움말")
+def help(ctx):
+    return text("/안녕 이름, /방문, /메모 내용, /메모확인").with_quick_replies(
+        quick_reply("인사", "/안녕 친구"), quick_reply("방문 횟수", "/방문"))
+
+@bot.command("안녕")
+def hello(ctx):
+    return f"안녕하세요, {ctx.args or '친구'}님!"
+
+@bot.command("방문")
+def visit(ctx):
+    count = ctx.store.increment(ctx.scope, "visits")
+    return f"{count}번째 방문입니다."
+
+@bot.command("메모")
+def memo(ctx):
+    if not ctx.args:
+        return "사용법: /메모 기억할 내용"
+    ctx.store.set(ctx.scope, "memo", ctx.args, ttl=86400)
+    return "하루 동안 기억할게요."
+
+@bot.command("메모확인")
+def read_memo(ctx):
+    return ctx.store.get(ctx.scope, "memo", "저장한 메모가 없어요.")
+"""
+
+PERSONAL_SCAFFOLD = """from kabot import Bot, SQLiteStore
+
+bot = Bot(store=SQLiteStore("personal-bot.sqlite3"))
+
+@bot.command("도움말")
+def help_command(ctx):
+    return "/핑, /안녕 이름, /방문 명령을 사용할 수 있습니다."
+
+@bot.command("핑")
+async def ping(ctx):
+    return "퐁!"
+
+@bot.command("안녕")
+def hello(ctx):
+    return f"안녕하세요, {ctx.args or '친구'}님!"
+
+@bot.command("방문")
+def visit(ctx):
+    return f"{ctx.store.increment(ctx.scope, 'visits')}번째 방문입니다."
+"""
+
+
+def load_bot(reference: str) -> Bot:
+    module_name, separator, name = reference.partition(":")
+    if not separator or not module_name or not name:
+        raise ValueError("Use module:bot, for example mybot:bot")
+    # Import operator-provided code from the working directory, as with uvicorn.
+    sys.path.insert(0, str(Path.cwd()))
+    bot = getattr(importlib.import_module(module_name), name)
+    if not isinstance(bot, Bot):
+        raise TypeError("The referenced object must be kabot.Bot")
+    return bot
+
+
+async def simulate(bot: Bot) -> None:
+    print("로컬 시뮬레이터입니다. 실제 카카오톡에는 전송하지 않습니다. /종료로 끝냅니다.")
+    while True:
+        try:
+            message = await asyncio.to_thread(input, "> ")
+        except EOFError:
+            return
+        if message == "/종료":
+            return
+        payload = {
+            "bot": {"id": "local"},
+            "userRequest": {"utterance": message, "user": {"id": "local-user"}},
+        }
+        response = await bot.handle(payload)
+        print(json.dumps(response.to_dict(), ensure_ascii=False, indent=2))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="kabot", description="Kakao channel skill bot tools")
+    sub = parser.add_subparsers(dest="command", required=True)
+    init = sub.add_parser("init", help="Create an example bot without overwriting files")
+    init.add_argument("file", nargs="?", default="mybot.py")
+    init.add_argument(
+        "--personal", action="store_true", help="Create a text-only personal/group bot"
+    )
+    local = sub.add_parser("chat", help="Run a local simulator (no Kakao network traffic)")
+    local.add_argument("bot", default="mybot:bot", nargs="?")
+    run = sub.add_parser("run", help="Start a channel skill server")
+    run.add_argument("bot", default="mybot:bot", nargs="?")
+    run.add_argument("--host", default="127.0.0.1")
+    run.add_argument("--port", type=int, default=8000)
+    login = sub.add_parser(
+        "login", help="Interactive experimental Android login; never pass passwords as arguments"
+    )
+    login.add_argument("--session", default="personal-session.kabot")
+    login.add_argument(
+        "--status-file", help="Write redacted phase/status codes for local progress monitoring"
+    )
+    login.add_argument("--skip-loco-check", action="store_true")
+    login.add_argument(
+        "--replace",
+        action="store_true",
+        help="Unlock and replace an existing session, reusing its device ID",
+    )
+    chats = sub.add_parser(
+        "chats", help="Unlock an encrypted personal session and list chat IDs locally"
+    )
+    chats.add_argument("--session", default="personal-session.kabot")
+    profile = sub.add_parser(
+        "open-profile", help="List open links, read a room profile, or explicitly switch it"
+    )
+    profile.add_argument("--session", default="personal-session.kabot")
+    profile.add_argument("--chat-id", type=int)
+    profile.add_argument("--kind", choices=("main", "anonymous", "link"))
+    profile.add_argument("--nickname")
+    profile.add_argument(
+        "--profile-path", help="Existing Kakao image path, not a local file or URL"
+    )
+    profile.add_argument("--profile-link-id", type=int)
+    verify = sub.add_parser(
+        "verify", help="Unlock a saved session and check chat login without sending messages"
+    )
+    verify.add_argument("--session", default="personal-session.kabot")
+    verify.add_argument("--status-file")
+    bot_test = sub.add_parser(
+        "bot-test", help="Locally select a test room and authorize one ping reply"
+    )
+    bot_test.add_argument("--session", default="personal-session.kabot")
+    bot_test.add_argument("--status-file")
+    bot_test.add_argument("--target-room")
+    bot_test.add_argument("--allow-open", action="store_true")
+    gui = sub.add_parser(
+        "gui", help="Open a local user-operated session verification or login window"
+    )
+    gui.add_argument("--session", default="personal-session.kabot")
+    gui.add_argument("--status-file")
+    gui.add_argument("--mode", choices=("verify", "login", "bot-test"), default="verify")
+    gui.add_argument("--replace", action="store_true")
+    gui.add_argument("--target-room")
+    gui.add_argument("--allow-open", action="store_true")
+    personal = sub.add_parser("personal", help="Run an experimental text bot in selected chats")
+    personal.add_argument("bot", default="mybot:bot", nargs="?")
+    personal.add_argument("--session", default="personal-session.kabot")
+    personal.add_argument("--chat-id", type=int, action="append", required=True)
+    sub.add_parser("secret", help="Generate a secret for KABOT_WEBHOOK_SECRET")
+    sub.add_parser("doctor", help="Show supported transports and configuration status")
+    args = parser.parse_args()
+    try:
+        if args.command == "init":
+            with Path(args.file).open("x", encoding="utf-8") as output:
+                output.write(PERSONAL_SCAFFOLD if args.personal else SCAFFOLD)
+            created = Path(args.file)
+            print(
+                f"Created {created}. From {created.resolve().parent}, run: "
+                f"kabot chat {created.stem}:bot"
+            )
+        elif args.command == "secret":
+            print(secrets.token_urlsafe(32))
+        elif args.command == "doctor":
+            print(
+                "Channel skill server: supported (public HTTPS + Kakao channel configuration required)"
+            )
+            print(
+                "Personal official API: self/friend outbound messages; OAuth and permissions required"
+            )
+            print(
+                "Personal/group LOCO: experimental transport/session; live compatibility unverified"
+            )
+            print(
+                "Android26.8.2 password/device registration: experimental; account verification required"
+            )
+            print("Automatic token renewal and QR login: not implemented")
+            print("Webhook secret configured: " + str(bool(os.getenv("KABOT_WEBHOOK_SECRET"))))
+        elif args.command == "chat":
+            asyncio.run(simulate(load_bot(args.bot)))
+        elif args.command == "gui":
+            from .loco.gui import run_window
+
+            run_window(
+                args.session,
+                status_path=args.status_file,
+                mode=args.mode,
+                replace=args.replace,
+                target_name=args.target_room,
+                allow_open=args.allow_open,
+            )
+        elif args.command in ("login", "chats", "personal", "verify", "bot-test", "open-profile"):
+            from .loco import LocoConnectionError, LocoStatusError, PersonalClient, run_personal_bot
+            from .loco.auth import AndroidAuthError
+            from .loco.interactive import (
+                interactive_login,
+                manage_open_profile,
+                show_chats,
+                unlock_session,
+                verify_saved_session,
+            )
+
+            try:
+                if args.command == "login":
+                    asyncio.run(
+                        interactive_login(
+                            args.session,
+                            status_path=args.status_file,
+                            verify_loco=not args.skip_loco_check,
+                            replace=args.replace,
+                        )
+                    )
+                elif args.command == "chats":
+                    asyncio.run(show_chats(args.session))
+                elif args.command == "open-profile":
+                    from .loco import OpenChatProfile
+                    from .loco.client import positive_id
+
+                    if args.chat_id is not None:
+                        positive_id(args.chat_id, "chat_id")
+                    if args.kind is not None and args.chat_id is None:
+                        raise ValueError("--chat-id is required to change a room profile")
+                    if args.kind is None and any(
+                        v is not None
+                        for v in (args.nickname, args.profile_path, args.profile_link_id)
+                    ):
+                        raise ValueError("--kind is required with profile options")
+                    selection = (
+                        OpenChatProfile(
+                            args.kind,
+                            nickname=args.nickname,
+                            profile_path=args.profile_path,
+                            profile_link_id=args.profile_link_id,
+                        )
+                        if args.kind is not None
+                        else None
+                    )
+                    asyncio.run(
+                        manage_open_profile(args.session, chat_id=args.chat_id, profile=selection)
+                    )
+                elif args.command == "verify":
+                    asyncio.run(verify_saved_session(args.session, status_path=args.status_file))
+                elif args.command == "bot-test":
+                    from .loco.live_test import run_reply_test
+
+                    asyncio.run(
+                        run_reply_test(
+                            args.session,
+                            status_path=args.status_file,
+                            target_name=args.target_room,
+                            allow_open=args.allow_open,
+                        )
+                    )
+                else:
+                    bot = load_bot(args.bot)
+
+                    async def personal_main():
+                        credentials = await unlock_session(args.session)
+                        async with PersonalClient(credentials) as client:
+                            await client.connect()
+                            await run_personal_bot(bot, client, chat_ids=args.chat_id)
+
+                    asyncio.run(personal_main())
+            except (
+                AndroidAuthError,
+                LocoConnectionError,
+                LocoStatusError,
+                OSError,
+                TimeoutError,
+            ) as exc:
+                parser.exit(1, f"kabot: {exc}\n")
+            except KeyboardInterrupt:
+                parser.exit(130, "\nStopped.\n")
+        elif args.command == "run":
+            secret = os.getenv("KABOT_WEBHOOK_SECRET", "")
+            if not secret:
+                parser.error("Set KABOT_WEBHOOK_SECRET first; generate one with kabot secret")
+            app = create_app(
+                load_bot(args.bot),
+                webhook_secret=secret,
+                expected_bot_id=os.getenv("KABOT_BOT_ID") or None,
+                callback_hosts=tuple(
+                    h.strip() for h in os.getenv("KABOT_CALLBACK_HOSTS", "").split(",") if h.strip()
+                ),
+            )
+            import uvicorn
+
+            # URLs contain a webhook secret: do not print access logs.
+            uvicorn.run(app, host=args.host, port=args.port, access_log=False)
+    except (ValueError, TypeError, FileExistsError, ImportError, AttributeError) as exc:
+        parser.exit(1, f"kabot: {exc}\n")
+
+
+if __name__ == "__main__":
+    main()

kabot/loco/__init__.py

@@ -0,0 +1,57 @@
+"""Experimental, locally tested LOCO components. Live Kakao compatibility is unverified.
+
+Install with pip install 'kabot-python[loco]'. No account login credentials are discovered.
+"""
+
+from importlib.util import find_spec
+
+if find_spec("bson") is None or find_spec("cryptography") is None:
+    raise ImportError("Install the optional LOCO dependencies: pip install 'kabot-python[loco]'")
+
+from .adapter import run_personal_bot
+from .auth import (
+    ANDROID_26_8_2,
+    AndroidAuthClient,
+    AndroidAuthError,
+    AndroidAuthProfile,
+    AndroidTokens,
+    RegistrationChallenge,
+    RegistrationRequired,
+    RegistrationStatus,
+    generate_device_uuid,
+)
+from .client import Credentials, Message, PersonalClient, received_messages
+from .crypto import CryptoError, LocoEncryptor
+from .open_profile import OpenChatProfile
+from .packet import LocoPacket, PacketDecoder, PacketError
+from .session import EventOverflowError, LocoSession, LocoStatusError
+from .transport import Endpoint, LocoConnectionError, LocoTransport
+
+__all__ = [
+    "ANDROID_26_8_2",
+    "AndroidAuthClient",
+    "AndroidAuthError",
+    "AndroidAuthProfile",
+    "AndroidTokens",
+    "RegistrationChallenge",
+    "RegistrationRequired",
+    "RegistrationStatus",
+    "generate_device_uuid",
+    "Credentials",
+    "CryptoError",
+    "Endpoint",
+    "EventOverflowError",
+    "LocoConnectionError",
+    "LocoEncryptor",
+    "LocoPacket",
+    "LocoSession",
+    "LocoStatusError",
+    "LocoTransport",
+    "Message",
+    "OpenChatProfile",
+    "PacketDecoder",
+    "PacketError",
+    "PersonalClient",
+    "received_messages",
+    "run_personal_bot",
+]